8
In a MAM stream, every message holds a reference to the next one. To follow the stream when there is a snapshot you must always keep the ref to the next message.
Currently, to read the beginning of the stream after a snapshot you have to connect to a permanode.
(Source : https://youtu.be/_ZO2ysgzKkM at 1h23)
7
To piggyback off of Chris, you can have forward secrecy even with a merkle tree of one leaf (which is the same as a simple one-time signature).
However, there are a few things (some of which I outlined in this blog post) that you can as a consequence of having merkle trees in MAM.
You can split/fork the channel into topics
You can encrypt different ...
4
MAM doesn't dictate you how to distribute the key. You can use encrypted peer-to-peer connection, post service, carrier pigeons or the tangle itself. It's up to you.
3
You can change the URL in the provider field to a node that's on the Mainnet.
You can use this URL as an example: https://nodes.thetangle.org/
Or, you can run your own node.
Be sure to use a minimum weight magnitude of at least 14 for the Mainnet.
For example, for the code you linked to, you need to use something like the following:
const provider = '...
3
It's irrelevant, you don't need a seed to publish a MAM message since you don't sign the transaction:
Example: https://github.com/iota-community/javascript-iota-workshop/blob/master/code/7.1-mam-public-send.js
If your library for some reason requires a seed just make one up, you can just publish to any address without the seed belonging to it. The seed is ...
3
When you want to send data via MAM, you have to encode the data in a specific way. The encoded data will be inserted in the signature/message slot of your transaction (0-value txs don't need any signature).
This means that you can put as much data as this protocol allows you to. I'll put here a youtube video about MAM (the guy doing these tutorials is pretty ...
3
I just tested your code and it worked for me. This is an example of the response:
NVYRBTEAJAYAJMWIAHRMZNT9PQMIUWFTLQOB9RVAIWDLDOSZHPJCWEGNF9JTZLCTULRFCWFEAFAPUIMFM
Published
Object {numberofSteps: 14, kilometersWalked: 110, message: "Message from Alice", timestamp: "12/4/2019, 8:28:51 AM"}
To do this automatically, you could set up events in the code that ...
3
There is no value transfer within MAM.
It's a messaging api
https://github.com/iotaledger/MAM
3
When storing data on the Tangle using MAM, you actually issue 0 value transactions that encapsulate your data. As such, it is impossible to revoke the data once published. By throwing away the side key, you make it impossible to find the tx and decrypt it.
Here is some nice material for MAM, it may clear things out.
3
I used code downloaded from here.
Basically:
in public mode the publisher chooses a seed and keeps it secret.
Then he starts to publish messages on a channel represented by the first Merkle tree root generated with his seed.
The first message also contains the second Merkle tree root that will be used by the publisher to publish the second message and so ...
3
Transaction size is limited. An intensive data stream will be splitted into many transactions. Each transaction requires a small pow and the idea is that even if it is small, the pow will discourage usage of intensive data stream.
The expected way to use MAM for such use case is to just transfer securly kind of credentials encrypted on the tangle and use ...
2
The purpose of the nonce is explained in:
https://www.mobilefish.com/download/iota/masked_payload_part20.pdf
2
You can use a Key-Sharing technique like a Group Diffie-Hellman key agreement or you can mask (encrypt) the sideKey and channel-id using the Public keys of the receivers. As i know, there's a public-key cryptosystem called NTRU that is said it has resistance to quantum-computer-based attacks. So i think this is maybe the solution to this problem.
2
Since iota.lib.java is a community effort (not written by the foundation), I assume a MAM library would have to be written by the community as well. – mihi♦
2
I just ran across this implementation
https://antonionardella.it/mqtt-data-on-the-tangle-with-mam/
2
I do not hold a direct answer, I am sorry.
What I would like to add is that MAM is going to be deprecated with the upcoming Chrysalis Part 2 upgrade, therefore I suggest you look into IOTA Streams, that will take over MAM:
Read about the latest news in our Blog here:
https://blog.iota.org/iota-streams-update-september-2020-c3b8668e231e
2
MAM does not support value transfer
All transactions (also the ones that send 1i) are deleted by a snapshot (on non-permanodes), only the final balances remain.
Therefore if you need transactions to survive across snapshots, you'd better find (or run) a permanode. (The only permanode I know of is run by the admin of thetangle.org for his tangle explorer. ...
1
Splitting the data into fragments will work. Alternatively if you work with the IOTA streams library you should have more luck with big sizes.
https://github.com/iotaledger/streams
1
Yes, you can add new messages to a MAM stream by reloading the “mam state” and then simply publishing again. here is an example using javascript
https://github.com/Evanfeenstra/helix/blob/master/mam.js#L181
1
Yes exactly, each leaf is a new transaction.
However, since Mam transactions do not have any “value”, they do not actually need any validation. They are immediately available to fetch after they are published
1
Mam.fetch is not an async function, instead use the callback. You can make any “callback style” function into an async function by wrapping the call in a return new Promise((resolve,reject)=> .... Do a bit of research about Promises, this is a very common and useful pattern in Nodejs.
But i think your problem is secretKey needs to be converted to trytes
1
You just run Mam.fetch. You need to store the root somewhere, and the sideKey if you are using “restricted” mode.
1
What library do you use? You can check, if the transaction is referenced by a milestone. This is the ultimate confirmation for your transaction. If the milestone directly or indirectly confirms your transaction, the transaction is received by all full-nodes.
1
Key exchange is a problem not just for IOTA MAM but a lot of cryptographic algorithms especially for symmetric-key encryption.
How can I securely transmit the keys?
To get the key from one actor to another, you have to establish a connection between the two, where no third party can interfere with the messages sent along this connection. Cryptographers ...
1
Never used Pandas, you probably have to ask elsewhere to get an answer how to serialize your object
There are two methods of generating addresses. There is one way to generate the next free address (which you can attach to the tangle automatically), or you can generate an address by index (which will not attach it automatically). Anyway, as soon as you send ...
1
On the IOTA blog they state:
an additional nonce may be used as a revocable encryption key
If I understand it correctly (and I believe I saw this in a MAM POC somewhere), it can be used to withdraw access to a specific subscriber of a restricted MAM stream. However, I struggle to understand how this works.
source: https://blog.iota.org/introducing-...
1
To be honest, I am not sure whether you can be that careless about whether your transactions confirm.
There is no guarantee that unconfirmed transactions will (eventually) reach every node of the network. Also permanodes will probably not retain unconfirmed transactions forever (in case they reached the node originally). Also, it is hard to "timestamp" ...
1
As reported the use of mam.client.js is deprecated.
Try with the source from http://iotameetup.nl and watch this @ 1:21:00 as already suggested by this answer.
1
To try MAM I recommend using the instructions as per latest IOTA meetup in Amsterdam. You can download the source from http://iotameetup.nl/ and watch https://www.youtube.com/watch?v=_ZO2ysgzKkM @ 1:21:00 for more instructions. Worked fine for my getting started. Not sure if that matches the github repo.
1
I think the introduction by the core dev, Paul H, is fairly easy to understand. Have you taken a look? :)
https://blog.iota.org/introducing-masked-authenticated-messaging-e55c1822d50e
Only top voted, non community-wiki answers of a minimum length are eligible