@anywalletkit/wallet-ton 0.2.4 → 0.3.0

package/README.md

@@ -56,10 +56,18 @@ const tk = await WalletManagerTon.fromTonMnemonic(words, { tonClient })
    an aborted transaction, a failed action phase or a failed **first-hop**
    internal message (the operation would bounce) throws `SimulationError`
    **before signing**; failures deeper in the trace are `warnings`. tonapi's
-   `risk` is returned as `risk` and a body that would carry the whole balance
-   (send mode 128) is refused with `UnsafeTransactionError('drain')` unless
-   `allowDrainingTransactions`. `emulate: false` keeps only `estimateFee`;
-   `simulate: false` skips the preflight entirely.
+   `risk` is returned as `risk`. A message with send mode 128 (the whole
+   remaining balance) or 32 (the account destroyed once empty) is refused with
+   `UnsafeTransactionError('drain')` unless `allowDrainingTransactions` — checked
+   locally before any emulation, prebuilt bodies too, and again on tonapi's risk.
+   `describeTransaction` shows each message's `mode`. `emulate: false` keeps only
+   `estimateFee`; `simulate: false` skips the preflight entirely (not the mode check).
+   A jetton transfer's recipient and response destination get the same network
+   (test-only flag) and workchain checks as a native transfer.
+   A broadcast with no definitive answer (no response, a timeout, a non-JSON body)
+   throws `BroadcastUnknownError` (`maybeSent`, `hash` = the body hash): do not sign
+   again (the next seqno would pay twice); a node's `ok: false` stays a `NetworkError`.
+   A custom `TonRpc` should mark refusals `answered: true` (`isAnsweredRefusal`).
 4. noble ed25519 over the body hash; the 32-byte seed is the only key material
    and `dispose()` zeroizes it.
 5. `sendBoc` of the external (with StateInit when the wallet is not deployed).
@@ -68,7 +76,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 +91,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

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  BroadcastUnknownError: () => BroadcastUnknownError,
   CAIP2: () => CAIP2,
   DEFAULT_SEND_MODE: () => DEFAULT_SEND_MODE,
   DEFAULT_TONAPI: () => DEFAULT_TONAPI,
@@ -27,6 +28,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,
@@ -52,6 +54,7 @@ __export(src_exports, {
   emulateViaTonapi: () => emulateViaTonapi,
   encodeHistoryCursor: () => encodeCursor,
   installBufferGlobal: () => installBufferGlobal,
+  isAnsweredRefusal: () => isAnsweredRefusal,
   mapTonapiActions: () => mapActions,
   mapTonapiEvent: () => mapTonapiEvent,
   mapToncenterTransaction: () => mapToncenterTransaction,
@@ -65,6 +68,8 @@ __export(src_exports, {
   runEmulation: () => runEmulation,
   tonCenterEndpoint: () => tonCenterEndpoint,
   tonExplorerTxUrl: () => tonExplorerTxUrl,
+  tonProofDigest: () => tonProofDigest,
+  tonSignDataDigest: () => tonSignDataDigest,
   v5r1Address: () => v5r1Address,
   v5r1Code: () => v5r1Code,
   v5r1ExternalMessage: () => v5r1ExternalMessage,
@@ -98,6 +103,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;
@@ -108,6 +120,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
 var import_core2 = require("@anywalletkit/core");
@@ -145,12 +168,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 import_core2.NetworkError(`${method}: ${detail} (HTTP ${res.status})`, { provider: url });
+        throw Object.assign(new import_core2.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;
@@ -163,14 +189,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 import_core2.NetworkError(`All TON endpoints failed for ${method}`, { cause: lastError });
+      const err = new import_core2.NetworkError(`All TON endpoints failed for ${method}`, { cause: lastError });
+      throw answered ? Object.assign(err, { answered: true }) : err;
     }
   };
 }
@@ -697,6 +726,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 });
@@ -718,7 +760,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) => {
@@ -736,7 +778,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));
@@ -842,25 +884,34 @@ var WalletAccountReadOnlyTon = class {
     if (src instanceof import_core8.Cell) return (0, import_core8.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 (import_core8.Address.isFriendly(tx.to)) {
-      const f = import_core8.Address.parseFriendly(tx.to);
+    if (import_core8.Address.isFriendly(to)) {
+      const f = import_core8.Address.parseFriendly(to);
       address = f.address;
       bounceable = f.isBounceable;
       testOnly = f.isTestOnly;
     } else {
-      address = import_core8.Address.parse(tx.to);
+      address = import_core8.Address.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 import_core8.Cell ? tx.body : typeof tx.body === "string" ? tx.body === "" ? void 0 : commentCell(tx.body) : tx.bodyBoc ? import_core8.Cell.fromBase64(tx.bodyBoc) : void 0;
     const init = this.stateInitOf(tx.stateInit);
     const message = (0, import_core8.internal)({ to: address, value, bounce: tx.bounceable ?? bounceable, ...body ? { body } : {}, ...init ? { init } : {} });
@@ -869,14 +920,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 = import_core8.Address.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 = (0, import_core8.beginCell)().storeUint(JETTON_TRANSFER_OP2, 32).storeUint(o.queryId !== void 0 ? BigInt(o.queryId) : randomQueryId(), 64).storeCoins(amount).storeAddress(recipient).storeAddress(o.responseDestination ? import_core8.Address.parse(o.responseDestination) : this._address).storeMaybeRef(o.customPayload ?? null).storeCoins(forwardTonAmount).storeMaybeRef(forwardPayload).endCell();
+    const body = (0, import_core8.beginCell)().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: (0, import_core8.internal)({ to: jw, value: attached, bounce: true, body }) };
   }
@@ -994,8 +1046,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 +1138,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 +1185,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();
@@ -1063,29 +1232,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 import_core10.Cell) {
+      this.assertNoDrain(this.bodyModes(tx));
       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) {
     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 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");
+    if (tx instanceof import_core10.Cell) this.assertNoDrain(this.bodyModes(tx));
+    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}. */
@@ -1116,6 +1293,7 @@ var WalletManagerTon = class _WalletManagerTon extends import_core11.WalletManag
   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 (0, import_crypto.mnemonicValidate)(list)) throw new Error("Not a valid TON mnemonic: check the words (a typo would open a different, empty wallet).");
     const pair = await (0, import_crypto.mnemonicToPrivateKey)(list);
     const privateKey = new Uint8Array(pair.secretKey.subarray(0, 32));
     const publicKey = new Uint8Array(pair.publicKey);
@@ -1181,7 +1359,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 +1376,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 +1633,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 = [];