|
5 | 5 |
|
6 | 6 | XMTP assists in verifying identities and establishing the initial handshake to share the shared secret. Afterward, you manage **end-to-end encryption** independently, ensuring complete privacy by never exposing plaintext messages outside your environment. |
7 | 7 |
|
8 | | -1. **Use XMTP** only once to exchange public addresses. |
| 8 | +1. **Use XMTP** network only once to exchange a shared secret. You only need to know the sender/reciever xmtp address (evm). |
9 | 9 | 2. **Encrypt** messages locally with [`@xmtp/agent-starter`](https://github.com/xmtp-labs/agent-starter). |
10 | 10 | 3. **Send** only `nonce` + `ciphertext` across your own servers, **no plaintext** ever leaves your app. |
11 | | - |
12 | | -## Code example |
| 11 | +4. **Decrypt**: Recive the message using a standard web2 API and decrypt it. |
13 | 12 |
|
14 | 13 | Below is a simple example using Node.js and Express to demonstrate the encryption and decryption process. |
15 | 14 |
|
16 | | -### Import dependencies |
| 15 | +## Sending encrypted message |
| 16 | + |
| 17 | +#### Create XMTP client |
17 | 18 |
|
18 | 19 | ```javascript |
19 | | -import express from "express"; |
20 | | -import fetch from "node-fetch"; |
21 | 20 | import { xmtpClient } from "@xmtp/agent-starter"; |
22 | | -``` |
23 | | - |
24 | | -### Create XMTP clients |
25 | 21 |
|
26 | | -```javascript |
27 | 22 | async function main() { |
28 | 23 | const agentA = await xmtpClient({ name: "bob" }); |
29 | | - const agentB = await xmtpClient({ name: "alice" }); |
30 | 24 | // ... |
31 | 25 | } |
32 | 26 | ``` |
33 | 27 |
|
34 | | -### Encryption |
35 | | - |
36 | 28 | Agent A encrypts a message intended for Agent B. |
37 | 29 |
|
38 | | -```javascript |
39 | | -const { nonce, ciphertext } = await agentA.encrypt( |
40 | | - "Hello from A!", |
41 | | - agentB.address, |
42 | | -); |
| 30 | +```tsx |
| 31 | +setTimeout(async () => { |
| 32 | + const { nonce, ciphertext } = await agentA.encrypt( |
| 33 | + "Hello from A!", |
| 34 | + agentB.address, |
| 35 | + ); |
| 36 | + await fetch("http://localhost:3001/receive", { |
| 37 | + method: "POST", |
| 38 | + headers: { "Content-Type": "application/json" }, |
| 39 | + body: JSON.stringify({ nonce, ciphertext, fromAddress: agentA.address }), |
| 40 | + }); |
| 41 | +}, 2000); |
43 | 42 | ``` |
44 | 43 |
|
45 | 44 | - **agentA.encrypt**: This function encrypts the plaintext message "Hello from A!" using Agent B's address. |
46 | 45 | - **nonce**: A unique number used once to ensure that the same plaintext will encrypt to different ciphertexts each time. |
47 | 46 | - **ciphertext**: The encrypted version of the message that can be safely sent over the network. |
48 | 47 |
|
49 | | -### Decryption |
| 48 | +### Decrypting message |
50 | 49 |
|
51 | | -Agent B decrypts the received message. |
| 50 | +#### Create XMTP client |
52 | 51 |
|
53 | 52 | ```javascript |
54 | | -appB.post("/receive", async (req, res) => { |
55 | | - const { nonce, ciphertext, fromAddress } = req.body; |
56 | | - const msg = await agentB.decrypt(nonce, ciphertext, fromAddress); |
57 | | - console.log("B decrypted:", msg); |
58 | | - res.json({ success: true }); |
59 | | -}); |
60 | | -``` |
61 | | - |
62 | | -- **agentB.decrypt**: This function takes the `nonce`, `ciphertext`, and the sender's address (`fromAddress`) as inputs to decrypt the message. |
63 | | -- **msg**: The decrypted plaintext message that was originally sent by Agent A. |
64 | | - |
65 | | -### Express servers |
66 | | - |
67 | | -#### Server for Agent A |
68 | | - |
69 | | -```javascript |
70 | | -const appA = express(); |
71 | | -appA.use(express.json()); |
72 | | - |
73 | | -appA.post("/receive", async (req, res) => { |
74 | | - const { nonce, ciphertext, fromAddress } = req.body; |
75 | | - const msg = await agentA.decrypt(nonce, ciphertext, fromAddress); |
76 | | - console.log("A decrypted:", msg); |
77 | | - res.json({ success: true }); |
78 | | -}); |
| 53 | +import { xmtpClient } from "@xmtp/agent-starter"; |
79 | 54 |
|
80 | | -appA.listen(3000, () => console.log("Server A on 3000")); |
| 55 | +async function main() { |
| 56 | + const agentB = await xmtpClient({ name: "bob" }); |
| 57 | + // ... |
| 58 | +} |
81 | 59 | ``` |
82 | 60 |
|
83 | | -#### Server for Agent B |
| 61 | +Agent B decrypts the received message. |
84 | 62 |
|
85 | 63 | ```javascript |
86 | | -const appB = express(); |
87 | | -appB.use(express.json()); |
88 | | - |
89 | 64 | appB.post("/receive", async (req, res) => { |
90 | 65 | const { nonce, ciphertext, fromAddress } = req.body; |
91 | 66 | const msg = await agentB.decrypt(nonce, ciphertext, fromAddress); |
92 | 67 | console.log("B decrypted:", msg); |
93 | 68 | res.json({ success: true }); |
94 | 69 | }); |
95 | | - |
96 | | -appB.listen(3001, () => console.log("Server B on 3001")); |
97 | 70 | ``` |
98 | 71 |
|
99 | | -### Sending encrypted messages |
100 | | - |
101 | | -Agent A sends the encrypted message to Agent B's server. |
102 | | - |
103 | | -```javascript |
104 | | -setTimeout(async () => { |
105 | | - const { nonce, ciphertext } = await agentA.encrypt( |
106 | | - "Hello from A!", |
107 | | - agentB.address, |
108 | | - ); |
109 | | - await fetch("http://localhost:3001/receive", { |
110 | | - method: "POST", |
111 | | - headers: { "Content-Type": "application/json" }, |
112 | | - body: JSON.stringify({ nonce, ciphertext, fromAddress: agentA.address }), |
113 | | - }); |
114 | | -}, 2000); |
115 | | -``` |
| 72 | +- **agentB.decrypt**: This function takes the `nonce`, `ciphertext`, and the sender's address (`fromAddress`) as inputs to decrypt the message. |
| 73 | +- **msg**: The decrypted plaintext message that was originally sent by Agent A. |
116 | 74 |
|
117 | 75 | ### Summary |
118 | 76 |
|
|
0 commit comments