@anywalletkit/wallet-ton 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -170,12 +170,19 @@ function tonCenterEndpoint(endpoint, opts = {}) {
       }
       if (!res.ok || json.ok !== true) {
         const detail = typeof json.error === "string" ? json.error : JSON.stringify(json.error ?? json);
-        throw Object.assign(new import_core2.NetworkError(`${method}: ${detail} (HTTP ${res.status})`, { provider: url }), { answered: true });
+        const err = new import_core2.NetworkError(`${method}: ${detail} (HTTP ${res.status})`, { provider: url });
+        throw isNodeRefusal(res.status, json) ? Object.assign(err, { answered: true }) : err;
       }
       return json.result;
     }
   };
 }
+var UNKNOWN_STATUS = /* @__PURE__ */ new Set([408, 502, 503, 504]);
+function isNodeRefusal(status, json) {
+  if (UNKNOWN_STATUS.has(status)) return false;
+  if (json.ok !== false || typeof json.error !== "string" || json.error.trim() === "") return false;
+  return !/time[ds]? ?out|timed out|deadline/i.test(json.error);
+}
 function isAnsweredRefusal(e) {
   return e?.answered === true;
 }
@@ -1016,8 +1023,8 @@ var WalletAccountReadOnlyTon = class {
     return Math.floor(Date.now() / 1e3) + seconds;
   }
   /** The cell to sign for `messages` at the CURRENT seqno (fetched fresh every time). */
-  async signingCell(messages) {
-    const seqno = await this.getSeqno();
+  async signingCell(messages, knownSeqno) {
+    const seqno = knownSeqno ?? await this.getSeqno();
     const validUntil = this.validUntil();
     return { signing: v5r1SigningMessage({ walletId: this._walletId, validUntil, seqno, messages }), seqno, validUntil };
   }
@@ -1178,6 +1185,8 @@ function tonSignDataDigest(address, request) {
 }
 
 // src/account.ts
+var PENDING_SEQNO_TIMEOUT_MS = 6e4;
+var PENDING_SEQNO_POLL_MS = 1500;
 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++) {
@@ -1200,6 +1209,14 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
   /** What holds the key: `seed`, `key` (one imported key) or `external`. */
   signerKind;
   _readOnly;
+  /**
+   * The last external this account broadcast (accepted, or maybe sent) and when it expires. Until
+   * the wallet's seqno moves past it, a new message signed at the chain seqno would carry the same
+   * seqno and silently never execute, so the next send waits for it first.
+   */
+  _inFlight;
+  /** Tail of this account's send queue: seqno → sign → broadcast runs one send at a time. */
+  _sendTail = Promise.resolve();
   /** `publicKey` is the signer's 32-byte ed25519 key; the V5R1 address derives from it synchronously. */
   constructor(signer, publicKey, path, config = {}) {
     super(publicKey, config);
@@ -1277,14 +1294,33 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
   bodyModes(body) {
     return parseV5R1Body(body)?.messages.map((m) => m.mode) ?? [];
   }
-  async #signMessages(messages, limit, op) {
+  /**
+   * The seqno to sign the next send at: the chain's, once it has moved past this account's last
+   * broadcast. While that external can still land (before its valid_until) the seqno is polled, up
+   * to `pendingSeqnoTimeoutMs`; an expired one that never landed is forgotten.
+   */
+  async #nextSendSeqno() {
+    const timeout = this._config.pendingSeqnoTimeoutMs ?? PENDING_SEQNO_TIMEOUT_MS;
+    const deadline = Date.now() + timeout;
+    for (; ; ) {
+      const chain = await this.getSeqno();
+      const prev = this._inFlight;
+      if (!prev || chain > prev.seqno || Date.now() / 1e3 > prev.validUntil) {
+        this._inFlight = void 0;
+        return chain;
+      }
+      if (Date.now() >= deadline) throw new Error(`The previous transfer is still pending (seqno ${prev.seqno} has not moved): wait for it to land, then send again.`);
+      await new Promise((resolve) => setTimeout(resolve, Math.min(PENDING_SEQNO_POLL_MS, Math.max(0, deadline - Date.now()))));
+    }
+  }
+  async #signMessages(messages, limit, op, forSend = false) {
     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();
       if (balance < want) throw new UnsafeTransactionError("insufficient-balance", `Insufficient TON balance: the messages carry ${want} nanotons, the wallet holds ${balance} (fees come on top).`);
     }
-    const { signing } = await this.signingCell(messages);
+    const { signing } = await this.signingCell(messages, forSend ? await this.#nextSendSeqno() : void 0);
     const fee = await this.preflight(v5r1PackUnsigned(signing), limit, op, want);
     const signature = await this.#signer.sign(new Uint8Array(signing.hash()), { scheme: "ed25519", context: "ton-external" });
     return { body: v5r1PackSigned(signing, signature), fee };
@@ -1321,26 +1357,47 @@ var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon
     const rpc = this.requireRpc("send transactions");
     const init = await this.initIfNeeded();
     const hash = body.hash().toString("hex");
+    const parsed = parseV5R1Body(body);
+    const sent = () => {
+      if (parsed) this._inFlight = { seqno: parsed.seqno, validUntil: parsed.validUntil };
+    };
     try {
       await rpc.sendBoc(v5r1ExternalMessage(this._address, body, init));
     } catch (e) {
       if (isAnsweredRefusal(e)) throw e;
+      sent();
       throw new BroadcastUnknownError(hash, e);
     }
+    sent();
     return hash;
   }
+  /**
+   * One send at a time per account: two sends started together would read the same seqno before
+   * either is broadcast. A failed send does not block the next.
+   */
+  #serial(run) {
+    const next = this._sendTail.then(run);
+    this._sendTail = next.then(() => void 0, () => void 0);
+    return next;
+  }
   /** Sign and broadcast; `hash` is the body hash (hex) — resolve it with getTransactionReceipt. */
-  async sendTransaction(tx, options = {}) {
+  sendTransaction(tx, options = {}) {
+    return this.#serial(() => this.#sendTransactionNow(tx, options));
+  }
+  async #sendTransactionNow(tx, options) {
     this.requireRpc("send transactions");
     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");
+    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", true);
     return { hash: await this.broadcast(body), fee };
   }
   /** TON (no `token`) or jetton transfer. */
-  async transfer(o, writeOptions = {}) {
+  transfer(o, writeOptions = {}) {
+    return this.#serial(() => this.#transferNow(o, writeOptions));
+  }
+  async #transferNow(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.#signMessages([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", true);
     return { hash: await this.broadcast(body), fee };
   }
   /** The same wallet as a {@link WalletAccountReadOnlyTon}. */