Something went wrong. Try again.
Monorepo for Aesthetic.Computer aesthetic.computer
Something went wrong. Try again.
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961/** * beacon-node.mjs - Node.js Beacon P2P client * * Direct port of Beacon SDK's Matrix transport to Node.js. * Uses the same HTTP REST API that the browser SDK uses. * * Matrix Protocol (what Beacon uses): * - POST /_matrix/client/r0/login - authenticate * - GET /_matrix/client/r0/sync - poll for events (long polling) * - POST /_matrix/client/r0/createRoom - create rooms * - POST /_matrix/client/r0/rooms/{roomId}/join - join rooms * - PUT /_matrix/client/r0/rooms/{roomId}/send/m.room.message/{txnId} - send messages */
import { promises as fs } from "fs";import { join } from "path";import { generateKeyPairFromSeed, sign, convertPublicKeyToX25519, convertSecretKeyToX25519 } from "@stablelib/ed25519";import { clientSessionKeys, serverSessionKeys } from "@stablelib/x25519-session";import { hash } from "@stablelib/blake2b";import { encode } from "@stablelib/utf8";import { secretBox, openSecretBox } from "@stablelib/nacl";import { randomBytes } from "@stablelib/random";import sodium from "libsodium-wrappers";import bs58check from "bs58check";import qrcode from "qrcode-terminal";import { getPkhfromPk } from "@taquito/utils";
// Secretbox constants (same as Beacon SDK)const secretbox_NONCEBYTES = 24;const secretbox_MACBYTES = 16;
// Storage file for Node.jsconst BEACON_STORAGE_FILE = join(process.env.HOME, ".ac-beacon-storage.json");
// Matrix API base pathconst MATRIX_API = "/_matrix/client/r0";
// Wait for sodium to initializeconst sodiumReady = sodium.ready;
// Terminal colorsconst RESET = '\x1b[0m';const BOLD = '\x1b[1m';const DIM = '\x1b[2m';const CYAN = '\x1b[36m';const GREEN = '\x1b[32m';const YELLOW = '\x1b[33m';const RED = '\x1b[31m';
/** * Beacon Serializer - bs58check encode/decode JSON (matches @airgap/beacon-core) */class Serializer { async serialize(message) { const str = JSON.stringify(message); return bs58check.encode(Buffer.from(str)); } async deserialize(encoded) { const decodedBytes = bs58check.decode(encoded); const jsonString = Buffer.from(decodedBytes).toString('utf8'); return JSON.parse(jsonString); }}
/** * Encrypt message with symmetric key (matches encryptCryptoboxPayload) */function encryptCryptoboxPayload(message, sharedKey) { const nonce = randomBytes(secretbox_NONCEBYTES); const messageBytes = Buffer.from(message, 'utf8'); const ciphertext = secretBox(sharedKey, nonce, messageBytes); const combined = Buffer.concat([Buffer.from(nonce), Buffer.from(ciphertext)]); return toHex(combined);}
/** * Convert bytes to hex string */function toHex(bytes) { return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');}
/** * Convert hex string to Buffer */function fromHex(hex) { return Buffer.from(hex, 'hex');}
/** * Get BLAKE2b hash of public key (32 bytes) as hex - matches Beacon SDK getHexHash */function getPublicKeyHash(publicKey) { const hashed = hash(publicKey, 32); return toHex(hashed);}
/** * Matrix HTTP Client - direct port from Beacon SDK */class MatrixClient { constructor(baseUrl) { this.baseUrl = baseUrl; this.accessToken = null; this.syncToken = null; this.txnNo = 0; }
async request(method, endpoint, body = null, useAuth = true) { const url = `${this.baseUrl}${MATRIX_API}${endpoint}`; const headers = { 'Content-Type': 'application/json' }; if (useAuth && this.accessToken) { headers['Authorization'] = `Bearer ${this.accessToken}`; } const options = { method, headers }; if (body) options.body = JSON.stringify(body); const response = await fetch(url, options); if (!response.ok) { const error = await response.json().catch(() => ({})); throw new Error(`Matrix API error: ${response.status} - ${error.error || response.statusText}`); } return response.json(); }
/** * Login to Matrix server using Beacon's signature-based auth */ async login(userId, password, deviceId) { const result = await this.request('POST', '/login', { type: 'm.login.password', identifier: { type: 'm.id.user', user: userId }, password, device_id: deviceId }, false); this.accessToken = result.access_token; return result; }
/** * Long-poll for sync events */ async sync(timeout = 30000) { let endpoint = '/sync'; const params = new URLSearchParams(); if (this.syncToken) params.set('since', this.syncToken); if (timeout) params.set('timeout', timeout.toString()); if (params.toString()) endpoint += '?' + params.toString(); const result = await this.request('GET', endpoint); this.syncToken = result.next_batch; return result; }
/** * Join a room */ async joinRoom(roomId) { return this.request('POST', `/rooms/${encodeURIComponent(roomId)}/join`, {}); }
/** * Send a text message to a room */ async sendMessage(roomId, message) { const txnId = `m${Date.now()}.${this.txnNo++}`; return this.request('PUT', `/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${txnId}`, { msgtype: 'm.text', body: message }); }}
/** * Beacon P2P Client - handles pairing and message encryption */class BeaconP2PClient { constructor(relayServer = "beacon-node-1.diamond.papers.tech") { this.relayServer = relayServer; this.matrix = new MatrixClient(`https://${relayServer}`); this.keyPair = null; this.pairingRequest = null; }
/** * Initialize with a new keypair */ async init() { await sodiumReady; // Generate keypair from random seed const seed = crypto.randomUUID(); const seedHash = hash(encode(seed), 32); this.keyPair = generateKeyPairFromSeed(seedHash); return this; }
/** * Get public key as hex string */ getPublicKey() { return toHex(this.keyPair.publicKey); }
/** * Get public key hash (for Matrix user ID) */ getPublicKeyHash() { return getPublicKeyHash(this.keyPair.publicKey); }
/** * Generate pairing request for QR code */ generatePairingRequest(appName = "Aesthetic Computer") { const publicKey = this.getPublicKey(); const id = crypto.randomUUID(); this.pairingRequest = { type: "p2p-pairing-request", id, name: appName, publicKey, version: "3", relayServer: this.relayServer }; const serialized = bs58check.encode(Buffer.from(JSON.stringify(this.pairingRequest))); const deepLinkUrl = `tezos://?type=tzip10&data=${serialized}`; return { pairingRequest: this.pairingRequest, serialized, deepLinkUrl }; }
/** * Connect to Matrix relay server * Uses Beacon's signature-based authentication */ async connect() { // Get relay server timestamp for login (Beacon uses /_synapse/client/beacon/info) const infoUrl = `https://${this.relayServer}/_synapse/client/beacon/info`; const info = await fetch(infoUrl).then(r => r.json()); // Beacon SDK: const time = Math.floor(relayServer.timestamp) // const loginString = `login:${Math.floor(time / (5 * 60))}` const time = Math.floor(info.timestamp); const loginBucket = Math.floor(time / (5 * 60)); const loginString = `login:${loginBucket}`; console.log(`${DIM}Login bucket: ${loginBucket} (timestamp: ${time})${RESET}`); // Create login signature (same as Beacon SDK) const loginDigest = hash(encode(loginString), 32); const signature = sign(this.keyPair.secretKey, loginDigest); // Login with signature const userId = this.getPublicKeyHash(); const password = `ed:${toHex(signature)}:${this.getPublicKey()}`; const deviceId = toHex(this.keyPair.publicKey); console.log(`${DIM}Logging in as @${userId}:${this.relayServer}...${RESET}`); await this.matrix.login(userId, password, deviceId); console.log(`${GREEN}✓${RESET} Connected to Matrix relay`); return this; }
/** * Wait for wallet pairing response */ async waitForPairing(timeoutMs = 120000) { console.log(`${YELLOW}⏳ Waiting for wallet to connect...${RESET}`); const startTime = Date.now(); while (Date.now() - startTime < timeoutMs) { try { // Poll for new events (5 second timeout for responsiveness) const syncResult = await this.matrix.sync(5000); // Check for room invites if (syncResult.rooms?.invite) { for (const [roomId, room] of Object.entries(syncResult.rooms.invite)) { console.log(`${GREEN}✓${RESET} Received room invite: ${roomId.slice(0, 20)}...`); await this.matrix.joinRoom(roomId); console.log(`${GREEN}✓${RESET} Joined room`); } } // Check for messages in joined rooms if (syncResult.rooms?.join) { for (const [roomId, room] of Object.entries(syncResult.rooms.join)) { const events = room.timeline?.events || []; for (const event of events) { if (event.type === 'm.room.message' && event.content?.body) { const message = event.content.body; // Check for channel-open message (pairing response) if (message.startsWith('@channel-open:')) { console.log(`${GREEN}✓${RESET} Received pairing response!`); const pairingResponse = await this.decryptPairingResponse(message, event.sender, roomId); return pairingResponse; } } } } } } catch (err) { // Sync timeout is normal, continue polling if (!err.message.includes('timeout')) { console.log(`${DIM}Sync: ${err.message}${RESET}`); } } } throw new Error("Pairing timeout - no wallet connected"); }
/** * Decrypt pairing response from wallet using openCryptobox * The message is encrypted with sealCryptobox (asymmetric encryption) */ async decryptPairingResponse(message, sender, roomId) { // Message format: @channel-open:@<recipientHash>:<relayServer>:<encryptedHex> const splits = message.split(':'); const encryptedHex = splits[splits.length - 1]; const encrypted = fromHex(encryptedHex); // Extract sender info const senderHash = sender.split(':')[0].slice(1); // Remove @ prefix console.log(`${DIM}Decrypting pairing response...${RESET}`); try { // Use openCryptobox - the Beacon SDK's asymmetric decryption // First 32 bytes are ephemeral public key, rest is ciphertext const epk = encrypted.slice(0, 32); const ciphertext = encrypted.slice(32); // Convert our ed25519 keys to x25519 for decryption const kxSecretKey = sodium.crypto_sign_ed25519_sk_to_curve25519(this.keyPair.secretKey); const kxPublicKey = sodium.crypto_sign_ed25519_pk_to_curve25519(this.keyPair.publicKey); // Create nonce from BLAKE2b(epk || kxPublicKey) const nonceData = new Uint8Array(64); nonceData.set(epk, 0); nonceData.set(kxPublicKey, 32); const nonce = hash(nonceData, 24); // Decrypt using crypto_box_open (nacl box) const decrypted = sodium.crypto_box_open_easy(ciphertext, nonce, epk, kxSecretKey); // Parse the JSON pairing response const jsonStr = new TextDecoder().decode(decrypted); const pairingResponse = JSON.parse(jsonStr); console.log(`${GREEN}✓${RESET} Decrypted pairing response:`); console.log(` ${DIM}Name:${RESET} ${pairingResponse.name}`); console.log(` ${DIM}Public Key:${RESET} ${pairingResponse.publicKey?.slice(0, 16)}...`); console.log(` ${DIM}Relay Server:${RESET} ${pairingResponse.relayServer}`); // Store the peer info for future communication this.peer = { ...pairingResponse, senderId: sender, roomId }; // Note: The DApp does NOT send a pairing response back. // The wallet considers pairing complete after sending its response. // Temple may show "loading" until we send an actual request (like PermissionRequest). return pairingResponse; } catch (err) { console.log(`${YELLOW}Decryption failed: ${err.message}${RESET}`); // Return basic info even if decryption fails return { sender, senderHash, error: err.message }; } }
/** * Send our pairing response back to the wallet * This completes the handshake so the wallet knows we received their response */ async sendPairingResponse(walletPairingResponse, roomId) { console.log(`${DIM}Sending pairing response back to wallet...${RESET}`); try { // Our response (same structure as what wallet sent) const ourResponse = { id: this.pairingRequest.id, type: "p2p-pairing-response", name: this.pairingRequest.name, publicKey: this.getPublicKey(), version: this.pairingRequest.version, relayServer: this.relayServer }; // Encrypt for wallet using sealCryptobox const message = JSON.stringify(ourResponse); const encryptedMessage = await this.encryptForPeer(message, walletPairingResponse.publicKey); // Build recipient string for the wallet const walletPubKeyHash = getPublicKeyHash(fromHex(walletPairingResponse.publicKey)); const recipient = `@${walletPubKeyHash}:${walletPairingResponse.relayServer}`; // Format: @channel-open:<recipient>:<encryptedHex> const channelOpenMsg = `@channel-open:${recipient}:${encryptedMessage}`; // Send to the room await this.matrix.sendMessage(roomId, channelOpenMsg); console.log(`${GREEN}✓${RESET} Sent pairing response to wallet`); } catch (err) { console.log(`${YELLOW}Warning: Could not send pairing response: ${err.message}${RESET}`); } }
/** * Encrypt a message for a peer using sealCryptobox (asymmetric) */ async encryptForPeer(message, peerPublicKeyHex) { const peerPublicKey = fromHex(peerPublicKeyHex); // Convert peer's ed25519 public key to x25519 const peerX25519PublicKey = sodium.crypto_sign_ed25519_pk_to_curve25519(peerPublicKey); // Generate ephemeral keypair for this message const ephemeralKeyPair = sodium.crypto_box_keypair(); // Create nonce from BLAKE2b(ephemeralPublicKey || peerX25519PublicKey) const nonceData = new Uint8Array(64); nonceData.set(ephemeralKeyPair.publicKey, 0); nonceData.set(peerX25519PublicKey, 32); const nonce = hash(nonceData, 24); // Encrypt const messageBytes = encode(message); const ciphertext = sodium.crypto_box_easy(messageBytes, nonce, peerX25519PublicKey, ephemeralKeyPair.privateKey); // Prepend ephemeral public key to ciphertext const sealed = new Uint8Array(32 + ciphertext.length); sealed.set(ephemeralKeyPair.publicKey, 0); sealed.set(ciphertext, 32); return toHex(sealed); }
/** * Send a permission request to the wallet * This is required after pairing to actually get wallet access */ async sendPermissionRequest() { if (!this.peer) throw new Error("Not paired with wallet yet"); console.log(`${DIM}Sending permission request to wallet...${RESET}`); const senderId = await this.getSenderId(); // Build the permission request (Beacon v2 format) const permissionRequest = { type: "permission_request", version: "2", // Use v2 for Temple compatibility id: crypto.randomUUID(), senderId: senderId, appMetadata: { senderId: senderId, name: this.pairingRequest.name }, network: { type: "ghostnet" // or "mainnet" }, scopes: ["operation_request", "sign"] }; console.log(`${DIM}Permission request:${RESET}`, JSON.stringify(permissionRequest, null, 2)); // Serialize the message with bs58check (like Beacon SDK Serializer) const serializer = new Serializer(); const serializedMessage = await serializer.serialize(permissionRequest); console.log(`${DIM}Serialized (bs58check): ${serializedMessage.slice(0, 50)}...${RESET}`); // Encrypt using symmetric key derived from key exchange // DApp uses clientSessionKeys, sends with sharedTx (which Beacon calls .send) const encryptedMessage = await this.encryptMessageForPeer(serializedMessage); console.log(`${DIM}Encrypted message: ${encryptedMessage.slice(0, 50)}...${RESET}`); // Send to the room await this.matrix.sendMessage(this.peer.roomId, encryptedMessage); console.log(`${GREEN}✓${RESET} Sent permission request`); return permissionRequest; }
/** * Get our sender ID (hash of public key) - matches Beacon SDK getSenderId */ async getSenderId() { // Beacon SDK: hash(publicKey, 5) -> hex const pubKeyHash = hash(this.keyPair.publicKey, 5); return toHex(pubKeyHash); }
/** * Wait for permission response from wallet */ async waitForPermissionResponse(timeoutMs = 120000) { console.log(`${YELLOW}⏳ Waiting for wallet approval...${RESET}`); const startTime = Date.now(); while (Date.now() - startTime < timeoutMs) { try { const syncResult = await this.matrix.sync(5000); // Check for messages in joined rooms if (syncResult.rooms?.join) { for (const [roomId, room] of Object.entries(syncResult.rooms.join)) { const events = room.timeline?.events || []; for (const event of events) { if (event.type === 'm.room.message' && event.content?.body) { const message = event.content.body; // Skip channel-open messages (those are for pairing) if (message.startsWith('@channel-open:')) continue; // Try to decrypt as a permission response try { const decrypted = await this.decryptMessageFromPeer(message); if (decrypted) { // decrypted is already parsed (deserialize returns parsed JSON) const parsed = typeof decrypted === 'string' ? JSON.parse(decrypted) : decrypted; console.log(`${GREEN}✓${RESET} Received message from wallet:`, parsed.type); if (parsed.type === 'permission_response') { return parsed; } else if (parsed.type === 'acknowledge') { console.log(`${DIM}Received acknowledge message${RESET}`); } else if (parsed.type === 'disconnect') { throw new Error('Wallet rejected/disconnected'); } else if (parsed.type === 'error') { throw new Error(`Wallet error: ${parsed.errorType || parsed.message}`); } } } catch (decryptErr) { // Not a message we can decrypt, or parse error if (!decryptErr.message.includes('decrypt') && !decryptErr.message.includes('Payload too short')) { console.log(`${DIM}Message parsing: ${decryptErr.message}${RESET}`); } } } } } } } catch (err) { if (!err.message.includes('timeout')) { console.log(`${DIM}Sync: ${err.message}${RESET}`); } } } throw new Error("Permission request timeout - wallet did not respond"); }
/** * Decrypt a message from the wallet using symmetric encryption * Wallet uses serverSessionKeys to send (so we receive with client's receive key) * But Beacon SDK: DApp creates CryptoBoxServer to receive from wallet! */ async decryptMessageFromPeer(encryptedHex) { const encrypted = fromHex(encryptedHex); const peerPublicKey = fromHex(this.peer.publicKey); // Check minimum payload length (nonce + mac) if (encrypted.length < secretbox_NONCEBYTES + secretbox_MACBYTES) { throw new Error('Payload too short'); } // Convert keys to x25519 const myX25519Public = convertPublicKeyToX25519(this.keyPair.publicKey); const myX25519Secret = convertSecretKeyToX25519(this.keyPair.secretKey); const peerX25519Public = convertPublicKeyToX25519(peerPublicKey); // Beacon SDK: DApp uses createCryptoBoxServer to RECEIVE messages // (opposite of sending where we use createCryptoBoxClient) const sessionKeys = serverSessionKeys( { publicKey: myX25519Public, secretKey: myX25519Secret }, peerX25519Public ); const sharedKey = sessionKeys.receive; // Extract nonce (first 24 bytes) and ciphertext const nonce = encrypted.slice(0, secretbox_NONCEBYTES); const ciphertext = encrypted.slice(secretbox_NONCEBYTES); // Decrypt const decrypted = openSecretBox(sharedKey, nonce, ciphertext); if (!decrypted) { throw new Error('Decryption failed'); } // The decrypted content is a serialized (bs58check) string const serializedStr = new TextDecoder().decode(decrypted); // Deserialize from bs58check const serializer = new Serializer(); return await serializer.deserialize(serializedStr); }
/** * Send an operation request to the wallet (e.g., contract call) * @param {Object} operationDetails - The operation to execute * @param {string} operationDetails.kind - "transaction", "origination", etc. * @param {string} operationDetails.destination - Contract address * @param {string} operationDetails.amount - Amount in mutez (string) * @param {Object} operationDetails.parameters - Michelson parameters * @param {string} operationDetails.fee - Fee in mutez (optional) * @param {string} operationDetails.gasLimit - Gas limit (optional) * @param {string} operationDetails.storageLimit - Storage limit (optional) */ async sendOperationRequest(operationDetails) { console.log(`${DIM}Sending operation request to wallet...${RESET}`); const senderId = await this.getSenderId(); // Tezos operations use snake_case: gas_limit, storage_limit // Temple iOS has issues estimating, so we provide generous defaults const ops = Array.isArray(operationDetails) ? operationDetails : [operationDetails]; const normalizedOps = ops.map(op => { const cleanOp = { ...op }; // Remove any camelCase variants delete cleanOp.gasLimit; delete cleanOp.storageLimit; // Set snake_case values with generous estimates for contract calls // These are based on typical FA2 minting operations cleanOp.fee = op.fee || "200000"; // 0.2 XTZ cleanOp.gas_limit = op.gas_limit || "50000"; // 50k gas cleanOp.storage_limit = op.storage_limit || "5000"; // 5k storage bytes return cleanOp; }); // Build the operation request (Beacon v2 format) const operationRequest = { type: "operation_request", version: "2", id: crypto.randomUUID(), senderId: senderId, network: { type: "ghostnet", rpcUrl: "https://ghostnet.ecadinfra.com" }, operationDetails: normalizedOps, sourceAddress: this.permissionResponse?.address || this.permissionResponse?.publicKey }; console.log(`${DIM}Operation request:${RESET}`, JSON.stringify(operationRequest, null, 2)); // Serialize the message const serializer = new Serializer(); const serializedMessage = await serializer.serialize(operationRequest); // Encrypt using symmetric key derived from key exchange const encryptedMessage = await this.encryptMessageForPeer(serializedMessage); // Send to the room await this.matrix.sendMessage(this.peer.roomId, encryptedMessage); console.log(`${GREEN}✓${RESET} Sent operation request`); return operationRequest; }
/** * Wait for operation response from wallet */ async waitForOperationResponse(timeoutMs = 120000) { console.log(`${YELLOW}⏳ Waiting for wallet to sign operation...${RESET}`); const startTime = Date.now(); while (Date.now() - startTime < timeoutMs) { try { const syncResult = await this.matrix.sync(5000); // Check for messages in joined rooms if (syncResult.rooms?.join) { for (const [roomId, room] of Object.entries(syncResult.rooms.join)) { const events = room.timeline?.events || []; for (const event of events) { if (event.type === 'm.room.message' && event.content?.body) { const message = event.content.body; // Skip channel-open messages if (message.startsWith('@channel-open:')) continue; try { const decrypted = await this.decryptMessageFromPeer(message); if (decrypted) { const parsed = typeof decrypted === 'string' ? JSON.parse(decrypted) : decrypted; console.log(`${GREEN}✓${RESET} Received message from wallet:`, parsed.type); if (parsed.type === 'operation_response') { return parsed; } else if (parsed.type === 'acknowledge') { console.log(`${DIM}Received acknowledge message${RESET}`); } else if (parsed.type === 'error') { throw new Error(`Wallet error: ${parsed.errorType || parsed.message || 'Operation rejected'}`); } } } catch (decryptErr) { if (!decryptErr.message.includes('decrypt') && !decryptErr.message.includes('Payload too short')) { console.log(`${DIM}Message parsing: ${decryptErr.message}${RESET}`); } } } } } } } catch (err) { if (!err.message.includes('timeout')) { console.log(`${DIM}Sync: ${err.message}${RESET}`); } } } throw new Error("Operation request timeout - wallet did not respond"); }
/** * Encrypt a message for the peer using symmetric encryption (after pairing) * Uses shared secret derived from X25519 key exchange * Matches Beacon SDK: createCryptoBoxClient + encryptCryptoboxPayload */ async encryptMessageForPeer(message) { const peerPublicKey = fromHex(this.peer.publicKey); // Convert ed25519 keys to x25519 using @stablelib const myX25519Public = convertPublicKeyToX25519(this.keyPair.publicKey); const myX25519Secret = convertSecretKeyToX25519(this.keyPair.secretKey); const peerX25519Public = convertPublicKeyToX25519(peerPublicKey); // Derive shared key using clientSessionKeys (DApp is client, wallet is server) // This matches Beacon SDK's createCryptoBoxClient const sessionKeys = clientSessionKeys( { publicKey: myX25519Public, secretKey: myX25519Secret }, peerX25519Public ); // Use .send for sending (DApp sends with client's send key) const sharedKey = sessionKeys.send; console.log(`${DIM}Shared key (first 8 bytes): ${toHex(sharedKey.slice(0, 8))}...${RESET}`); // Encrypt with secretbox (nonce || ciphertext) return encryptCryptoboxPayload(message, sharedKey); }}
/** * Display QR code in terminal */export function displayQR(data, small = true) { console.log(`\n${BOLD}${CYAN}╔════════════════════════════════════════════════════════════════╗${RESET}`); console.log(`${BOLD}${CYAN}║ 📱 Scan with Temple Wallet (Beacon P2P) ║${RESET}`); console.log(`${BOLD}${CYAN}╚════════════════════════════════════════════════════════════════╝${RESET}\n`); // Generate QR synchronously to stdout qrcode.generate(data, { small }); console.log(`\n\n${DIM}Waiting for wallet connection...${RESET}\n\n`);}
/** * Full P2P pairing flow */export async function pairWallet(appName = "Aesthetic Computer") { console.log(`\n${BOLD}${CYAN}═══════════════════════════════════════════════════════════════════${RESET}`); console.log(`${BOLD}${CYAN} Beacon P2P Wallet Pairing ${RESET}`); console.log(`${BOLD}${CYAN}═══════════════════════════════════════════════════════════════════${RESET}\n`); // Create P2P client const client = await new BeaconP2PClient().init(); // Generate pairing request const { pairingRequest, serialized, deepLinkUrl } = client.generatePairingRequest(appName); console.log(`${GREEN}✓${RESET} Generated pairing request:`); console.log(` ${DIM}ID:${RESET} ${pairingRequest.id}`); console.log(` ${DIM}Name:${RESET} ${pairingRequest.name}`); console.log(` ${DIM}Public Key:${RESET} ${pairingRequest.publicKey.slice(0, 16)}...`); console.log(` ${DIM}Relay:${RESET} ${pairingRequest.relayServer}`); // Display QR code displayQR(deepLinkUrl); // Connect to Matrix relay await client.connect(); // Wait for wallet to respond const response = await client.waitForPairing(120000); if (response) { console.log(`\n${GREEN}✓ Wallet paired successfully!${RESET}`); console.log(` ${DIM}Name:${RESET} ${response.name}`); console.log(` ${DIM}Public Key:${RESET} ${response.publicKey?.slice(0, 16)}...`); // Send permission request to complete the flow // This makes the wallet show the permission approval screen await client.sendPermissionRequest(); // Wait for user to approve in wallet try { const permissionResponse = await client.waitForPermissionResponse(120000); console.log(`\n${GREEN}✓ Permission granted!${RESET}`); // Debug: show full response structure console.log(`${DIM}Full response:${RESET}`, JSON.stringify(permissionResponse, null, 2)); // Get public key from response const publicKey = permissionResponse.publicKey || permissionResponse.account?.publicKey || permissionResponse.accountInfo?.publicKey; // Address might be in response, or derive from public key let address = permissionResponse.address || permissionResponse.account?.address || permissionResponse.accountInfo?.address; // Derive address from public key if not provided directly if (!address && publicKey) { try { address = getPkhfromPk(publicKey); console.log(`${DIM}(Address derived from public key)${RESET}`); } catch (e) { console.log(`${DIM}Could not derive address: ${e.message}${RESET}`); } } // Store the derived address in the response for callers permissionResponse.address = address; console.log(` ${DIM}Address:${RESET} ${address || '(unknown)'}`); console.log(` ${DIM}Public Key:${RESET} ${publicKey?.slice(0, 16)}...`); console.log(` ${DIM}Network:${RESET} ${permissionResponse.network?.type}`); console.log(` ${DIM}Scopes:${RESET} ${permissionResponse.scopes?.join(', ')}`); // Store permission response in client for operation requests client.permissionResponse = permissionResponse; return { client, response, permissionResponse }; } catch (permErr) { console.log(`\n${RED}✗ Permission denied or timeout: ${permErr.message}${RESET}`); return { client, response, error: permErr.message }; } } else { console.log(`\n${RED}✗ Pairing failed${RESET}`); return null; }}
/** * Quick test of QR generation only (no Matrix connection) */export async function testQR() { console.log(`\n${BOLD}Testing Beacon QR code generation...${RESET}\n`); const client = await new BeaconP2PClient().init(); const { pairingRequest, serialized, deepLinkUrl } = client.generatePairingRequest(); console.log(`${GREEN}✓${RESET} Generated pairing request:`); console.log(` ID: ${pairingRequest.id}`); console.log(` Name: ${pairingRequest.name}`); console.log(` Public Key: ${pairingRequest.publicKey.slice(0, 16)}...`); console.log(` Version: ${pairingRequest.version}`); console.log(` Relay: ${pairingRequest.relayServer}`); console.log(` Serialized: ${serialized.slice(0, 30)}...`); console.log(` Length: ${serialized.length} chars`); console.log(`\n${CYAN}Deep Link URL for QR:${RESET}`); console.log(` ${deepLinkUrl.slice(0, 60)}...\n`); // Display QR with deep link URL displayQR(deepLinkUrl); return { pairingRequest, serialized, deepLinkUrl };}
/** * Send a contract call operation via a connected Beacon client * @param {BeaconP2PClient} client - Connected Beacon client * @param {string} contractAddress - Contract to call * @param {string} entrypoint - Entrypoint name * @param {Object} args - Michelson arguments * @param {string} amount - Amount in XTZ (optional, default "0") */export async function sendContractCall(client, contractAddress, entrypoint, args, amountMutez = "0") { if (!client.permissionResponse?.address) { throw new Error("Wallet not connected - run pairWallet first"); } // Amount is already in mutez const amountStr = String(amountMutez); const amountXtz = (parseFloat(amountStr) / 1_000_000).toFixed(2); console.log(`\n${BOLD}${CYAN}═══════════════════════════════════════════════════════════════════${RESET}`); console.log(`${BOLD}${CYAN} Sending Contract Call via Temple ${RESET}`); console.log(`${BOLD}${CYAN}═══════════════════════════════════════════════════════════════════${RESET}\n`); console.log(`${DIM}Contract:${RESET} ${contractAddress}`); console.log(`${DIM}Entrypoint:${RESET} ${entrypoint}`); console.log(`${DIM}Amount:${RESET} ${amountXtz} ꜩ (${amountStr} mutez)`); console.log(`${DIM}Sender:${RESET} ${client.permissionResponse.address}`); const operation = { kind: "transaction", destination: contractAddress, amount: amountStr, parameters: { entrypoint: entrypoint, value: args } }; // Send operation request await client.sendOperationRequest(operation); // Wait for response const response = await client.waitForOperationResponse(120000); if (response.transactionHash) { console.log(`\n${GREEN}✓ Transaction confirmed!${RESET}`); console.log(`${DIM}Operation hash:${RESET} ${response.transactionHash}`); return response; } else { console.log(`\n${GREEN}✓ Operation response received${RESET}`); console.log(`${DIM}Response:${RESET}`, JSON.stringify(response, null, 2)); return response; }}
// Export the client classexport { BeaconP2PClient };
// Run if called directlyif (import.meta.url === `file://${process.argv[1]}`) { const args = process.argv.slice(2); if (args.includes('--pair') || args.includes('-p')) { pairWallet().catch(err => { console.error(`${RED}Error: ${err.message}${RESET}`); process.exit(1); }); } else { testQR().catch(console.error); }}