@anywalletkit/wallet-ton 0.0.0-stage → 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1649 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CAIP2: () => CAIP2,
+  DEFAULT_SEND_MODE: () => DEFAULT_SEND_MODE,
+  DEFAULT_TONAPI: () => DEFAULT_TONAPI,
+  HistoryUnavailableError: () => HistoryUnavailableError,
+  JETTON_TRANSFER_OP: () => JETTON_TRANSFER_OP,
+  MAINNET_GLOBAL_ID: () => MAINNET_GLOBAL_ID,
+  MAX_ACTIONS: () => MAX_ACTIONS,
+  SEND_MODE: () => SEND_MODE,
+  SimulationError: () => SimulationError,
+  TESTNET_GLOBAL_ID: () => TESTNET_GLOBAL_ID,
+  TON_BASE_PATH: () => TON_BASE_PATH,
+  TON_MNEMONIC_PATH: () => TON_MNEMONIC_PATH,
+  TonCenter: () => TonCenter,
+  UnsafeTransactionError: () => UnsafeTransactionError,
+  V5R1_CODE_HEX: () => V5R1_CODE_HEX,
+  V5R1_OP: () => V5R1_OP,
+  WalletAccountReadOnlyTon: () => WalletAccountReadOnlyTon,
+  WalletAccountTon: () => WalletAccountTon,
+  WalletManagerTon: () => WalletManagerTon,
+  commentCell: () => commentCell,
+  createTonClient: () => createTonRpc,
+  createTonHistory: () => createTonHistory,
+  createTonRpc: () => createTonRpc,
+  decodeBody: () => decodeBody,
+  decodeHistoryCursor: () => decodeCursor,
+  default: () => WalletManagerTon,
+  describeMessageRelaxed: () => describeMessageRelaxed,
+  describeTransaction: () => describeTransaction,
+  emulateExternal: () => emulateExternal,
+  emulateViaTonapi: () => emulateViaTonapi,
+  encodeHistoryCursor: () => encodeCursor,
+  installBufferGlobal: () => installBufferGlobal,
+  mapTonapiActions: () => mapActions,
+  mapTonapiEvent: () => mapTonapiEvent,
+  mapToncenterTransaction: () => mapToncenterTransaction,
+  parseEmulation: () => parseEmulation,
+  parseTonapiConsequences: () => parseTonapiConsequences,
+  parseTonapiRisk: () => parseTonapiRisk,
+  parseTonapiTrace: () => parseTonapiTrace,
+  parseV5R1Body: () => parseV5R1Body,
+  rawTonAddress: () => rawTonAddress,
+  resolveEmulate: () => resolveEmulate,
+  runEmulation: () => runEmulation,
+  tonCenterEndpoint: () => tonCenterEndpoint,
+  tonExplorerTxUrl: () => tonExplorerTxUrl,
+  v5r1Address: () => v5r1Address,
+  v5r1Code: () => v5r1Code,
+  v5r1ExternalMessage: () => v5r1ExternalMessage,
+  v5r1PackSigned: () => v5r1PackSigned,
+  v5r1PackUnsigned: () => v5r1PackUnsigned,
+  v5r1SigningMessage: () => v5r1SigningMessage,
+  v5r1StateInit: () => v5r1StateInit,
+  v5r1WalletId: () => v5r1WalletId,
+  valueFlowTransfers: () => valueFlowTransfers
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/buffer-global.ts
+var import_buffer = require("buffer");
+function installBufferGlobal() {
+  const g = globalThis;
+  g.Buffer ??= import_buffer.Buffer;
+}
+installBufferGlobal();
+
+// src/types.ts
+var CAIP2 = { mainnet: "ton:-239", testnet: "ton:-3" };
+
+// src/errors.ts
+var import_core = require("@anywalletkit/core");
+var UnsafeTransactionError = class extends import_core.SignerError {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "UnsafeTransactionError";
+    this.code = code;
+  }
+};
+var SimulationError = class extends Error {
+  exitCode;
+  aborted;
+  constructor(reason, details = {}) {
+    super(`Transaction simulation failed: ${reason}`);
+    this.name = "SimulationError";
+    this.exitCode = details.exitCode;
+    this.aborted = details.aborted ?? false;
+  }
+};
+
+// src/toncenter.ts
+var import_core2 = require("@anywalletkit/core");
+var import_buffer2 = require("buffer");
+var import_core3 = require("@ton/core");
+var DEFAULT_TIMEOUT_MS = 15e3;
+var isRpc = (p) => typeof p.call === "function";
+function tonCenterEndpoint(endpoint, opts = {}) {
+  const url = endpoint.url;
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  if (typeof doFetch !== "function") throw new import_core2.NetworkError("No fetch available; pass config.fetch", { provider: url });
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return {
+    async call(method, params) {
+      let res;
+      try {
+        res = await doFetch(url, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            accept: "application/json",
+            ...endpoint.secretKey ? { "X-API-Key": endpoint.secretKey } : {}
+          },
+          body: JSON.stringify({ id: "1", jsonrpc: "2.0", method, params }),
+          signal: AbortSignal.timeout(timeoutMs)
+        });
+      } catch (e) {
+        throw new import_core2.NetworkError(`${method}: ${e instanceof Error ? e.message : String(e)}`, { provider: url, cause: e });
+      }
+      let json;
+      try {
+        json = await res.json();
+      } catch (e) {
+        throw new import_core2.NetworkError(`${method}: HTTP ${res.status}, non-JSON body`, { provider: url, cause: e });
+      }
+      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 });
+      }
+      return json.result;
+    }
+  };
+}
+function createTonRpc(config) {
+  const target = config.tonClient ?? config.provider;
+  if (target === void 0) return void 0;
+  const list = (Array.isArray(target) ? target : [target]).map(
+    (p) => isRpc(p) ? p : tonCenterEndpoint(p, { ...config.fetch ? { fetch: config.fetch } : {}, ...config.timeoutMs !== void 0 ? { timeoutMs: config.timeoutMs } : {} })
+  );
+  if (list.length === 0) throw new Error("The 'tonClient' option cannot be set to an empty list.");
+  if (list.length === 1) return list[0];
+  const attempts = list.length + (config.retries ?? 3);
+  return {
+    async call(method, params) {
+      let lastError;
+      for (let i = 0; i < attempts; i++) {
+        try {
+          return await list[i % list.length].call(method, params);
+        } catch (e) {
+          lastError = e;
+        }
+      }
+      throw new import_core2.NetworkError(`All TON endpoints failed for ${method}`, { cause: lastError });
+    }
+  };
+}
+function serializeStackItem(item) {
+  switch (item.type) {
+    case "int":
+      return ["num", item.value.toString()];
+    case "cell":
+      return ["tvm.Cell", item.cell.toBoc().toString("base64")];
+    case "slice":
+      return ["tvm.Slice", item.cell.toBoc().toString("base64")];
+    case "builder":
+      return ["tvm.Builder", item.cell.toBoc().toString("base64")];
+    default:
+      throw new Error(`Unsupported stack item type: ${item.type}`);
+  }
+}
+var hexBigInt = (s) => s.startsWith("-") ? -BigInt(s.slice(1)) : BigInt(s);
+var cellFromBase64 = (b64) => import_core3.Cell.fromBoc(import_buffer2.Buffer.from(b64, "base64"))[0];
+function parseStackEntry(x) {
+  const o = x;
+  switch (o["@type"]) {
+    case "tvm.list":
+    case "tvm.tuple":
+      return { type: "tuple", items: o.elements.map(parseStackEntry) };
+    case "tvm.cell":
+      return { type: "cell", cell: cellFromBase64(o.bytes) };
+    case "tvm.stackEntryCell":
+      return parseStackEntry(o.cell);
+    case "tvm.stackEntryTuple":
+      return parseStackEntry(o.tuple);
+    case "tvm.stackEntryNumber":
+      return parseStackEntry(o.number);
+    case "tvm.numberDecimal":
+      return { type: "int", value: BigInt(o.number) };
+    default:
+      throw new import_core2.NetworkError(`Malformed stack entry: ${JSON.stringify(x)}`);
+  }
+}
+function parseStackItem(s) {
+  if (!Array.isArray(s) || s.length < 2) throw new import_core2.NetworkError(`Malformed stack item: ${JSON.stringify(s)}`);
+  const [kind, value] = s;
+  switch (kind) {
+    case "num":
+      return { type: "int", value: hexBigInt(value) };
+    case "null":
+      return { type: "null" };
+    case "cell":
+      return { type: "cell", cell: cellFromBase64(value.bytes) };
+    case "slice":
+      return { type: "slice", cell: cellFromBase64(value.bytes) };
+    case "builder":
+      return { type: "builder", cell: cellFromBase64(value.bytes) };
+    case "tuple":
+    case "list":
+      return { type: "tuple", items: (value.elements ?? []).map(parseStackEntry) };
+    default:
+      throw new import_core2.NetworkError(`Malformed stack item kind: ${kind}`);
+  }
+}
+var need = (cond, what, value) => {
+  if (!cond) throw new import_core2.NetworkError(`Malformed toncenter response: ${what}`);
+  return value;
+};
+var TonCenter = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  rpc;
+  /** Balance, status, code and data of an account. */
+  async getAddressInformation(address) {
+    const r = await this.rpc.call("getAddressInformation", { address: address.toString() });
+    need(r && typeof r === "object" && typeof r.balance === "string", "getAddressInformation", r);
+    const state = r.state;
+    const last = r.last_transaction_id;
+    return {
+      balance: BigInt(r.balance),
+      state: ["active", "uninitialized", "frozen", "nonexist"].includes(state) ? state : "nonexist",
+      code: typeof r.code === "string" && r.code !== "" ? cellFromBase64(r.code) : null,
+      data: typeof r.data === "string" && r.data !== "" ? cellFromBase64(r.data) : null,
+      lastTransaction: last && last.lt && last.lt !== "0" ? { lt: last.lt, hash: last.hash ?? "" } : null
+    };
+  }
+  /** Call a contract get-method; the result carries the exit code. */
+  async runGetMethod(address, method, stack = []) {
+    const r = await this.rpc.call("runGetMethod", {
+      address: address.toString(),
+      method,
+      stack: stack.map(serializeStackItem)
+    });
+    need(r && typeof r === "object" && typeof r.exit_code === "number" && Array.isArray(r.stack), "runGetMethod", r);
+    return { exitCode: r.exit_code, gasUsed: Number(r.gas_used ?? 0), stack: new import_core3.TupleReader(r.stack.map(parseStackItem)) };
+  }
+  /** Like runGetMethod but throws on a non-zero exit code. */
+  async runGetMethodOk(address, method, stack = []) {
+    const r = await this.runGetMethod(address, method, stack);
+    if (r.exitCode !== 0) throw new import_core2.NetworkError(`Get method ${method} failed with exit_code: ${r.exitCode}`);
+    return r;
+  }
+  /** Broadcast a signed external message. */
+  async sendBoc(message) {
+    await this.rpc.call("sendBoc", { boc: message.toBoc().toString("base64") });
+  }
+  /** Broadcast and return the external-message hash (base64) toncenter reports. */
+  async sendBocReturnHash(message) {
+    const r = await this.rpc.call("sendBocReturnHash", { boc: message.toBoc().toString("base64") });
+    return need(r && typeof r.hash === "string", "sendBocReturnHash", r.hash);
+  }
+  async getTransactions(address, opts) {
+    const params = { address: address.toString(), limit: opts.limit };
+    if (opts.lt) params.lt = opts.lt;
+    if (opts.hash) params.hash = import_buffer2.Buffer.from(opts.hash, "base64").toString("hex");
+    if (opts.archival) params.archival = true;
+    const r = await this.rpc.call("getTransactions", params);
+    need(Array.isArray(r), "getTransactions", r);
+    return r.map((t) => {
+      need(typeof t.data === "string", "getTransactions[].data", t);
+      return (0, import_core3.loadTransaction)(cellFromBase64(t.data).beginParse());
+    });
+  }
+  async estimateFee(address, args) {
+    const r = await this.rpc.call("estimateFee", {
+      address: address.toString(),
+      body: args.body.toBoc().toString("base64"),
+      init_code: args.init ? args.init.code.toBoc().toString("base64") : "",
+      init_data: args.init ? args.init.data.toBoc().toString("base64") : "",
+      ignore_chksig: args.ignoreSignature ?? true
+    });
+    const f = r?.source_fees;
+    need(f && ["in_fwd_fee", "storage_fee", "gas_fee", "fwd_fee"].every((k) => typeof f[k] === "number" || typeof f[k] === "string"), "estimateFee", r);
+    const fees = {
+      inFwdFee: BigInt(f.in_fwd_fee),
+      storageFee: BigInt(f.storage_fee),
+      gasFee: BigInt(f.gas_fee),
+      fwdFee: BigInt(f.fwd_fee)
+    };
+    return { ...fees, total: fees.inFwdFee + fees.storageFee + fees.gasFee + fees.fwdFee };
+  }
+};
+function parseEmulation(json) {
+  const j = json;
+  if (!j || typeof j !== "object") throw new import_core2.NetworkError("Malformed emulation response");
+  if (typeof j.error === "string") return { ok: false, reason: j.error };
+  const txs = j.transactions;
+  const rootHash = j.trace?.tx_hash;
+  let tx;
+  if (Array.isArray(txs)) tx = txs[0];
+  else if (txs && typeof txs === "object") tx = rootHash && txs[rootHash] || Object.values(txs)[0];
+  if (!tx) {
+    if (typeof j.exit_code === "number") return verdict(j.exit_code, j.aborted === true, void 0);
+    throw new import_core2.NetworkError("Malformed emulation response: no transactions");
+  }
+  const d = tx.description ?? tx;
+  const compute = d.compute_ph ?? d.compute;
+  const action = d.action;
+  const exitCode = typeof compute?.exit_code === "number" ? compute.exit_code : compute?.success === true ? 0 : void 0;
+  const actionSuccess = typeof action?.success === "boolean" ? action.success : void 0;
+  if (exitCode === void 0 && d.aborted === void 0 && actionSuccess === void 0) throw new import_core2.NetworkError("Malformed emulation response: no phases");
+  return verdict(exitCode, d.aborted === true, actionSuccess);
+}
+function verdict(exitCode, aborted, actionSuccess) {
+  const ok = !aborted && (exitCode === void 0 || exitCode === 0) && actionSuccess !== false;
+  const reason = aborted ? "transaction aborted" : exitCode !== void 0 && exitCode !== 0 ? `compute phase exit_code ${exitCode}` : actionSuccess === false ? "action phase failed" : void 0;
+  return { ok, ...exitCode !== void 0 ? { exitCode } : {}, aborted, ...actionSuccess !== void 0 ? { actionSuccess } : {}, ...reason ? { reason } : {} };
+}
+async function emulateExternal(url, message, opts = {}) {
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  let res;
+  try {
+    res = await doFetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json", ...opts.apiKey ? { "X-API-Key": opts.apiKey } : {} },
+      body: JSON.stringify({ boc: message.toBoc().toString("base64"), ignore_chksig: true, include_code_data: false, with_actions: false }),
+      signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+    });
+  } catch (e) {
+    throw new import_core2.NetworkError(`emulate: ${e instanceof Error ? e.message : String(e)}`, { provider: url, cause: e });
+  }
+  let json;
+  try {
+    json = await res.json();
+  } catch (e) {
+    throw new import_core2.NetworkError(`emulate: HTTP ${res.status}, non-JSON body`, { provider: url, cause: e });
+  }
+  if (!res.ok) {
+    const err = json;
+    return { ok: false, reason: `HTTP ${res.status}: ${typeof err.error === "string" ? err.error : JSON.stringify(err.detail ?? err.error ?? json)}` };
+  }
+  return parseEmulation(json);
+}
+
+// src/emulation.ts
+var import_core4 = require("@anywalletkit/core");
+var DEFAULT_TIMEOUT_MS2 = 15e3;
+var DEFAULT_TONAPI = "https://tonapi.io/v2";
+function isObject(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function creditedUninit(tx) {
+  const c = tx.compute_phase;
+  return tx.success === true && c?.skipped === true && c.skip_reason === "cskip_no_state" && tx.bounce_phase === void 0 && (tx.action_phase === void 0 || tx.action_phase.success !== false);
+}
+function txFailure(tx) {
+  const c = tx.compute_phase;
+  if (creditedUninit(tx)) return void 0;
+  if (tx.aborted === true) return "aborted";
+  if (c && c.skipped !== true && typeof c.exit_code === "number" && c.exit_code !== 0) return `compute exit_code ${c.exit_code}${c.exit_code_description ? ` (${c.exit_code_description})` : ""}`;
+  if (c && c.skipped === true && tx.success === false) return `compute skipped${c.skip_reason ? ` (${c.skip_reason})` : ""}`;
+  if (tx.action_phase && tx.action_phase.success === false) return `action phase failed${typeof tx.action_phase.result_code === "number" ? ` (code ${tx.action_phase.result_code})` : ""}`;
+  if (typeof tx.bounce_phase === "string" && tx.bounce_phase !== "TrPhaseBounceOk" && tx.success === false) return `bounced (${tx.bounce_phase})`;
+  if (tx.success === false) return "failed";
+  return void 0;
+}
+function accountOf(tx) {
+  return typeof tx.account === "string" ? tx.account : tx.account?.address ?? "?";
+}
+function parseTonapiTrace(trace) {
+  if (!isObject(trace) || !isObject(trace.transaction)) throw new import_core4.NetworkError("Malformed tonapi emulation: no root transaction");
+  const root = trace.transaction;
+  const compute = root.compute_phase;
+  const exitCode = compute && compute.skipped !== true && typeof compute.exit_code === "number" ? compute.exit_code : compute?.success === true ? 0 : void 0;
+  const actionSuccess = typeof root.action_phase?.success === "boolean" ? root.action_phase.success : void 0;
+  if (exitCode === void 0 && actionSuccess === void 0 && typeof root.success !== "boolean" && typeof root.aborted !== "boolean") {
+    throw new import_core4.NetworkError("Malformed tonapi emulation: root transaction has no phases");
+  }
+  const aborted = root.aborted === true;
+  const rootFailure = txFailure(root);
+  const warnings = [];
+  let firstHopFailure;
+  const walk = (t, depth) => {
+    for (const child of t.children ?? []) {
+      const tx = child.transaction;
+      if (tx) {
+        const f = txFailure(tx);
+        if (f) {
+          const line = `${accountOf(tx)}: ${f}`;
+          if (depth === 1) firstHopFailure ??= line;
+          else warnings.push(line);
+        }
+      }
+      walk(child, depth + 1);
+    }
+  };
+  walk(trace, 1);
+  const reason = rootFailure ? aborted ? "transaction aborted" : rootFailure : firstHopFailure ? `internal message failed \u2014 ${firstHopFailure}` : void 0;
+  return {
+    ok: reason === void 0,
+    ...exitCode !== void 0 ? { exitCode } : {},
+    aborted,
+    ...actionSuccess !== void 0 ? { actionSuccess } : {},
+    ...reason ? { reason } : {},
+    warnings
+  };
+}
+function parseTonapiRisk(risk) {
+  if (!isObject(risk)) throw new import_core4.NetworkError("Malformed tonapi emulation: no risk");
+  const big3 = (v) => {
+    if (typeof v === "bigint") return v;
+    if (typeof v === "number" && Number.isFinite(v)) return BigInt(Math.trunc(v));
+    if (typeof v === "string" && /^-?\d+$/.test(v)) return BigInt(v);
+    throw new import_core4.NetworkError("Malformed tonapi emulation: risk amount");
+  };
+  const jettons = Array.isArray(risk.jettons) ? risk.jettons : [];
+  return {
+    ton: big3(risk.ton ?? 0),
+    transferAllRemainingBalance: risk.transfer_all_remaining_balance === true,
+    jettons: jettons.map((j) => {
+      if (!isObject(j)) throw new import_core4.NetworkError("Malformed tonapi emulation: risk jetton");
+      const jetton = isObject(j.jetton) ? j.jetton : {};
+      const wallet = isObject(j.wallet_address) ? j.wallet_address : {};
+      return {
+        amount: big3(j.quantity ?? 0),
+        address: typeof jetton.address === "string" ? jetton.address : "",
+        walletAddress: typeof wallet.address === "string" ? wallet.address : "",
+        ...typeof jetton.symbol === "string" ? { symbol: jetton.symbol } : {},
+        ...typeof jetton.decimals === "number" ? { decimals: jetton.decimals } : {}
+      };
+    })
+  };
+}
+function parseTonapiConsequences(json) {
+  if (!isObject(json)) throw new import_core4.NetworkError("Malformed tonapi emulation response");
+  if (typeof json.error === "string") return { ok: false, reason: json.error, aborted: false, warnings: [], source: "tonapi" };
+  const verdict2 = parseTonapiTrace(json.trace);
+  return { ...verdict2, source: "tonapi", risk: parseTonapiRisk(json.risk) };
+}
+async function post(doFetch, url, body, opts) {
+  let res;
+  try {
+    res = await doFetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json", ...opts.apiKey ? { authorization: `Bearer ${opts.apiKey}` } : {} },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2)
+    });
+  } catch (e) {
+    throw new import_core4.NetworkError(`emulate: ${e instanceof Error ? e.message : String(e)}`, { provider: url, cause: e });
+  }
+  if (res.status === 404) return { status: 404, ok: false, json: void 0 };
+  let json;
+  try {
+    json = await res.json();
+  } catch (e) {
+    throw new import_core4.NetworkError(`emulate: HTTP ${res.status}, non-JSON body`, { provider: url, cause: e });
+  }
+  return { status: res.status, ok: res.ok, json };
+}
+function httpFailure(status, json) {
+  const err = isObject(json) ? json : {};
+  const text = typeof err.error === "string" ? err.error : JSON.stringify(err.detail ?? err.error ?? json);
+  return { ok: false, reason: `HTTP ${status}: ${text}`, aborted: false, warnings: [], source: "tonapi" };
+}
+async function emulateViaTonapi(baseUrl, message, opts = {}) {
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  const base = baseUrl.replace(/\/+$/, "");
+  const boc = message.toBoc().toString("base64");
+  const first = await post(doFetch, `${base}/wallet/emulate?ignore_signature_check=true`, { boc }, opts);
+  if (first.status !== 404) {
+    if (!first.ok) return httpFailure(first.status, first.json);
+    return parseTonapiConsequences(first.json);
+  }
+  const second = await post(doFetch, `${base}/traces/emulate?ignore_signature_check=true`, { boc }, opts);
+  if (second.status === 404) throw new import_core4.NetworkError("emulate: tonapi serves neither /wallet/emulate nor /traces/emulate", { provider: base });
+  if (!second.ok) return httpFailure(second.status, second.json);
+  if (isObject(second.json) && typeof second.json.error === "string") return { ok: false, reason: second.json.error, aborted: false, warnings: [], source: "tonapi" };
+  return { ...parseTonapiTrace(second.json), source: "tonapi" };
+}
+function resolveEmulate(config) {
+  if (config.emulate === false) return false;
+  if (config.emulate) return config.emulate;
+  if (config.emulateUrl) return { kind: "toncenter-v3", url: config.emulateUrl };
+  return { kind: "tonapi" };
+}
+async function runEmulation(config, message) {
+  const target = resolveEmulate(config);
+  if (!target) return void 0;
+  const opts = {
+    ...config.fetch ? { fetch: config.fetch } : {},
+    ...config.timeoutMs !== void 0 ? { timeoutMs: config.timeoutMs } : {},
+    ...config.tonApiKey ? { apiKey: config.tonApiKey } : {}
+  };
+  if (target.kind === "tonapi") return emulateViaTonapi(target.url ?? config.tonApiUrl ?? DEFAULT_TONAPI, message, opts);
+  const v = await emulateExternal(target.url, message, opts);
+  return { ...v, aborted: v.aborted ?? false, source: "toncenter-v3", warnings: [] };
+}
+
+// src/wallet-v5r1.ts
+var import_buffer3 = require("buffer");
+var import_core5 = require("@ton/core");
+var V5R1_CODE_HEX = "b5ee9c7241021401000281000114ff00f4a413f4bcf2c80b01020120020d020148030402dcd020d749c120915b8f6320d70b1f2082106578746ebd21821073696e74bdb0925f03e082106578746eba8eb48020d72101d074d721fa4030fa44f828fa443058bd915be0ed44d0810141d721f4058307f40e6fa1319130e18040d721707fdb3ce03120d749810280b99130e070e2100f020120050c020120060902016e07080019adce76a2684020eb90eb85ffc00019af1df6a2684010eb90eb858fc00201480a0b0017b325fb51341c75c875c2c7e00011b262fb513435c280200019be5f0f6a2684080a0eb90fa02c0102f20e011e20d70b1f82107369676ebaf2e08a7f0f01e68ef0eda2edfb218308d722028308d723208020d721d31fd31fd31fed44d0d200d31f20d31fd3ffd70a000af90140ccf9109a28945f0adb31e1f2c087df02b35007b0f2d0845125baf2e0855036baf2e086f823bbf2d0882292f800de01a47fc8ca00cb1f01cf16c9ed542092f80fde70db3cd81003f6eda2edfb02f404216e926c218e4c0221d73930709421c700b38e2d01d72820761e436c20d749c008f2e09320d74ac002f2e09320d71d06c712c2005230b0f2d089d74cd7393001a4e86c128407bbf2e093d74ac000f2e093ed55e2d20001c000915be0ebd72c08142091709601d72c081c12e25210b1e30f20d74a111213009601fa4001fa44f828fa443058baf2e091ed44d0810141d718f405049d7fc8ca0040048307f453f2e08b8e14038307f45bf2e08c22d70a00216e01b3b0f2d090e2c85003cf1612f400c9ed54007230d72c08248e2d21f2e092d200ed44d0d2005113baf2d08f54503091319c01810140d721d70a00f2e08ee2c8ca0058cf16c9ed5493f2c08de20010935bdb31e1d74cd0b4d6c35e";
+var codeCell;
+function v5r1Code() {
+  codeCell ??= import_core5.Cell.fromBoc(import_buffer3.Buffer.from(V5R1_CODE_HEX, "hex"))[0];
+  return codeCell;
+}
+var V5R1_OP = {
+  signedExternal: 1936287598,
+  signedInternal: 1936289396,
+  extension: 1702392942
+};
+var MAINNET_GLOBAL_ID = -239;
+var TESTNET_GLOBAL_ID = -3;
+var DEFAULT_SEND_MODE = import_core5.SendMode.PAY_GAS_SEPARATELY | import_core5.SendMode.IGNORE_ERRORS;
+var MAX_ACTIONS = 255;
+function v5r1WalletId(parts = {}) {
+  const context = (0, import_core5.beginCell)().storeUint(1, 1).storeInt(parts.workchain ?? 0, 8).storeUint(0, 8).storeUint(parts.subwalletNumber ?? 0, 15).endCell().beginParse().loadInt(32);
+  return BigInt(parts.networkGlobalId ?? MAINNET_GLOBAL_ID) ^ BigInt(context);
+}
+function v5r1StateInit(publicKey, walletId = v5r1WalletId()) {
+  if (publicKey.length !== 32) throw new Error("V5R1: public key must be 32 bytes");
+  const data = (0, import_core5.beginCell)().storeUint(1, 1).storeUint(0, 32).storeInt(walletId, 32).storeBuffer(import_buffer3.Buffer.from(publicKey), 32).storeBit(0).endCell();
+  return { code: v5r1Code(), data };
+}
+function v5r1Address(publicKey, opts = {}) {
+  return (0, import_core5.contractAddress)(opts.workchain ?? 0, v5r1StateInit(publicKey, opts.walletId));
+}
+function v5r1SigningMessage(p) {
+  if (p.messages.length > MAX_ACTIONS) throw new Error(`V5R1: at most ${MAX_ACTIONS} messages per external (got ${p.messages.length})`);
+  const actions = p.messages.map((m) => ({
+    type: "sendMsg",
+    // Externals must carry IGNORE_ERRORS or the wallet contract rejects them.
+    mode: (m.mode ?? DEFAULT_SEND_MODE) | import_core5.SendMode.IGNORE_ERRORS,
+    outMsg: m.message
+  }));
+  const outList = actions.length ? (0, import_core5.beginCell)().store((0, import_core5.storeOutList)(actions)).endCell() : null;
+  return (0, import_core5.beginCell)().storeUint(V5R1_OP.signedExternal, 32).storeInt(p.walletId, 32).storeUint(p.validUntil, 32).storeUint(p.seqno, 32).storeMaybeRef(outList).storeUint(0, 1).endCell();
+}
+function v5r1PackSigned(signing, signature) {
+  if (signature.length !== 64) throw new Error("V5R1: signature must be 64 bytes");
+  return (0, import_core5.beginCell)().storeSlice(signing.beginParse()).storeBuffer(import_buffer3.Buffer.from(signature), 64).endCell();
+}
+function v5r1PackUnsigned(signing) {
+  return v5r1PackSigned(signing, new Uint8Array(64));
+}
+function v5r1ExternalMessage(to, body, init) {
+  return (0, import_core5.beginCell)().store((0, import_core5.storeMessage)((0, import_core5.external)({ to, body, ...init ? { init } : {} }))).endCell();
+}
+function parseV5R1Body(body) {
+  try {
+    const s = body.beginParse();
+    const op = s.loadUint(32);
+    if (op !== V5R1_OP.signedExternal && op !== V5R1_OP.signedInternal) return null;
+    const walletId = BigInt(s.loadInt(32));
+    const validUntil = s.loadUint(32);
+    const seqno = s.loadUint(32);
+    const outList = s.loadMaybeRef();
+    const hasExtended = s.loadBit();
+    if (hasExtended) return null;
+    const messages = [];
+    if (outList) {
+      for (const a of (0, import_core5.loadOutList)(outList.beginParse())) {
+        if (a.type !== "sendMsg") return null;
+        messages.push({ message: a.outMsg, mode: a.mode });
+      }
+    }
+    const signed = s.remainingBits >= 512;
+    return { op, walletId, validUntil, seqno, messages, signed };
+  } catch {
+    return null;
+  }
+}
+
+// src/describe.ts
+var import_core6 = require("@ton/core");
+var JETTON_TRANSFER_OP = 260734629;
+var LARGE_FORWARD_NANOTON = 500000000n;
+function decodeBody(body) {
+  const s = body.beginParse();
+  if (s.remainingBits === 0 && s.remainingRefs === 0) return { type: "empty" };
+  if (s.remainingBits < 32) return { type: "unknown" };
+  const op = s.loadUint(32);
+  try {
+    if (op === 0) return { type: "comment", text: s.loadStringTail() };
+    if (op === JETTON_TRANSFER_OP) return { type: "jetton-transfer", jetton: loadJettonTransfer(s) };
+  } catch {
+    return { type: "unknown" };
+  }
+  return { type: "op", op };
+}
+function loadJettonTransfer(s) {
+  const queryId = s.loadUintBig(64);
+  const amount = s.loadCoins();
+  const destination = s.loadAddress();
+  const responseDestination = s.loadMaybeAddress();
+  const customPayload = s.loadMaybeRef();
+  const forwardTonAmount = s.loadCoins();
+  const inRef = s.loadBit();
+  const payload = inRef ? s.loadRef().beginParse() : s;
+  let forwardPayload = "none";
+  let forwardComment;
+  if (payload.remainingBits > 0 || payload.remainingRefs > 0) {
+    forwardPayload = "cell";
+    if (payload.remainingBits >= 32) {
+      const p = payload.clone();
+      if (p.loadUint(32) === 0) {
+        try {
+          forwardComment = p.loadStringTail();
+          forwardPayload = "comment";
+        } catch {
+        }
+      }
+    }
+  }
+  return {
+    queryId,
+    amount,
+    destination: destination.toString(),
+    responseDestination: responseDestination ? responseDestination.toString() : null,
+    forwardTonAmount,
+    forwardPayload,
+    ...forwardComment !== void 0 ? { forwardComment } : {},
+    hasCustomPayload: customPayload !== null
+  };
+}
+function parseTo(to) {
+  if (import_core6.Address.isFriendly(to)) {
+    const f = import_core6.Address.parseFriendly(to);
+    return { to, bounceable: f.isBounceable, testOnly: f.isTestOnly, workchain: f.address.workChain };
+  }
+  const a = import_core6.Address.parse(to);
+  return { to: a.toRawString(), bounceable: true, workchain: a.workChain };
+}
+function bodyOf(tx) {
+  if (tx.body instanceof import_core6.Cell) return tx.body;
+  if (typeof tx.body === "string") return tx.body === "" ? void 0 : commentCell(tx.body);
+  if (tx.bodyBoc) return import_core6.Cell.fromBase64(tx.bodyBoc);
+  return void 0;
+}
+function commentCell(text) {
+  return (0, import_core6.beginCell)().storeUint(0, 32).storeStringTail(text).endCell();
+}
+function describeOne(i, to, value, body, hasStateInit, bounceableOverride, warnings, ctx) {
+  const bounceable = bounceableOverride ?? to.bounceable;
+  const decoded = body ? decodeBody(body) : { type: "empty" };
+  const base = { to: to.to, value, bounceable, ...to.testOnly !== void 0 ? { testOnly: to.testOnly } : {}, hasStateInit, bodyBits: body ? body.bits.length : 0 };
+  if (value <= 0n) warnings.push({ code: "zero-value", message: "message carries no TON; it cannot pay for gas at the destination", index: i });
+  if (to.workchain !== 0 && to.workchain !== -1) warnings.push({ code: "exotic-workchain", message: `workchain ${to.workchain}`, index: i });
+  if (ctx.network && to.testOnly !== void 0) {
+    if (to.testOnly && ctx.network !== "testnet") warnings.push({ code: "testnet-address", message: "test-only address on a mainnet wallet", index: i });
+    if (!to.testOnly && ctx.network === "testnet") warnings.push({ code: "mainnet-address", message: "mainnet address on a testnet wallet", index: i });
+  }
+  let item;
+  switch (decoded.type) {
+    case "empty":
+      item = { kind: "ton-transfer", ...base };
+      break;
+    case "comment":
+      item = { kind: "ton-transfer", ...base, comment: decoded.text };
+      break;
+    case "jetton-transfer":
+      item = { kind: "jetton-transfer", ...base, jetton: decoded.jetton, op: hex(JETTON_TRANSFER_OP) };
+      if (decoded.jetton.forwardTonAmount > LARGE_FORWARD_NANOTON) warnings.push({ code: "large-forward-amount", message: `forward_ton_amount ${decoded.jetton.forwardTonAmount} > 0.5 TON`, index: i });
+      break;
+    case "op":
+      item = { kind: "contract-call", ...base, op: hex(decoded.op) };
+      break;
+    default:
+      item = { kind: "contract-call", ...base };
+      warnings.push({ code: "unknown-body", message: "message body could not be decoded", index: i });
+  }
+  if (item.kind !== "ton-transfer" && !bounceable) {
+    warnings.push({ code: "non-bounceable-contract-call", message: "contract call to a non-bounceable address: TON is lost if the call fails", index: i });
+  }
+  return item;
+}
+var hex = (n) => `0x${n.toString(16).padStart(8, "0")}`;
+function describeMessageRelaxed(i, m, warnings, ctx = {}) {
+  if (m.info.type !== "internal") {
+    warnings.push({ code: "unknown-body", message: "not an internal message", index: i });
+    return { kind: "contract-call", to: "", value: 0n, bounceable: false, hasStateInit: false, bodyBits: 0 };
+  }
+  const dest = m.info.dest;
+  const to = { to: dest.toString({ bounceable: m.info.bounce }), bounceable: m.info.bounce, workchain: dest.workChain };
+  const body = m.body.bits.length === 0 && m.body.refs.length === 0 ? void 0 : m.body;
+  return describeOne(i, to, m.info.value.coins, body, !!m.init, m.info.bounce, warnings, ctx);
+}
+function describeTransaction(tx, ctx = {}) {
+  const warnings = [];
+  const items = [];
+  let external2;
+  if (tx instanceof import_core6.Cell) {
+    const parsed = parseV5R1Body(tx);
+    if (!parsed) {
+      warnings.push({ code: "unknown-body", message: "not a V5R1 signed-external body" });
+      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)));
+  } else {
+    const list = Array.isArray(tx) ? tx : [tx];
+    list.forEach((t, i) => {
+      let to;
+      try {
+        to = parseTo(t.to);
+      } catch {
+        warnings.push({ code: "unknown-body", message: `invalid address: ${t.to}`, index: i });
+        items.push({ kind: "contract-call", to: t.to, value: 0n, bounceable: false, hasStateInit: false, bodyBits: 0 });
+        return;
+      }
+      let body;
+      try {
+        body = bodyOf(t);
+      } 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));
+    });
+  }
+  const kinds = new Set(items.map((x) => x.kind));
+  const kind = kinds.size === 1 ? items[0].kind : kinds.size === 0 ? "contract-call" : "mixed";
+  return { kind, items, warnings, ...external2 ? { external: external2 } : {} };
+}
+
+// src/read-only-account.ts
+var import_core7 = require("@anywalletkit/core");
+var import_ed25519 = require("@noble/curves/ed25519.js");
+var import_core8 = require("@ton/core");
+var JETTON_TRANSFER_OP2 = 260734629;
+var DEFAULT_JETTON_ATTACHED = 50000000n;
+var DEFAULT_INDEXER = "https://toncenter.com/api/v3";
+var DEFAULT_VALID_SECONDS = 60;
+var MAX_VALID_SECONDS = 600;
+var SEND_MODE = DEFAULT_SEND_MODE;
+var utf8 = (s) => typeof s === "string" ? new TextEncoder().encode(s) : s;
+var hexToBytes = (h) => Uint8Array.from(h.match(/.{2}/g) ?? [], (b) => parseInt(b, 16));
+var big = (v) => BigInt(v);
+var WalletAccountReadOnlyTon = class {
+  chain;
+  /** Ed25519 public key the wallet is derived from. */
+  publicKey;
+  /** User-friendly address. */
+  address;
+  _config;
+  _walletId;
+  _init;
+  _address;
+  _rpc;
+  constructor(publicKey, config = {}) {
+    this.publicKey = typeof publicKey === "string" ? hexToBytes(publicKey) : publicKey;
+    this._config = config;
+    const networkGlobalId = config.network === "testnet" ? TESTNET_GLOBAL_ID : MAINNET_GLOBAL_ID;
+    if (config.walletId?.networkGlobalId !== void 0 && config.walletId.networkGlobalId !== networkGlobalId) {
+      throw new UnsafeTransactionError("network-mismatch", `walletId.networkGlobalId ${config.walletId.networkGlobalId} contradicts network '${config.network ?? "mainnet"}' (expected ${networkGlobalId}): externals signed this way would be valid on the other network.`);
+    }
+    this._walletId = v5r1WalletId({ networkGlobalId, ...config.walletId?.subwalletNumber !== void 0 ? { subwalletNumber: config.walletId.subwalletNumber } : {} });
+    this._init = v5r1StateInit(this.publicKey, this._walletId);
+    this._address = v5r1Address(this.publicKey, { walletId: this._walletId });
+    this.address = this._address.toString({ bounceable: false, testOnly: config.network === "testnet" });
+    this.chain = CAIP2[config.network ?? "mainnet"];
+    const rpc = createTonRpc(config);
+    this._rpc = rpc ? new TonCenter(rpc) : void 0;
+  }
+  requireRpc(what) {
+    if (!this._rpc) throw new import_core7.NetworkError(`The wallet must be connected to a provider (toncenter) to ${what}.`);
+    return this._rpc;
+  }
+  /** The user-friendly address. */
+  async getAddress() {
+    return this.address;
+  }
+  /** Native balance in nanotons. */
+  async getBalance() {
+    return (await this.requireRpc("get balances").getAddressInformation(this._address)).balance;
+  }
+  /** Current seqno — 0 until the wallet contract is deployed. Always fetched fresh. */
+  async getSeqno() {
+    const rpc = this.requireRpc("read the seqno");
+    const state = await rpc.getAddressInformation(this._address);
+    if (state.state !== "active") return 0;
+    return (await rpc.runGetMethodOk(this._address, "seqno")).stack.readNumber();
+  }
+  /** Resolve this wallet's jetton wallet for a jetton master. */
+  async getJettonWalletAddress(token) {
+    const rpc = this.requireRpc("resolve jetton wallets");
+    const r = await rpc.runGetMethodOk(import_core8.Address.parse(token), "get_wallet_address", [
+      { type: "slice", cell: (0, import_core8.beginCell)().storeAddress(this._address).endCell() }
+    ]);
+    return r.stack.readAddress();
+  }
+  /**
+   * Read a jetton wallet and prove it is ours for `token`: `get_wallet_data`
+   * must name this wallet as owner and `token` as master. The master's own
+   * `get_wallet_address` answer is not trusted on its own — a fake master could
+   * point at our real wallet of another jetton (e.g. USDT).
+   */
+  async jettonWalletData(token, jw) {
+    const stack = (await this.requireRpc("read jetton wallets").runGetMethodOk(jw, "get_wallet_data")).stack;
+    const balance = stack.readBigNumber();
+    const owner = stack.readAddress();
+    const master = stack.readAddress();
+    if (!owner.equals(this._address) || !master.equals(import_core8.Address.parse(token))) {
+      throw new UnsafeTransactionError("jetton-wallet", `The jetton wallet ${jw.toString()} does not belong to this wallet for ${token}.`);
+    }
+    return balance;
+  }
+  /**
+   * Jetton balance in base units, read from this wallet's jetton wallet; 0 when it does not exist.
+   */
+  async getTokenBalance(token) {
+    const rpc = this.requireRpc("get token balances");
+    const jw = await this.getJettonWalletAddress(token);
+    if ((await rpc.getAddressInformation(jw)).state !== "active") return 0n;
+    return this.jettonWalletData(token, jw);
+  }
+  // ── Message building ──────────────────────────────────────────────────────
+  stateInitOf(src) {
+    if (src === void 0) return void 0;
+    if (typeof src === "string") return (0, import_core8.loadStateInit)(import_core8.Cell.fromBase64(src).beginParse());
+    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.");
+    let address;
+    let bounceable = true;
+    let testOnly;
+    if (import_core8.Address.isFriendly(tx.to)) {
+      const f = import_core8.Address.parseFriendly(tx.to);
+      address = f.address;
+      bounceable = f.isBounceable;
+      testOnly = f.isTestOnly;
+    } else {
+      address = import_core8.Address.parse(tx.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.");
+    }
+    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 } : {} });
+    return { message, ...tx.sendMode !== void 0 ? { mode: tx.sendMode } : {} };
+  }
+  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 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 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 }) };
+  }
+  toMessages(tx) {
+    const list = Array.isArray(tx) ? tx : [tx];
+    if (list.length === 0) throw new UnsafeTransactionError("empty", "Nothing to send.");
+    return list.map((t) => this.transactionMessage(t));
+  }
+  validUntil() {
+    const seconds = this._config.validUntilSeconds ?? DEFAULT_VALID_SECONDS;
+    if (!Number.isInteger(seconds) || seconds <= 0 || seconds > MAX_VALID_SECONDS) {
+      throw new UnsafeTransactionError("valid-until", `validUntilSeconds must be an integer between 1 and ${MAX_VALID_SECONDS}.`);
+    }
+    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();
+    const validUntil = this.validUntil();
+    return { signing: v5r1SigningMessage({ walletId: this._walletId, validUntil, seqno, messages }), seqno, validUntil };
+  }
+  // ── Fees / preflight ──────────────────────────────────────────────────────
+  /** StateInit to attach to an external when the wallet is not deployed yet. */
+  async initIfNeeded() {
+    const state = await this.requireRpc("read the account state").getAddressInformation(this._address);
+    return state.state === "active" ? void 0 : this._init;
+  }
+  /** in_fwd + storage + gas + fwd from toncenter's estimateFee (signature ignored). */
+  async estimateFees(body) {
+    const rpc = this.requireRpc("quote transfers");
+    const init = await this.initIfNeeded();
+    return rpc.estimateFee(this._address, { body, ...init ? { init } : {}, ignoreSignature: true });
+  }
+  /**
+   * Preflight an external body: fees via estimateFee and, unless
+   * `config.emulate === false`, a trace emulation (tonapi by default, see
+   * {@link TonConfig.emulate}) whose compute/action phases — and the first-hop
+   * internal messages — decide `ok`. Never throws for a failing emulation,
+   * only for transport problems or a malformed emulator response.
+   */
+  async simulateBody(body) {
+    const fees = await this.estimateFees(body);
+    const init = await this.initIfNeeded();
+    const outcome = await runEmulation(this._config, v5r1ExternalMessage(this._address, body, init));
+    if (!outcome) return { ok: true, fees, emulated: false, source: "estimate-only", warnings: [] };
+    const common = {
+      fees,
+      emulated: true,
+      source: outcome.source,
+      warnings: outcome.warnings,
+      ...outcome.exitCode !== void 0 ? { exitCode: outcome.exitCode } : {},
+      ...outcome.risk ? { risk: outcome.risk } : {}
+    };
+    if (outcome.ok) return { ok: true, ...common, ...outcome.actionSuccess !== void 0 ? { actionSuccess: outcome.actionSuccess } : {} };
+    return { ok: false, ...common, reason: outcome.reason ?? "emulation failed", ...outcome.aborted !== void 0 ? { aborted: outcome.aborted } : {} };
+  }
+  /** Preflight a {@link TonSendable} (unsigned body, current seqno). */
+  async simulateTransaction(tx) {
+    const body = tx instanceof import_core8.Cell ? tx : v5r1PackUnsigned((await this.signingCell(this.toMessages(tx))).signing);
+    return this.simulateBody(body);
+  }
+  /** Estimated fee of a transaction, in nanotons. */
+  async quoteSendTransaction(tx) {
+    const body = tx instanceof import_core8.Cell ? tx : v5r1PackUnsigned((await this.signingCell(this.toMessages(tx))).signing);
+    return { fee: (await this.estimateFees(body)).total };
+  }
+  /** Estimated fee of a transfer, in nanotons. */
+  async quoteTransfer(o) {
+    const message = o.token ? await this.jettonTransferMessage(o) : this.transactionMessage({ to: o.recipient, value: o.amount, ...o.memo !== void 0 ? { body: o.memo } : {} });
+    const { signing } = await this.signingCell([message]);
+    return { fee: (await this.estimateFees(v5r1PackUnsigned(signing))).total };
+  }
+  /** Offline description of what `tx` does — see {@link describeTransaction}. */
+  describe(tx) {
+    return describeTransaction(tx, { network: this._config.network ?? "mainnet" });
+  }
+  /**
+   * Receipt for a body hash returned by sendTransaction: toncenter v3 maps the
+   * message body hash to the account transaction, which is then fetched.
+   */
+  async getTransactionReceipt(hash) {
+    const rpc = this.requireRpc("fetch transaction receipts");
+    const base = this._config.indexerUrl ?? DEFAULT_INDEXER;
+    const doFetch = this._config.fetch ?? globalThis.fetch;
+    const res = await doFetch(`${base}/transactionsByMessage?${new URLSearchParams({ body_hash: hash, limit: "1" })}`, { signal: AbortSignal.timeout(this._config.timeoutMs ?? 15e3) });
+    if (!res.ok) throw new import_core7.NetworkError(`toncenter v3 ${res.status}`, { provider: base });
+    const { transactions } = await res.json();
+    const found = transactions?.[0];
+    if (!found) return void 0;
+    const account = import_core8.Address.parse(found.account);
+    let tx;
+    try {
+      [tx] = await rpc.getTransactions(account, { limit: 1, hash: found.hash });
+    } catch {
+      [tx] = await rpc.getTransactions(account, { limit: 1, lt: found.lt, hash: found.hash, archival: true });
+    }
+    if (!tx) return void 0;
+    const d = tx.description;
+    return { hash, status: d.type === "generic" && !d.aborted ? 1 : 0, blockNumber: tx.lt, transactionHash: tx.hash().toString("base64"), totalFees: tx.totalFees.coins, raw: tx };
+  }
+  /** ed25519 over the raw message bytes; `signature` hex. */
+  async verify(message, signature) {
+    try {
+      return import_ed25519.ed25519.verify(hexToBytes(signature), utf8(message), this.publicKey);
+    } catch {
+      return false;
+    }
+  }
+};
+function randomQueryId() {
+  const r = new Uint32Array(2);
+  globalThis.crypto.getRandomValues(r);
+  return BigInt(r[0]) << 32n | BigInt(r[1]);
+}
+
+// src/account.ts
+var import_core9 = require("@anywalletkit/core");
+var import_core10 = require("@ton/core");
+var toHex = (u8) => Array.from(u8, (b) => b.toString(16).padStart(2, "0")).join("");
+var WalletAccountTon = class _WalletAccountTon extends WalletAccountReadOnlyTon {
+  /** seqno and fees come from the network before signing. */
+  needsNetwork = true;
+  /** Derivation path, `ton-mnemonic`, or `external`. */
+  path;
+  /** The signer that holds the key. */
+  signer;
+  _readOnly;
+  /** `publicKey` is the signer's 32-byte ed25519 key; the V5R1 address derives from it synchronously. */
+  constructor(signer, publicKey, path, config = {}) {
+    super(publicKey, config);
+    this.signer = (0, import_core9.requireCurve)(signer, "ed25519");
+    this.path = path;
+  }
+  /** Back-compat: wrap a raw derived key in a {@link LocalSigner} (the account takes ownership; it cannot derive). */
+  static fromPrivateKey(privateKey, publicKey, path, config = {}) {
+    return new _WalletAccountTon(import_core9.LocalSigner.fromPrivateKey("ed25519", privateKey, publicKey, path), publicKey, path, config);
+  }
+  /** Account index for the standard m/44'/607'/i' path. */
+  get index() {
+    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). */
+  async sign(message) {
+    const bytes = typeof message === "string" ? new TextEncoder().encode(message) : message;
+    return toHex(await this.signer.sign(bytes, { scheme: "ed25519", context: "ton-message" }));
+  }
+  checkMaxFee(fee, limit, op) {
+    if (limit !== void 0 && fee > BigInt(limit)) throw new Error(`Exceeded maximum fee cost for ${op} operation.`);
+  }
+  /**
+   * 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) {
+    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 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 };
+  }
+  async preflight(body, limit, op, expectedTonOut) {
+    if (this._config.simulate === false) {
+      if (limit === void 0) return 0n;
+      const fee = (await this.estimateFees(body)).total;
+      this.checkMaxFee(fee, limit, op);
+      return fee;
+    }
+    const sim = await this.simulateBody(body);
+    if (!sim.ok) throw new SimulationError(sim.reason, { ...sim.exitCode !== void 0 ? { exitCode: sim.exitCode } : {}, ...sim.aborted !== void 0 ? { aborted: sim.aborted } : {} });
+    if (sim.risk?.transferAllRemainingBalance && this._config.allowDrainingTransactions !== true) {
+      throw new UnsafeTransactionError("drain", "Refusing a message that carries the whole remaining balance (send mode 128); set allowDrainingTransactions to override.");
+    }
+    if (expectedTonOut !== void 0 && sim.risk && sim.risk.ton < expectedTonOut) {
+      throw new SimulationError(`The emulation shows only ${sim.risk.ton} nanotons leaving the wallet for messages carrying ${expectedTonOut}: a message would be dropped (insufficient balance for value + fees).`);
+    }
+    this.checkMaxFee(sim.fees.total, limit, op);
+    return sim.fees.total;
+  }
+  /** Sign without broadcasting. Returns the external-message BODY as base64 BoC (pass it back to sendTransaction as a Cell). */
+  async signTransaction(tx) {
+    if (tx instanceof import_core10.Cell) {
+      await this.preflight(tx, this._config.transactionMaxFee, "transaction");
+      return tx.toBoc().toString("base64");
+    }
+    const { body } = await this.prepare(this.toMessages(tx), this._config.transactionMaxFee, "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");
+  }
+  /** Sign and broadcast; `hash` is the body hash (hex) — resolve it with getTransactionReceipt. */
+  async sendTransaction(tx) {
+    this.requireRpc("send transactions");
+    const { body, fee } = tx instanceof import_core10.Cell ? { body: tx, fee: await this.preflight(tx, this._config.transactionMaxFee, "transaction") } : await this.prepare(this.toMessages(tx), this._config.transactionMaxFee, "transaction");
+    return { hash: await this.broadcast(body), fee };
+  }
+  /** TON (no `token`) or jetton transfer. */
+  async transfer(o) {
+    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], this._config.transferMaxFee, "transfer");
+    return { hash: await this.broadcast(body), fee };
+  }
+  /** The same wallet as a {@link WalletAccountReadOnlyTon}. */
+  toReadOnlyAccount() {
+    this._readOnly ??= new WalletAccountReadOnlyTon(this.publicKey, this._config);
+    return this._readOnly;
+  }
+  /** Disposes the signer: a local key is zeroized, an external one is released. */
+  dispose() {
+    this.signer.dispose();
+  }
+};
+
+// src/manager.ts
+var import_core11 = require("@anywalletkit/core");
+var import_crypto = require("@ton/crypto");
+var TON_BASE_PATH = "m/44'/607'";
+var TON_MNEMONIC_PATH = "ton-mnemonic";
+var WalletManagerTon = class _WalletManagerTon extends import_core11.WalletManager {
+  constructor(seedOrSigner, config = {}) {
+    super(seedOrSigner, config);
+  }
+  /**
+   * Import a TON-native mnemonic (24 words, Tonkeeper / Tonhub / MyTonWallet
+   * default): PBKDF2 per @ton/crypto, one ed25519 key, one V5R1 account at
+   * path `ton-mnemonic` with the address those wallets show.
+   */
+  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.");
+    const pair = await (0, import_crypto.mnemonicToPrivateKey)(list);
+    const privateKey = new Uint8Array(pair.secretKey.subarray(0, 32));
+    const publicKey = new Uint8Array(pair.publicKey);
+    (0, import_core11.zeroize)(new Uint8Array(pair.secretKey.buffer, pair.secretKey.byteOffset, pair.secretKey.byteLength));
+    return new _WalletManagerTon(import_core11.LocalSigner.fromPrivateKey("ed25519", privateKey, publicKey, TON_MNEMONIC_PATH), config);
+  }
+  async getAccount(index = 0) {
+    const external2 = this.externalSigner();
+    if (external2 && !((0, import_core11.isSeedSigner)(external2) && external2.path === TON_BASE_PATH)) {
+      if (index !== 0) throw new import_core11.SignerError(`This signer yields a single account (index 0); ${index} is not derivable from it.`);
+      return this.fromSigner(external2, this.singlePath(external2));
+    }
+    return this.getAccountByPath(`${TON_BASE_PATH}/${index}'`);
+  }
+  async getAccountByPath(path) {
+    const external2 = this.externalSigner();
+    if (external2) {
+      const single = this.singlePath(external2);
+      const full2 = path === single || path.startsWith("m/") ? path : `${TON_BASE_PATH}/${path}`;
+      return this.fromSigner(external2, full2);
+    }
+    const full = path.startsWith("m/") ? path : `${TON_BASE_PATH}/${path}`;
+    const cached = this._accounts.get(full);
+    if (cached) return cached;
+    const signer = import_core11.LocalSigner.leafFromSeed(this.seedBytes(), "ed25519", full);
+    const account = new WalletAccountTon(signer, signer.publicKey, full, this._config);
+    this._accounts.set(full, account);
+    return account;
+  }
+  /** The one path a non-derivable signer answers to: its own, or 'external'. */
+  singlePath(signer) {
+    return (0, import_core11.isSeedSigner)(signer) ? signer.path : "external";
+  }
+  /** Resolve `path` against an injected signer: the signer itself, or a child when it can derive there. */
+  async fromSigner(signer, path) {
+    this.requireSigner("ed25519");
+    let leaf = signer;
+    let key = this.singlePath(signer);
+    if ((0, import_core11.isSeedSigner)(signer)) {
+      if (path === signer.path) key = path;
+      else if (path.startsWith(`${signer.path}/`)) {
+        leaf = await (signer.deriveLeaf ?? signer.derive).call(signer, path.slice(signer.path.length + 1));
+        key = path;
+      } else throw new import_core11.SignerError(`This signer yields a single account at path '${signer.path}'; it cannot provide ${path}.`);
+    } else if (path !== `${TON_BASE_PATH}/0'` && path !== "external") {
+      throw new import_core11.SignerError(`An external signer yields a single account; ${path} is not derivable from it.`);
+    }
+    const cached = this._accounts.get(key);
+    if (cached) return cached;
+    const account = new WalletAccountTon(leaf, await leaf.getPublicKey(), key, this._config);
+    this._accounts.set(key, account);
+    return account;
+  }
+  /** Watch-only account for a public key (hex or bytes) — TON addresses derive from the key, not the other way round. */
+  getReadOnlyAccount(publicKey) {
+    return new WalletAccountReadOnlyTon(publicKey, this._config);
+  }
+  /** Gas price from config param 21 via tonapi (normal = fast there; slow = ×0.8 here). */
+  async getFeeRates() {
+    const doFetch = this._config.fetch ?? globalThis.fetch;
+    const res = await doFetch(`${this._config.tonApiUrl ?? DEFAULT_TONAPI}/blockchain/config/raw`, { signal: AbortSignal.timeout(this._config.timeoutMs ?? 15e3) });
+    const json = await res.json();
+    const normal = BigInt(Math.round(json.config.config_param21.gas_limits_prices.gas_flat_pfx.other.gas_prices_ext.gas_price / 65536));
+    return { slow: normal * 80n / 100n, normal, fast: normal };
+  }
+};
+
+// src/history.ts
+var import_core12 = require("@ton/core");
+var import_buffer4 = require("buffer");
+var HistoryUnavailableError = class extends Error {
+  chain;
+  reason;
+  attempts;
+  constructor(chain, reason, attempts = []) {
+    super(`History unavailable for ${chain}: ${reason}`);
+    this.name = "HistoryUnavailableError";
+    this.chain = chain;
+    this.reason = reason;
+    this.attempts = attempts;
+  }
+};
+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");
+}
+function decodeCursor(s) {
+  let parsed;
+  try {
+    parsed = JSON.parse(import_buffer4.Buffer.from(s, "base64").toString("utf8"));
+  } catch {
+    throw new Error("@anywalletkit/wallet-ton: malformed history cursor");
+  }
+  const c = parsed;
+  if (!c || c.v !== 1 || c.b !== "tonapi" && c.b !== "toncenter" || typeof c.lt !== "string" || !/^\d+$/.test(c.lt)) {
+    throw new Error("@anywalletkit/wallet-ton: malformed history cursor");
+  }
+  return { v: 1, b: c.b, lt: c.lt };
+}
+var TokenBucket = class {
+  constructor(rate, burst = Math.max(1, Math.ceil(rate))) {
+    this.rate = rate;
+    this.burst = burst;
+    this.tokens = burst;
+  }
+  rate;
+  burst;
+  tokens;
+  last = Date.now();
+  chain = Promise.resolve();
+  acquire() {
+    const next = this.chain.then(() => this.take());
+    this.chain = next.catch(() => void 0);
+    return next;
+  }
+  refill() {
+    const now = Date.now();
+    this.tokens = Math.min(this.burst, this.tokens + (now - this.last) / 1e3 * this.rate);
+    this.last = now;
+  }
+  async take() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return;
+    }
+    await new Promise((r) => setTimeout(r, Math.ceil((1 - this.tokens) / this.rate * 1e3)));
+    this.refill();
+    this.tokens = Math.max(0, this.tokens - 1);
+  }
+};
+function timeoutSignal(ms) {
+  const ctor = globalThis.AbortSignal;
+  return typeof ctor?.timeout === "function" ? ctor.timeout(ms) : void 0;
+}
+function rawTonAddress(a) {
+  try {
+    return import_core12.Address.parse(a).toRawString().toLowerCase();
+  } catch {
+    return a.toLowerCase();
+  }
+}
+var big2 = (v) => {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number" && Number.isFinite(v)) return BigInt(Math.trunc(v));
+  if (typeof v === "string" && /^-?\d+$/.test(v)) return BigInt(v);
+  return 0n;
+};
+var isHexOp = (s) => typeof s === "string" && /^0x[0-9a-f]{1,8}$/i.test(s);
+var jettonMeta = (j) => {
+  const m = {};
+  if (j?.symbol !== void 0) m.symbol = j.symbol;
+  if (j?.decimals !== void 0) m.decimals = j.decimals;
+  return m;
+};
+var addr = (a) => typeof a === "object" && a !== null && typeof a.address === "string" ? a.address.toLowerCase() : typeof a === "string" ? a.toLowerCase() : void 0;
+var isWallet = (a) => typeof a === "object" && a !== null && a.is_wallet === true;
+function mapActions(actions) {
+  const out = { transfers: [] };
+  const native = (from, to, amount) => {
+    if (from === void 0 || to === void 0 || amount <= 0n) return;
+    out.transfers.push({ token: null, from, to, amount });
+  };
+  const jetton = (j, from, to, amount) => {
+    if (!j || from === void 0 || to === void 0 || amount <= 0n) return;
+    out.transfers.push({ token: j.address.toLowerCase(), from, to, amount, standard: "jetton", ...jettonMeta(j) });
+  };
+  const setCall = (c) => {
+    if (c && !out.call) out.call = c;
+  };
+  const init = (a) => {
+    if (out.initiator === void 0 && a !== void 0) out.initiator = a;
+  };
+  for (const a of actions) {
+    const b = a[a.type] ?? {};
+    const ok = a.status === "ok";
+    switch (a.type) {
+      case "TonTransfer": {
+        const from = addr(b.sender), to = addr(b.recipient);
+        init(from);
+        if (ok) native(from, to, big2(b.amount));
+        break;
+      }
+      case "JettonTransfer": {
+        const from = addr(b.sender) ?? addr(b.senders_wallet), to = addr(b.recipient) ?? addr(b.recipients_wallet);
+        init(from);
+        if (ok) jetton(b.jetton, from, to, big2(b.amount));
+        if (to !== void 0 && b.recipient !== void 0 && !isWallet(b.recipient)) {
+          const c = { to, method: "jetton_transfer" };
+          const m = typeof b.comment === "string" ? /^Call:\s*(0x[0-9a-f]+)/i.exec(b.comment) : null;
+          if (m) c.data = m[1].toLowerCase();
+          setCall(c);
+        }
+        break;
+      }
+      case "JettonMint": {
+        const j = b.jetton;
+        if (ok) jetton(j, j?.address.toLowerCase(), addr(b.recipient) ?? addr(b.recipients_wallet), big2(b.amount));
+        break;
+      }
+      case "JettonBurn": {
+        const j = b.jetton;
+        const from = addr(b.sender) ?? addr(b.senders_wallet);
+        init(from);
+        if (ok) jetton(j, from, j?.address.toLowerCase(), big2(b.amount));
+        setCall(j ? { to: j.address.toLowerCase(), method: "jetton_burn" } : void 0);
+        break;
+      }
+      case "JettonSwap": {
+        const user = addr(b.user_wallet), router = addr(b.router);
+        init(user);
+        if (ok) {
+          native(user, router, big2(b.ton_in));
+          jetton(b.jetton_master_in, user, router, big2(b.amount_in));
+          native(router, user, big2(b.ton_out));
+          jetton(b.jetton_master_out, router, user, big2(b.amount_out));
+        }
+        if (router !== void 0) setCall({ to: router, method: "swap" });
+        break;
+      }
+      case "SmartContractExec": {
+        const executor = addr(b.executor), contract = addr(b.contract);
+        init(executor);
+        if (ok) native(executor, contract, big2(b.ton_attached));
+        if (contract !== void 0) {
+          const c = { to: contract };
+          if (isHexOp(b.operation)) c.data = b.operation.toLowerCase();
+          else if (typeof b.operation === "string" && b.operation) c.method = b.operation;
+          setCall(c);
+        }
+        break;
+      }
+      case "DepositStake": {
+        const staker = addr(b.staker), pool = addr(b.pool);
+        init(staker);
+        if (ok) native(staker, pool, big2(b.amount));
+        if (pool !== void 0) setCall({ to: pool, method: "stake" });
+        break;
+      }
+      case "WithdrawStakeRequest": {
+        const staker = addr(b.staker), pool = addr(b.pool);
+        init(staker);
+        if (ok && b.amount !== void 0) native(staker, pool, big2(b.amount));
+        if (pool !== void 0) {
+          setCall({ to: pool, method: "unstake" });
+          if (ok) out.needsValueFlow ??= { counterparty: pool };
+        }
+        break;
+      }
+      case "WithdrawStake": {
+        const staker = addr(b.staker), pool = addr(b.pool);
+        init(pool);
+        if (ok) native(pool, staker, big2(b.amount));
+        if (pool !== void 0) setCall({ to: pool, method: "withdraw_stake" });
+        break;
+      }
+      case "ElectionsDepositStake":
+      case "ElectionsRecoverStake": {
+        const staker = addr(b.staker);
+        init(staker);
+        if (ok) a.type === "ElectionsDepositStake" ? native(staker, "-1:3333333333333333333333333333333333333333333333333333333333333333", big2(b.amount)) : native("-1:3333333333333333333333333333333333333333333333333333333333333333", staker, big2(b.amount));
+        break;
+      }
+      case "Subscribe":
+      case "UnSubscribe": {
+        const subscriber = addr(b.subscriber), beneficiary = addr(b.beneficiary), subscription = addr(b.subscription);
+        init(subscriber);
+        if (ok && a.type === "Subscribe") native(subscriber, beneficiary, big2(b.amount));
+        if (subscription !== void 0) setCall({ to: subscription, method: a.type === "Subscribe" ? "subscribe" : "unsubscribe" });
+        break;
+      }
+      case "NftPurchase": {
+        const buyer = addr(b.buyer), seller = addr(b.seller), nft = addr(b.nft);
+        init(buyer);
+        if (ok) native(buyer, seller, big2(b.amount?.value ?? b.amount));
+        if (nft !== void 0) setCall({ to: nft, method: "nft_purchase" });
+        break;
+      }
+      case "ContractDeploy": {
+        const deployed = addr(b.address);
+        if (deployed !== void 0) setCall({ to: deployed, method: "deploy" });
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return out;
+}
+function valueFlowTransfers(event, own, counterparty) {
+  const flow = event.value_flow?.find((v) => addr(v.account) === own);
+  const out = [];
+  for (const j of flow?.jettons ?? []) {
+    const q = big2(j.quantity);
+    if (q === 0n) continue;
+    const t = { token: j.jetton.address.toLowerCase(), from: q < 0n ? own : counterparty, to: q < 0n ? counterparty : own, amount: q < 0n ? -q : q, standard: "jetton", ...jettonMeta(j.jetton) };
+    out.push(t);
+  }
+  return out;
+}
+function mapTonapiEvent(chain, address, own, event, valueFlow) {
+  const mapped = mapActions(event.actions ?? []);
+  const transfers = mapped.transfers;
+  const raw = { backend: "tonapi", event };
+  if (mapped.needsValueFlow && valueFlow) {
+    raw.valueFlow = valueFlow.value_flow;
+    const extra = valueFlowTransfers(valueFlow, own, mapped.needsValueFlow.counterparty);
+    for (const t of extra) if (!transfers.some((x) => x.token === t.token && x.from === t.from && x.to === t.to && x.amount === t.amount)) transfers.push(t);
+  }
+  const from = mapped.initiator ?? own;
+  const involves = (t) => t.from === own || t.to === own;
+  const primary = transfers.find((t) => t.token !== null && involves(t)) ?? transfers.find(involves) ?? transfers[0];
+  const to = mapped.call?.to ?? primary?.to ?? null;
+  let nativeValue = 0n;
+  for (const t of transfers) if (t.token === null && t.from === from) nativeValue += t.amount;
+  const actions = event.actions ?? [];
+  const status = event.in_progress ? "pending" : actions.length > 0 && actions.every((a) => a.status !== "ok") ? "failed" : "confirmed";
+  const out = {
+    chain,
+    hash: event.event_id,
+    time: event.timestamp,
+    status,
+    address,
+    from,
+    to,
+    nativeValue,
+    transfers,
+    block: big2(event.lt),
+    raw
+  };
+  if (typeof event.extra === "number" && event.extra < 0) out.fee = BigInt(-event.extra);
+  if (mapped.call) out.call = mapped.call;
+  if (event.is_scam) {
+    out.scam = true;
+    raw.scam = true;
+  }
+  return out;
+}
+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 d = row.description;
+  const failed = d?.aborted === true || d?.compute_ph?.skipped !== true && d?.compute_ph?.success === false || d?.action?.success === false;
+  const transfers = [];
+  let from = own;
+  let to = null;
+  let call;
+  const source = row.in_msg?.source ? row.in_msg.source.toLowerCase() : void 0;
+  if (source === void 0) {
+    for (const m of row.out_msgs ?? []) {
+      const dest = m.destination?.toLowerCase();
+      if (!dest) continue;
+      const value = big2(m.value);
+      if (value > 0n) transfers.push({ token: null, from: own, to: dest, amount: value });
+      if (!call && m.opcode && m.opcode !== TEXT_COMMENT_OP) {
+        call = { to: dest, data: m.opcode.toLowerCase() };
+        if (m.decoded_opcode) call.method = m.decoded_opcode;
+      }
+      to ??= dest;
+    }
+  } else {
+    from = source;
+    to = own;
+    const value = big2(row.in_msg?.value);
+    if (value > 0n) transfers.push({ token: null, from: source, to: own, amount: value });
+    const op = row.in_msg?.opcode;
+    if (op && op !== TEXT_COMMENT_OP) {
+      call = { to: own, data: op.toLowerCase() };
+      if (row.in_msg?.decoded_opcode) call.method = row.in_msg.decoded_opcode;
+    }
+  }
+  let nativeValue = 0n;
+  for (const t of transfers) if (t.token === null && t.from === from) nativeValue += t.amount;
+  const out = {
+    chain,
+    hash,
+    time: row.now,
+    status: failed ? "failed" : "confirmed",
+    address,
+    from,
+    to: call?.to ?? to,
+    nativeValue,
+    transfers,
+    fee: big2(row.total_fees),
+    block: big2(row.lt),
+    raw: { backend: "toncenter", event: row }
+  };
+  if (call) out.call = call;
+  return out;
+}
+function tonExplorerTxUrl(hash, network = "mainnet") {
+  return `https://${network === "testnet" ? "testnet." : ""}tonviewer.com/transaction/${hash}`;
+}
+function createTonHistory(options = {}) {
+  const network = options.network ?? "mainnet";
+  const chain = CAIP2[network];
+  const fetchFn = options.fetch ?? globalThis.fetch;
+  if (typeof fetchFn !== "function") throw new Error("@anywalletkit/wallet-ton: no global fetch; pass `fetch` in the options");
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS3;
+  const tonapiUrl = options.tonapiUrl === null ? void 0 : (options.tonapiUrl ?? (network === "testnet" ? "https://testnet.tonapi.io" : "https://tonapi.io")).replace(/\/+$/, "");
+  const toncenterUrl = options.toncenterUrl === null ? void 0 : (options.toncenterUrl ?? (network === "testnet" ? "https://testnet.toncenter.com" : "https://toncenter.com")).replace(/\/+$/, "");
+  if (!tonapiUrl && !toncenterUrl) throw new Error("@anywalletkit/wallet-ton: createTonHistory needs tonapi or toncenter");
+  const tonapiBucket = new TokenBucket(options.rateLimit ?? (options.apiKey ? 10 : 1));
+  const toncenterBucket = new TokenBucket(options.toncenterApiKey ? 10 : 1);
+  async function getJson(backend, url, headers) {
+    await (backend === "tonapi" ? tonapiBucket : toncenterBucket).acquire();
+    let res;
+    try {
+      const signal = timeoutSignal(timeoutMs);
+      res = await fetchFn(url, { headers: { accept: "application/json", ...headers }, ...signal ? { signal } : {} });
+    } catch (e) {
+      throw new Error(`${backend}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = void 0;
+    }
+    return { status: res.status, body };
+  }
+  const tonapiHeaders = () => options.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {};
+  const toncenterHeaders = () => options.toncenterApiKey ? { "x-api-key": options.toncenterApiKey } : {};
+  const fail = (backend, r) => {
+    const msg = typeof r.body === "object" && r.body !== null && typeof r.body.error === "string" ? r.body.error : "";
+    throw new Error(`${backend}: HTTP ${r.status}${msg ? ` ${msg}` : ""}`);
+  };
+  async function tonapiEventFull(eventId) {
+    const r = await getJson("tonapi", `${tonapiUrl}/v2/events/${eventId}`, tonapiHeaders());
+    if (r.status === 404) return void 0;
+    if (r.status !== 200) fail("tonapi", r);
+    return r.body;
+  }
+  async function finishTonapi(address, own, event) {
+    const probe = mapActions(event.actions ?? []);
+    let flow;
+    if (probe.needsValueFlow) {
+      try {
+        flow = await tonapiEventFull(event.event_id);
+      } catch {
+        flow = void 0;
+      }
+    }
+    return mapTonapiEvent(chain, address, own, event, flow);
+  }
+  async function tonapiPage(address, own, limit, before) {
+    if (!tonapiUrl) throw new Error("tonapi: disabled");
+    const q = `limit=${limit}${before ? `&before_lt=${before}` : ""}`;
+    const r = await getJson("tonapi", `${tonapiUrl}/v2/accounts/${encodeURIComponent(address)}/events?${q}`, tonapiHeaders());
+    if (r.status !== 200) fail("tonapi", r);
+    const body = r.body;
+    const events = body?.events ?? [];
+    const items = [];
+    for (const e of events) items.push(await finishTonapi(address, own, e));
+    const page = { items, backend: "tonapi" };
+    if (events.length >= limit) {
+      const last = events[events.length - 1];
+      page.cursor = encodeCursor({ v: 1, b: "tonapi", lt: String(body?.next_from ?? last.lt) });
+    }
+    return page;
+  }
+  async function toncenterPage(address, limit, before) {
+    if (!toncenterUrl) throw new Error("toncenter: disabled");
+    const endLt = before ? (BigInt(before) - 1n).toString() : void 0;
+    const q = `account=${encodeURIComponent(address)}&limit=${limit}&sort=desc${endLt ? `&end_lt=${endLt}` : ""}`;
+    const r = await getJson("toncenter", `${toncenterUrl}/api/v3/transactions?${q}`, toncenterHeaders());
+    if (r.status !== 200) fail("toncenter", r);
+    const rows = r.body?.transactions ?? [];
+    const items = rows.map((row) => mapToncenterTransaction(chain, address, row));
+    const page = { items, backend: "toncenter" };
+    if (rows.length >= limit) page.cursor = encodeCursor({ v: 1, b: "toncenter", lt: rows[rows.length - 1].lt });
+    return page;
+  }
+  const backends = [...tonapiUrl ? ["tonapi"] : [], ...toncenterUrl ? ["toncenter"] : []];
+  return {
+    chain,
+    async listActivity(address, query = {}) {
+      const limit = Math.min(MAX_LIMIT, Math.max(1, Math.floor(query.limit ?? DEFAULT_LIMIT)));
+      const cursor = query.cursor ? decodeCursor(query.cursor) : void 0;
+      const own = rawTonAddress(address);
+      const ordered = cursor ? [...backends].sort((a, b) => a === cursor.b ? -1 : b === cursor.b ? 1 : 0) : backends;
+      const attempts = [];
+      for (const b of ordered) {
+        try {
+          let page = b === "tonapi" ? await tonapiPage(address, own, limit, cursor?.lt) : await toncenterPage(address, limit, cursor?.lt);
+          if (query.since !== void 0) {
+            const since = query.since;
+            if (page.items.some((t) => t.time < since)) delete page.cursor;
+            page = { ...page, items: page.items.filter((t) => t.time >= since) };
+          }
+          return page;
+        } catch (e) {
+          attempts.push(e instanceof Error ? e.message : String(e));
+        }
+      }
+      throw new HistoryUnavailableError(chain, attempts[attempts.length - 1] ?? "no backend configured", attempts);
+    },
+    async getTransaction(hash, address) {
+      const own = rawTonAddress(address);
+      const attempts = [];
+      for (const b of backends) {
+        try {
+          if (b === "tonapi") {
+            const r2 = await getJson("tonapi", `${tonapiUrl}/v2/accounts/${encodeURIComponent(address)}/events/${encodeURIComponent(hash)}`, tonapiHeaders());
+            if (r2.status === 404) return void 0;
+            if (r2.status !== 200) fail("tonapi", r2);
+            return await finishTonapi(address, own, r2.body);
+          }
+          const r = await getJson("toncenter", `${toncenterUrl}/api/v3/transactions?hash=${encodeURIComponent(hash)}`, toncenterHeaders());
+          if (r.status !== 200) fail("toncenter", r);
+          const rows = r.body?.transactions ?? [];
+          const row = rows.find((x) => x.account.toLowerCase() === own) ?? rows[0];
+          return row ? mapToncenterTransaction(chain, address, row) : void 0;
+        } catch (e) {
+          attempts.push(e instanceof Error ? e.message : String(e));
+        }
+      }
+      throw new HistoryUnavailableError(chain, attempts[attempts.length - 1] ?? "no backend configured", attempts);
+    },
+    explorerTxUrl(hash) {
+      return tonExplorerTxUrl(hash, network);
+    }
+  };
+}
+
+// src/index.ts
+installBufferGlobal();
+//# sourceMappingURL=index.cjs.map