@anywalletkit/wallet-ton 0.2.4 → 0.2.5

package/README.md

@@ -68,7 +68,8 @@ const tk = await WalletManagerTon.fromTonMnemonic(words, { tonClient })
 
 The account never holds a key. Every signature is a `signer.sign(bytes, {scheme: 'ed25519', context})`
 call: `ton-external` over the hash of the V5R1 signing cell (after the preflight, which runs on a
-zero-signed body), `ton-message` over raw message bytes (`sign()`, ton_proof). Seed wallets get a
+zero-signed body), `ton-message` over raw message bytes (`sign()`), `ton-proof` / `ton-sign-data`
+over the TON Connect digests (`signTonProof`, `signTonConnectData`). Seed wallets get a
 `LocalSigner`; a hardware wallet, MPC node or backend is wrapped with `externalSigner()` from
 `@anywalletkit/core`:
 
@@ -82,6 +83,21 @@ A derivable `SeedSigner` at `m/44'/607'` yields `getAccount(i)` children; a leaf
 `fromTonMnemonic`) is one account. `WalletAccountTon.fromPrivateKey(priv, pub, path)` keeps the
 raw-key shape for callers that derive themselves.
 
+## Messages and TON Connect
+
+`sign(message)` is a hex ed25519 signature over the raw bytes. A 32-byte message — bytes or a
+string that encodes to 32 bytes — is refused with `MessageIsTransactionError`: the wallet contract
+checks a transfer's signature over the 32-byte hash of its signing cell, so 32 raw bytes may be a
+transfer. TON Connect has its own methods, which build the digest from the request and the
+account's own address (0xffff ‖ "ton-connect…", never a cell hash):
+
+```ts
+const proof = await account.signTonProof({ domain: 'app.example', timestamp, payload })  // the `proof` of a ton_proof reply
+const reply = await account.signTonConnectData({ domain: 'app.example', timestamp, payload: { type: 'text', text } }) // signData (text | binary)
+```
+
+`domain` is the host the wallet saw the request come from, never the dApp's own claim.
+
 ## Describe
 
 `describeTransaction(tx)` / `account.describe(tx)` decode TON transfers (text

package/dist/index.cjs

@@ -27,6 +27,7 @@ __export(src_exports, {
   JETTON_TRANSFER_OP: () => JETTON_TRANSFER_OP,
   MAINNET_GLOBAL_ID: () => MAINNET_GLOBAL_ID,
   MAX_ACTIONS: () => MAX_ACTIONS,
+  MessageIsTransactionError: () => MessageIsTransactionError,
   SEND_MODE: () => SEND_MODE,
   SimulationError: () => SimulationError,
   TESTNET_GLOBAL_ID: () => TESTNET_GLOBAL_ID,
@@ -65,6 +66,8 @@ __export(src_exports, {
   runEmulation: () => runEmulation,
   tonCenterEndpoint: () => tonCenterEndpoint,
   tonExplorerTxUrl: () => tonExplorerTxUrl,
+  tonProofDigest: () => tonProofDigest,
+  tonSignDataDigest: () => tonSignDataDigest,
   v5r1Address: () => v5r1Address,
   v5r1Code: () => v5r1Code,
   v5r1ExternalMessage: () => v5r1ExternalMessage,
@@ -98,6 +101,13 @@ var UnsafeTransactionError = class extends import_core.SignerError {
     this.code = code;
   }
 };
+var MessageIsTransactionError = class extends import_core.SignerError {
+  code = "message-is-transaction";
+  constructor() {
+    super("This message has the shape of a transaction (a 32-byte TON hash, or bytes naming this key as a Solana signer) and is not signed; use signTonProof / signTonConnectData for TON Connect, or signTransaction so it can be reviewed.");
+    this.name = "MessageIsTransactionError";
+  }
+};
 var SimulationError = class extends Error {
   exitCode;
   aborted;
@@ -994,8 +1004,75 @@ function randomQueryId() {
 
 // src/account.ts
 var import_core9 = require("@anywalletkit/core");
+var import_buffer5 = require("buffer");
 var import_core10 = require("@ton/core");
+
+// src/tonconnect.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_buffer4 = require("buffer");
+var utf82 = (s) => new TextEncoder().encode(s);
+var int32BE = (n) => {
+  const b = new Uint8Array(4);
+  new DataView(b.buffer).setInt32(0, n, false);
+  return b;
+};
+var uint32 = (n, littleEndian) => {
+  const b = new Uint8Array(4);
+  new DataView(b.buffer).setUint32(0, n, littleEndian);
+  return b;
+};
+var uint64 = (n, littleEndian) => {
+  const b = new Uint8Array(8);
+  new DataView(b.buffer).setBigUint64(0, BigInt(n), littleEndian);
+  return b;
+};
+var concat = (...parts) => {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+};
+function checkCommon(address, domain, timestamp) {
+  if (address.hash.length !== 32) throw new RangeError("TON address hash must be 32 bytes.");
+  if (!Number.isInteger(address.workChain)) throw new TypeError("TON address workChain must be an integer.");
+  if (typeof domain !== "string" || domain.length === 0) throw new TypeError("TON Connect domain must be a non-empty string.");
+  if (typeof timestamp !== "number" || !Number.isSafeInteger(timestamp) || timestamp < 0) throw new TypeError("TON Connect timestamp must be a non-negative integer (unix seconds).");
+}
+function base64Bytes(raw) {
+  const s = raw.replace(/[\t\n\f\r ]/g, "");
+  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(s) || s.replace(/=+$/, "").length % 4 === 1) throw new TypeError("signData binary payload must be base64.");
+  return new Uint8Array(import_buffer4.Buffer.from(s, "base64"));
+}
+function tonProofDigest(address, request) {
+  checkCommon(address, request.domain, request.timestamp);
+  if (typeof request.payload !== "string") throw new TypeError("ton_proof payload must be a string.");
+  const domain = utf82(request.domain);
+  const inner = concat(utf82("ton-proof-item-v2/"), int32BE(address.workChain), address.hash, uint32(domain.length, true), domain, uint64(request.timestamp, true), utf82(request.payload));
+  return (0, import_sha2.sha256)(concat(new Uint8Array([255, 255]), utf82("ton-connect"), (0, import_sha2.sha256)(inner)));
+}
+function tonSignDataDigest(address, request) {
+  checkCommon(address, request.domain, request.timestamp);
+  const p = request.payload;
+  let payload;
+  if (p?.type === "text" && typeof p.text === "string") payload = utf82(p.text);
+  else if (p?.type === "binary" && typeof p.bytes === "string") payload = base64Bytes(p.bytes);
+  else throw new TypeError('signData payload must be { type: "text", text } or { type: "binary", bytes }; cell payloads are not supported.');
+  const domain = utf82(request.domain);
+  return (0, import_sha2.sha256)(concat(new Uint8Array([255, 255]), utf82("ton-connect/sign-data/"), int32BE(address.workChain), address.hash, uint32(domain.length, false), domain, uint64(request.timestamp, false), utf82(p.type === "text" ? "txt" : "bin"), uint32(payload.length, false), payload));
+}
+
+// src/account.ts
 var toHex = (u8) => Array.from(u8, (b) => b.toString(16).padStart(2, "0")).join("");
+var carriesKey = (bytes, key) => {
+  outer: for (let i = 0; i + key.length <= bytes.length; i++) {
+    for (let j = 0; j < key.length; j++) if (bytes[i + j] !== key[j]) continue outer;
+    return true;
+  }
+  return false;
+};
 var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon {
   /** seqno and fees come from the network before signing. */
   needsNetwork = true;
@@ -1019,11 +1096,46 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
     const m = /^m\/44'\/607'\/(\d+)'$/.exec(this.path);
     return m ? Number(m[1]) : void 0;
   }
-  /** Hex ed25519 signature over the raw message bytes (ton_proof and the like). */
+  /**
+   * Hex ed25519 signature over the raw message bytes. A 32-byte message — string or bytes — is
+   * refused with {@link MessageIsTransactionError}: the wallet contract checks a transfer's
+   * signature over the 32-byte hash of its signing cell, so those bytes could be one. Bytes that
+   * carry this account's public key are refused as well: one ed25519 key (an external signer) may
+   * also be a Solana wallet, and a Solana transaction names its signer's key. TON Connect goes
+   * through {@link signTonProof} and {@link signTonConnectData}.
+   */
   async sign(message) {
     const bytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+    if (bytes.length === 32 || carriesKey(bytes, this.publicKey)) throw new MessageIsTransactionError();
     return toHex(await this.signer.sign(bytes, { scheme: "ed25519", context: "ton-message" }));
   }
+  /**
+   * TON Connect `ton_proof` for this wallet's address: the `proof` object of the connect reply. The
+   * digest is built here (0xffff ‖ "ton-connect" ‖ …), so no request can turn it into a transfer.
+   * `domain` is the host the wallet saw the request come from.
+   */
+  async signTonProof(request) {
+    const digest = tonProofDigest(this._address, request);
+    const signature = await this.signer.sign(digest, { scheme: "ed25519", context: "ton-proof" });
+    return {
+      timestamp: request.timestamp,
+      domain: { lengthBytes: new TextEncoder().encode(request.domain).length, value: request.domain },
+      payload: request.payload,
+      signature: import_buffer5.Buffer.from(signature).toString("base64")
+    };
+  }
+  /** TON Connect `signData` (text / binary) for this wallet's address: the reply the dApp gets. */
+  async signTonConnectData(request) {
+    const digest = tonSignDataDigest(this._address, request);
+    const signature = await this.signer.sign(digest, { scheme: "ed25519", context: "ton-sign-data" });
+    return {
+      signature: import_buffer5.Buffer.from(signature).toString("base64"),
+      address: this._address.toRawString(),
+      timestamp: request.timestamp,
+      domain: request.domain,
+      payload: request.payload.type === "text" ? { type: "text", text: request.payload.text } : { type: "binary", bytes: request.payload.bytes }
+    };
+  }
   checkMaxFee(fee, limit, op) {
     if (limit !== void 0 && fee > BigInt(limit)) throw new Error(`Exceeded maximum fee cost for ${op} operation.`);
   }
@@ -1031,7 +1143,7 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
    * Checks → seqno → preflight → signed body. The preflight runs on the
    * zero-signed body (ignore_chksig), so nothing is signed before it passes.
    */
-  async prepare(messages, limit, op) {
+  async signMessages(messages, limit, op) {
     const want = messages.reduce((sum, m) => sum + (m.message.info.type === "internal" ? m.message.info.value.coins : 0n), 0n);
     if (want > 0n) {
       const balance = await this.getBalance();
@@ -1066,7 +1178,7 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
       await this.preflight(tx, (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction");
       return tx.toBoc().toString("base64");
     }
-    const { body } = await this.prepare(this.toMessages(tx), (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction");
+    const { body } = await this.signMessages(this.toMessages(tx), (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction");
     return body.toBoc().toString("base64");
   }
   async broadcast(body) {
@@ -1078,14 +1190,14 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
   /** Sign and broadcast; `hash` is the body hash (hex) — resolve it with getTransactionReceipt. */
   async sendTransaction(tx, options = {}) {
     this.requireRpc("send transactions");
-    const { body, fee } = tx instanceof import_core10.Cell ? { body: tx, fee: await this.preflight(tx, (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction") } : await this.prepare(this.toMessages(tx), (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction");
+    const { body, fee } = tx instanceof import_core10.Cell ? { body: tx, fee: await this.preflight(tx, (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction") } : await this.signMessages(this.toMessages(tx), (0, import_core9.feeLimit)(this._config.transactionMaxFee, options), "transaction");
     return { hash: await this.broadcast(body), fee };
   }
   /** TON (no `token`) or jetton transfer. */
   async transfer(o, writeOptions = {}) {
     this.requireRpc("transfer tokens");
     const message = o.token ? await this.jettonTransferMessage(o) : this.transactionMessage({ to: o.recipient, value: o.amount, ...o.memo !== void 0 ? { body: o.memo } : {} });
-    const { body, fee } = await this.prepare([message], (0, import_core9.feeLimit)(this._config.transferMaxFee, writeOptions), "transfer");
+    const { body, fee } = await this.signMessages([message], (0, import_core9.feeLimit)(this._config.transferMaxFee, writeOptions), "transfer");
     return { hash: await this.broadcast(body), fee };
   }
   /** The same wallet as a {@link WalletAccountReadOnlyTon}. */
@@ -1181,7 +1293,7 @@ var WalletManagerTon = class _WalletManagerTon extends import_core11.WalletManag
 
 // src/history.ts
 var import_core12 = require("@ton/core");
-var import_buffer4 = require("buffer");
+var import_buffer6 = require("buffer");
 var HistoryUnavailableError = class extends Error {
   chain;
   reason;
@@ -1198,12 +1310,12 @@ var DEFAULT_LIMIT = 25;
 var MAX_LIMIT = 100;
 var DEFAULT_TIMEOUT_MS3 = 15e3;
 function encodeCursor(c) {
-  return import_buffer4.Buffer.from(JSON.stringify(c), "utf8").toString("base64");
+  return import_buffer6.Buffer.from(JSON.stringify(c), "utf8").toString("base64");
 }
 function decodeCursor(s) {
   let parsed;
   try {
-    parsed = JSON.parse(import_buffer4.Buffer.from(s, "base64").toString("utf8"));
+    parsed = JSON.parse(import_buffer6.Buffer.from(s, "base64").toString("utf8"));
   } catch {
     throw new Error("@anywalletkit/wallet-ton: malformed history cursor");
   }
@@ -1455,7 +1567,7 @@ function mapTonapiEvent(chain, address, own, event, valueFlow) {
 var TEXT_COMMENT_OP = "0x00000000";
 function mapToncenterTransaction(chain, address, row) {
   const own = row.account.toLowerCase();
-  const hash = import_buffer4.Buffer.from(row.hash, "base64").toString("hex");
+  const hash = import_buffer6.Buffer.from(row.hash, "base64").toString("hex");
   const d = row.description;
   const failed = d?.aborted === true || d?.compute_ph?.skipped !== true && d?.compute_ph?.success === false || d?.action?.success === false;
   const transfers = [];