@anywalletkit/wallet-ton 0.2.4 → 0.3.0

package/dist/index.js

@@ -30,6 +30,13 @@ var UnsafeTransactionError = class extends SignerError {
     this.code = code;
   }
 };
+var MessageIsTransactionError = class extends 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;
@@ -40,6 +47,17 @@ var SimulationError = class extends Error {
     this.aborted = details.aborted ?? false;
   }
 };
+var BroadcastUnknownError = class extends Error {
+  /** Always true: the transaction may be on its way. */
+  maybeSent = true;
+  /** Hex hash of the signed body. */
+  hash;
+  constructor(hash, cause) {
+    super(`Broadcast outcome unknown for ${hash}: ${cause instanceof Error ? cause.message.slice(0, 200) : String(cause).slice(0, 200)}`, { cause });
+    this.name = "BroadcastUnknownError";
+    this.hash = hash;
+  }
+};
 
 // src/toncenter.ts
 import { NetworkError } from "@anywalletkit/core";
@@ -77,12 +95,15 @@ function tonCenterEndpoint(endpoint, opts = {}) {
       }
       if (!res.ok || json.ok !== true) {
         const detail = typeof json.error === "string" ? json.error : JSON.stringify(json.error ?? json);
-        throw new NetworkError(`${method}: ${detail} (HTTP ${res.status})`, { provider: url });
+        throw Object.assign(new NetworkError(`${method}: ${detail} (HTTP ${res.status})`, { provider: url }), { answered: true });
       }
       return json.result;
     }
   };
 }
+function isAnsweredRefusal(e) {
+  return e?.answered === true;
+}
 function createTonRpc(config) {
   const target = config.tonClient ?? config.provider;
   if (target === void 0) return void 0;
@@ -95,14 +116,17 @@ function createTonRpc(config) {
   return {
     async call(method, params) {
       let lastError;
+      let answered = true;
       for (let i = 0; i < attempts; i++) {
         try {
           return await list[i % list.length].call(method, params);
         } catch (e) {
           lastError = e;
+          answered &&= isAnsweredRefusal(e);
         }
       }
-      throw new NetworkError(`All TON endpoints failed for ${method}`, { cause: lastError });
+      const err = new NetworkError(`All TON endpoints failed for ${method}`, { cause: lastError });
+      throw answered ? Object.assign(err, { answered: true }) : err;
     }
   };
 }
@@ -638,6 +662,19 @@ function describeOne(i, to, value, body, hasStateInit, bounceableOverride, warni
   return item;
 }
 var hex = (n) => `0x${n.toString(16).padStart(8, "0")}`;
+var IGNORE_ERRORS = 2;
+function sendModeOf(sendMode) {
+  return (sendMode ?? DEFAULT_SEND_MODE) | IGNORE_ERRORS;
+}
+function drainModes(mode) {
+  return [...(mode & 128) !== 0 ? ["carries-all-balance"] : [], ...(mode & 32) !== 0 ? ["destroys-account"] : []];
+}
+function withMode(i, item, mode, warnings) {
+  for (const code of drainModes(mode)) {
+    warnings.push({ code, message: code === "carries-all-balance" ? "send mode 128: the message carries the whole remaining balance" : "send mode 32: the wallet account is destroyed once it is empty", index: i });
+  }
+  return { ...item, mode };
+}
 function describeMessageRelaxed(i, m, warnings, ctx = {}) {
   if (m.info.type !== "internal") {
     warnings.push({ code: "unknown-body", message: "not an internal message", index: i });
@@ -659,7 +696,7 @@ function describeTransaction(tx, ctx = {}) {
       return { kind: "contract-call", items, warnings };
     }
     external2 = { seqno: parsed.seqno, validUntil: parsed.validUntil, walletId: parsed.walletId, signed: parsed.signed };
-    parsed.messages.forEach((m, i) => items.push(describeMessageRelaxed(i, m.message, warnings, ctx)));
+    parsed.messages.forEach((m, i) => items.push(withMode(i, describeMessageRelaxed(i, m.message, warnings, ctx), m.mode, warnings)));
   } else {
     const list = Array.isArray(tx) ? tx : [tx];
     list.forEach((t, i) => {
@@ -677,7 +714,7 @@ function describeTransaction(tx, ctx = {}) {
       } catch {
         warnings.push({ code: "unknown-body", message: "bodyBoc is not a valid BoC", index: i });
       }
-      items.push(describeOne(i, to, BigInt(t.value), body, t.stateInit !== void 0, t.bounceable, warnings, ctx));
+      items.push(withMode(i, describeOne(i, to, BigInt(t.value), body, t.stateInit !== void 0, t.bounceable, warnings, ctx), sendModeOf(t.sendMode), warnings));
     });
   }
   const kinds = new Set(items.map((x) => x.kind));
@@ -783,25 +820,34 @@ var WalletAccountReadOnlyTon = class {
     if (src instanceof Cell4) return loadStateInit(src.beginParse());
     return src;
   }
-  transactionMessage(tx) {
-    const value = big(tx.value);
-    if (value <= 0n) throw new UnsafeTransactionError("zero-value", "TON message value must be positive.");
+  /**
+   * A destination address with the checks every payment gets: workchain 0 or -1, and a friendly
+   * address's test-only flag matching the wallet's network. Used for a native message's `to` and a
+   * jetton transfer's recipient and response destination (round 3, L8).
+   */
+  checkedAddress(to) {
     let address;
     let bounceable = true;
     let testOnly;
-    if (Address4.isFriendly(tx.to)) {
-      const f = Address4.parseFriendly(tx.to);
+    if (Address4.isFriendly(to)) {
+      const f = Address4.parseFriendly(to);
       address = f.address;
       bounceable = f.isBounceable;
       testOnly = f.isTestOnly;
     } else {
-      address = Address4.parse(tx.to);
+      address = Address4.parse(to);
     }
     if (address.workChain !== 0 && address.workChain !== -1) throw new UnsafeTransactionError("exotic-workchain", `Refusing to send to workchain ${address.workChain}.`);
     const testnet = this._config.network === "testnet";
     if (testOnly !== void 0 && testOnly !== testnet) {
       throw new UnsafeTransactionError("network-mismatch", testOnly ? "Test-only address on a mainnet wallet." : "Mainnet address on a testnet wallet.");
     }
+    return { address, bounceable };
+  }
+  transactionMessage(tx) {
+    const value = big(tx.value);
+    if (value <= 0n) throw new UnsafeTransactionError("zero-value", "TON message value must be positive.");
+    const { address, bounceable } = this.checkedAddress(tx.to);
     const body = tx.body instanceof Cell4 ? tx.body : typeof tx.body === "string" ? tx.body === "" ? void 0 : commentCell(tx.body) : tx.bodyBoc ? Cell4.fromBase64(tx.bodyBoc) : void 0;
     const init = this.stateInitOf(tx.stateInit);
     const message = internal({ to: address, value, bounce: tx.bounceable ?? bounceable, ...body ? { body } : {}, ...init ? { init } : {} });
@@ -810,14 +856,15 @@ var WalletAccountReadOnlyTon = class {
   async jettonTransferMessage(o) {
     const amount = big(o.amount);
     if (amount <= 0n) throw new UnsafeTransactionError("zero-value", "Jetton amount must be positive.");
-    const recipient = Address4.parse(o.recipient);
+    const recipient = this.checkedAddress(o.recipient).address;
+    const response = o.responseDestination ? this.checkedAddress(o.responseDestination).address : void 0;
     const jw = await this.getJettonWalletAddress(o.token);
     await this.jettonWalletData(o.token, jw);
     const forwardTonAmount = o.forwardTonAmount !== void 0 ? big(o.forwardTonAmount) : 1n;
     if (o.memo !== void 0 && o.forwardPayload !== void 0) throw new UnsafeTransactionError("memo-and-payload", "Pass either memo or forwardPayload, not both: a jetton transfer carries one forward payload.");
     const payload = o.forwardPayload ?? o.memo;
     const forwardPayload = payload === void 0 ? null : typeof payload === "string" ? commentCell(payload) : payload;
-    const body = beginCell3().storeUint(JETTON_TRANSFER_OP2, 32).storeUint(o.queryId !== void 0 ? BigInt(o.queryId) : randomQueryId(), 64).storeCoins(amount).storeAddress(recipient).storeAddress(o.responseDestination ? Address4.parse(o.responseDestination) : this._address).storeMaybeRef(o.customPayload ?? null).storeCoins(forwardTonAmount).storeMaybeRef(forwardPayload).endCell();
+    const body = beginCell3().storeUint(JETTON_TRANSFER_OP2, 32).storeUint(o.queryId !== void 0 ? BigInt(o.queryId) : randomQueryId(), 64).storeCoins(amount).storeAddress(recipient).storeAddress(response ?? this._address).storeMaybeRef(o.customPayload ?? null).storeCoins(forwardTonAmount).storeMaybeRef(forwardPayload).endCell();
     const attached = o.attachedValue !== void 0 ? big(o.attachedValue) : (this._config.jettonAttachedValue !== void 0 ? big(this._config.jettonAttachedValue) : DEFAULT_JETTON_ATTACHED) + forwardTonAmount;
     return { message: internal({ to: jw, value: attached, bounce: true, body }) };
   }
@@ -935,8 +982,75 @@ function randomQueryId() {
 
 // src/account.ts
 import { LocalSigner, feeLimit, requireCurve } from "@anywalletkit/core";
+import { Buffer as Buffer5 } from "buffer";
 import { Cell as Cell5 } from "@ton/core";
+
+// src/tonconnect.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+import { Buffer as Buffer4 } from "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(Buffer4.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 sha256(concat(new Uint8Array([255, 255]), utf82("ton-connect"), 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 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;
@@ -960,11 +1074,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: Buffer5.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: Buffer5.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.`);
   }
@@ -972,7 +1121,22 @@ 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) {
+  /**
+   * Refuse send modes that drain the wallet — 128 (the whole remaining balance) and 32 (the account
+   * destroyed once empty) — unless `allowDrainingTransactions`. Checked locally, before any seqno or
+   * emulation, so it holds with `simulate: false` too (round 3, M11); the emulation check stays.
+   */
+  assertNoDrain(modes) {
+    if (this._config.allowDrainingTransactions === true) return;
+    const found = modes.flatMap(drainModes);
+    if (found.length) throw new UnsafeTransactionError("drain", `Refusing a message with send mode ${found.includes("carries-all-balance") ? "128 (it carries the whole remaining balance)" : "32 (it destroys the wallet account once empty)"}; set allowDrainingTransactions to override.`);
+  }
+  /** The send modes of a prebuilt V5R1 body; an unreadable body is left to the emulation and the node. */
+  bodyModes(body) {
+    return parseV5R1Body(body)?.messages.map((m) => m.mode) ?? [];
+  }
+  async signMessages(messages, limit, op) {
+    this.assertNoDrain(messages.map((m) => sendModeOf(m.mode)));
     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();
@@ -1004,29 +1168,37 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
   /** Sign without broadcasting. Returns the external-message BODY as base64 BoC (pass it back to sendTransaction as a Cell). */
   async signTransaction(tx, options = {}) {
     if (tx instanceof Cell5) {
+      this.assertNoDrain(this.bodyModes(tx));
       await this.preflight(tx, feeLimit(this._config.transactionMaxFee, options), "transaction");
       return tx.toBoc().toString("base64");
     }
-    const { body } = await this.prepare(this.toMessages(tx), feeLimit(this._config.transactionMaxFee, options), "transaction");
+    const { body } = await this.signMessages(this.toMessages(tx), feeLimit(this._config.transactionMaxFee, options), "transaction");
     return body.toBoc().toString("base64");
   }
   async broadcast(body) {
     const rpc = this.requireRpc("send transactions");
     const init = await this.initIfNeeded();
-    await rpc.sendBoc(v5r1ExternalMessage(this._address, body, init));
-    return body.hash().toString("hex");
+    const hash = body.hash().toString("hex");
+    try {
+      await rpc.sendBoc(v5r1ExternalMessage(this._address, body, init));
+    } catch (e) {
+      if (isAnsweredRefusal(e)) throw e;
+      throw new BroadcastUnknownError(hash, e);
+    }
+    return hash;
   }
   /** 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 Cell5 ? { body: tx, fee: await this.preflight(tx, feeLimit(this._config.transactionMaxFee, options), "transaction") } : await this.prepare(this.toMessages(tx), feeLimit(this._config.transactionMaxFee, options), "transaction");
+    if (tx instanceof Cell5) this.assertNoDrain(this.bodyModes(tx));
+    const { body, fee } = tx instanceof Cell5 ? { body: tx, fee: await this.preflight(tx, feeLimit(this._config.transactionMaxFee, options), "transaction") } : await this.signMessages(this.toMessages(tx), 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], feeLimit(this._config.transferMaxFee, writeOptions), "transfer");
+    const { body, fee } = await this.signMessages([message], feeLimit(this._config.transferMaxFee, writeOptions), "transfer");
     return { hash: await this.broadcast(body), fee };
   }
   /** The same wallet as a {@link WalletAccountReadOnlyTon}. */
@@ -1042,7 +1214,7 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
 
 // src/manager.ts
 import { LocalSigner as LocalSigner2, SignerError as SignerError2, WalletManager, isSeedSigner, zeroize } from "@anywalletkit/core";
-import { mnemonicToPrivateKey } from "@ton/crypto";
+import { mnemonicToPrivateKey, mnemonicValidate } from "@ton/crypto";
 var TON_BASE_PATH = "m/44'/607'";
 var TON_MNEMONIC_PATH = "ton-mnemonic";
 var WalletManagerTon = class _WalletManagerTon extends WalletManager {
@@ -1057,6 +1229,7 @@ var WalletManagerTon = class _WalletManagerTon extends WalletManager {
   static async fromTonMnemonic(words, config = {}) {
     const list = (Array.isArray(words) ? words : words.trim().split(/\s+/)).map((w) => w.toLowerCase());
     if (list.length !== 24) throw new Error("A TON mnemonic has 24 words.");
+    if (!await mnemonicValidate(list)) throw new Error("Not a valid TON mnemonic: check the words (a typo would open a different, empty wallet).");
     const pair = await mnemonicToPrivateKey(list);
     const privateKey = new Uint8Array(pair.secretKey.subarray(0, 32));
     const publicKey = new Uint8Array(pair.publicKey);
@@ -1123,6 +1296,7 @@ var WalletManagerTon = class _WalletManagerTon extends WalletManager {
 // src/index.ts
 installBufferGlobal();
 export {
+  BroadcastUnknownError,
   CAIP2,
   DEFAULT_SEND_MODE,
   DEFAULT_TONAPI,
@@ -1130,6 +1304,7 @@ export {
   JETTON_TRANSFER_OP,
   MAINNET_GLOBAL_ID,
   MAX_ACTIONS,
+  MessageIsTransactionError,
   SEND_MODE,
   SimulationError,
   TESTNET_GLOBAL_ID,
@@ -1155,6 +1330,7 @@ export {
   emulateViaTonapi,
   encodeCursor as encodeHistoryCursor,
   installBufferGlobal,
+  isAnsweredRefusal,
   mapActions as mapTonapiActions,
   mapTonapiEvent,
   mapToncenterTransaction,
@@ -1168,6 +1344,8 @@ export {
   runEmulation,
   tonCenterEndpoint,
   tonExplorerTxUrl,
+  tonProofDigest,
+  tonSignDataDigest,
   v5r1Address,
   v5r1Code,
   v5r1ExternalMessage,