crypto-aio 0.0.3 → 0.2.0

package/dist/adapters/ton/trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.js","sourceRoot":"","sources":["../../../src/adapters/ton/trace.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The verdict on one of our own Attempts: did the value move? A TON wallet transaction\n * \"succeeds\" even when it moved nothing (send mode +2 skips a message it cannot pay), and\n * a transfer can still bounce, or a jetton move fail, one or two hops later. So an\n * Attempt succeeded only when:\n * - the wallet transaction consumed the request's seqno and ran it to the end;\n * - every message of the signed request is among its outgoing messages (a missing one is a\n *   skip only when the wallet's action phase itself counts that many skipped actions);\n * - no native message came back bounced (a `nofunds` or `negfunds` bounce, a failed action\n *   phase without send mode +16 and a non-bounceable message all leave the value with the\n *   recipient), each delivery's bounce phase agreeing with the flag we signed;\n * - every jetton request reached a jetton wallet as an `internal_transfer` of a positive\n *   amount from our wallet, sent by our jetton wallet and run to the end by the receiving\n *   one (the exact amount is not required: fee-on-transfer tokens exist), and both jetton\n *   wallets are the master's own for the sender and the intended recipient. That last\n *   check needs chain reads, so the verdict returns the `legs` for the caller to confirm\n *   (`confirmLegs` in `reader.ts`); the receiving wallet's own 707 check then holds.\n * A bounce read here is still only the indexer's word, and a lone lying indexer could\n * report one for a transfer that landed: so a bounce verdict returns where the chain\n * records it (`bounce`), for the caller to authenticate from the chain itself\n * (`confirmBounce` in `reader.ts`) before it decides anything.\n * Only a request that consumed its seqno is final: any other run (a failed action phase,\n * or a compute phase that failed before `commit()`) left the same message valid until it\n * expires, so anyone may replay it and move the value; such a run decides nothing\n * (`pending`), and only the seqno or the proven expiry can.\n * Used on the verdict paths only (`observe`, `includedFinal`). Every body read here is\n * bound to the hash the quorum keyed (`messageBody`). A batch is one Attempt: one bounced\n * output fails it, although the other outputs moved. Only the chain's own record of a\n * failure decides `failed`; an answer that contradicts the chain or the signed request (a\n * message missing that the wallet did not skip, a jetton wallet that ran the transfer yet\n * sent nothing from the sender, phases that contradict each other or the chain's own\n * counters) throws a retryable `PROVIDER_INCONSISTENT`, which decides nothing. Every\n * output is checked before any of them decides.\n */\nimport { ProviderError } from '../../core/errors/error';\nimport type { TxFailure } from '../../core/model/transaction';\nimport type { V3Message, V3Trace, V3Transaction } from './api';\nimport { ran, threwAfterCommit } from './decode';\nimport {\n  OP,\n  decodeComment,\n  decodeJettonInternalTransfer,\n  decodeJettonTransfer,\n  decodeWalletRequest,\n  messageBody,\n  messageFacts,\n} from './messages';\nimport { externalHashOf } from './wallets';\n\n/** One jetton transfer: the jetton wallets whose owners must be `from` and `recipient`. */\nexport interface JettonLeg {\n  readonly senderWallet: string;\n  readonly recipientWallet: string;\n  readonly recipient: string;\n}\n\n/** A transaction as the chain names it: its account (raw), logical time and hash (hex). */\nexport interface ChainTxId {\n  readonly account: string;\n  readonly lt: bigint;\n  readonly hash: string;\n}\n\n/** A delivery on a bounce's path: its transaction and the hash of the message it received. */\nexport interface Delivery extends ChainTxId {\n  readonly message: string;\n}\n\n/**\n * Where the chain records a bounce, as the indexer names it: our wallet transaction\n * (`root`), each delivery from its message on to the one that failed (`path`), and what\n * that last one did (`end`): sent the value back (its bounce phase), ran nothing, or ran\n * and moved no jettons. Names only: `confirmBounce` reads each from the chain.\n */\nexport interface BounceEvidence {\n  readonly root: ChainTxId;\n  readonly path: readonly Delivery[];\n  readonly end: 'bounced' | 'unran' | 'unmoved';\n}\n\nexport type Verdict =\n  | { readonly kind: 'success'; readonly legs: readonly JettonLeg[] }\n  | {\n      readonly kind: 'failed';\n      readonly reason: string;\n      /** Absent: the transfer did not happen (`reverted`). */\n      readonly failure?: TxFailure;\n      /** Every `bounced` and `jettonBounced` verdict carries its chain evidence. */\n      readonly bounce?: BounceEvidence;\n    }\n  /**\n   * Not decidable yet: the trace is still being executed or indexed, or the request ran\n   * without consuming its seqno and may still run again until it expires.\n   */\n  | { readonly kind: 'pending' };\n\n/** Fixed reasons: a stored reason never holds an address, an amount or node text. */\nexport const REASONS = Object.freeze({\n  walletFailed: 'the wallet transaction failed',\n  skipped: 'the wallet skipped a message',\n  bounced: 'transfer bounced',\n  jettonBounced: 'jetton transfer bounced',\n  jettonUnverified: 'the jetton wallets are not the master’s',\n});\n\nconst PENDING: Verdict = Object.freeze({ kind: 'pending' });\nconst failed = (reason: string, bounce?: BounceEvidence): Verdict =>\n  Object.freeze({ kind: 'failed', reason, ...(bounce ? { bounce } : {}) });\n\nconst inconsistent = (reason: string) =>\n  new ProviderError('PROVIDER_INCONSISTENT', reason, { retryable: true });\n\n/**\n * wallet_v5.fc: an external request whose send mode lacks +2, refused after `commit()`\n * stored the next seqno with an empty action list. The chain counts that compute phase a\n * success (transaction.cpp: `success = accepted && committed`) and runs the empty list, so\n * the transaction ran; the scripted node records it that way too. An indexer that wrote it\n * as a failed compute phase is still read as W5's refusal.\n */\nconst W5_REFUSED_AFTER_COMMIT = 137;\n\n/** Whether `tx` ran a W5 signed external request (only W5 throws 137 after committing). */\nfunction w5External(tx: V3Transaction): boolean {\n  if (!tx.inMsg || tx.inMsg.source !== null) return false;\n  const body = messageBody(tx.inMsg);\n  return (\n    body !== null &&\n    body.bits.length >= 32 &&\n    body.beginParse().preloadUint(32) === OP.w5SignedExternal\n  );\n}\n\n/**\n * Whether the wallet transaction of an external request `tx` consumed the request's seqno,\n * so that the same message can never run again: it ran (the new seqno stands with the\n * actions, W5's 137 included), or, as a defensive reading of W5 alone, its compute phase is\n * recorded failed with 137. Any other run left the old seqno (transaction.cpp: a\n * failed action phase drops the compute phase's state, and a compute phase that failed\n * before `commit()` never had one): a foreign request signed with the same key, or our\n * own, whose action phase failed does not consume the seqno. Throws the retryable\n * contradiction of `ran`.\n */\nexport function consumesSeqno(tx: V3Transaction): boolean {\n  if (ran(tx)) return true;\n  return (\n    !tx.compute.success &&\n    !tx.compute.skipped &&\n    tx.compute.exitCode === W5_REFUSED_AFTER_COMMIT &&\n    w5External(tx)\n  );\n}\n\n/**\n * Whether `tx` is our Attempt: the external message to `from` whose TEP-467 hash,\n * computed here from the bound body, is the Attempt id. The indexer's `hash_norm` only\n * finds candidates; it never decides.\n */\nexport function isOwnAttempt(tx: V3Transaction, from: string, refId: string): boolean {\n  if (!tx.inMsg || tx.inMsg.source !== null || tx.account !== from) return false;\n  const body = messageBody(tx.inMsg);\n  return body !== null && externalHashOf(tx.account, body) === refId;\n}\n\n/**\n * The transaction in `trace` that received `message`, which `sender` sent. An internal\n * message is delivered once, to its destination, with its value and its bounce flag:\n * anything else contradicts the chain.\n */\nfunction receiver(trace: V3Trace, message: V3Message, sender: string): V3Transaction {\n  const found = trace.transactions.filter((t) => t.inMsg?.hash === message.hash);\n  const [tx] = found;\n  if (!tx) throw inconsistent('a complete trace lacks a delivered message');\n  if (\n    found.length > 1 ||\n    message.source !== sender ||\n    tx.account !== message.destination ||\n    tx.inMsg?.source !== sender ||\n    tx.inMsg.value !== message.value ||\n    (message.bounce !== null &&\n      tx.inMsg.bounce !== null &&\n      tx.inMsg.bounce !== message.bounce)\n  ) {\n    throw inconsistent('the trace delivered a message other than the one sent');\n  }\n  return tx;\n}\n\ninterface Sent {\n  readonly out: V3Message;\n  /** The bounce flag we signed for it: it decides whether a bounce phase may exist. */\n  readonly bounceable: boolean;\n  /** For a jetton request: its intended recipient (the owner). */\n  readonly jettonRecipient?: string;\n}\n\n/** A native transfer as our builder signs it: a positive value, no body or a comment. */\nfunction plainTransfer(facts: NonNullable<ReturnType<typeof messageFacts>>): boolean {\n  const { value, body } = facts;\n  const empty = body.bits.length === 0 && body.refs.length === 0;\n  return value > 0n && (empty || decodeComment(body) !== undefined);\n}\n\n/**\n * The requested messages, matched one to one with the wallet transaction's outgoing\n * messages; or why they did not all go out: the wallet skipped them (send mode +2), or its\n * code threw after committing the seqno. `ran` holds, so the outgoing messages are\n * distinct and as many as the action phase created; the skips must be exactly the missing\n * messages.\n */\nfunction sentMessages(root: V3Transaction): readonly Sent[] | 'skipped' | 'threw' {\n  const body = messageBody(root.inMsg as V3Message);\n  if (!body) throw inconsistent('the indexer has no body for the external message');\n  const request = decodeWalletRequest(body);\n  if (!request || request.auth !== 'external') {\n    throw inconsistent('the indexed external message is not a wallet transfer');\n  }\n  const action = root.action as NonNullable<V3Transaction['action']>;\n  // Committed, then threw (W5 137): the list committed with the seqno was empty.\n  if (threwAfterCommit(root)) {\n    if (action.msgsCreated !== 0 || action.skippedActions !== 0) {\n      throw inconsistent('the wallet threw after committing, yet ran an action');\n    }\n    return 'threw';\n  }\n  const unused = [...root.outMsgs];\n  const matched: Sent[] = [];\n  let missing = 0;\n  for (const requested of request.messages) {\n    const facts = messageFacts(requested);\n    if (!facts)\n      throw inconsistent('the signed request holds a message that is not internal');\n    // Our builder signs only plain transfers of a positive value and TEP-74 transfers; any\n    // other message moves what the verdict cannot see, so it is never judged a success.\n    const jetton = decodeJettonTransfer(facts.body);\n    if (!jetton && !plainTransfer(facts)) {\n      throw inconsistent('the signed request holds a message the verdict cannot judge');\n    }\n    const index = unused.findIndex(\n      (out) =>\n        out.destination === facts.to &&\n        out.value === facts.value &&\n        out.bodyHash === facts.bodyHash,\n    );\n    if (index < 0) {\n      missing += 1;\n      continue;\n    }\n    const out = unused.splice(index, 1)[0] as V3Message;\n    // A message leaves the wallet with the flag we signed.\n    const bounceable = requested.info.type === 'internal' && requested.info.bounce;\n    if (out.bounce !== null && out.bounce !== bounceable) {\n      throw inconsistent('a message went out with another bounce flag than signed');\n    }\n    matched.push({\n      out,\n      bounceable,\n      ...(jetton ? { jettonRecipient: jetton.destination } : {}),\n    });\n  }\n  if (unused.length > 0) {\n    throw inconsistent(\n      'the wallet transaction sent a message the request did not ask for',\n    );\n  }\n  // Send mode +2: the wallet records exactly the messages it skipped. The action phase\n  // counts skipped sends since global version 8 (config param 8), which both networks\n  // run; on an older chain this refuses (retryable), and never decides.\n  if (missing !== action.skippedActions) {\n    throw inconsistent('the wallet counts other skips than the messages it did not send');\n  }\n  return missing > 0 ? 'skipped' : matched;\n}\n\n/**\n * The `internal_transfer` our jetton wallet `hop` sent onwards for our wallet `from`: the\n * message of a positive amount, `null` when it moved nothing.\n */\nfunction onward(hop: V3Transaction, from: string): V3Message | null {\n  let nothingMoved = false;\n  for (const m of hop.outMsgs) {\n    const body = messageBody(m);\n    const internal = body ? decodeJettonInternalTransfer(body) : null;\n    if (!internal || internal.from !== from) continue;\n    // From the sender, a positive amount, never the exact one (fee-on-transfer tokens).\n    if (internal.amount > 0n) return m;\n    nothingMoved = true; // a zero amount: nothing moved, so `failed` is accurate\n  }\n  if (nothingMoved) return null;\n  throw inconsistent('the jetton wallet ran the transfer but sent none from the sender');\n}\n\n/**\n * What one output did: failed (with why, and the deliveries the chain records it in), a\n * jetton leg to confirm, or delivered.\n */\ntype Outcome =\n  | {\n      readonly failed: string;\n      readonly path: readonly Delivery[];\n      readonly end: BounceEvidence['end'];\n    }\n  | { readonly leg: JettonLeg }\n  | { readonly delivered: true };\n\n/** `tx`, which received `message`, as a delivery on a bounce's path. */\nconst delivery = (tx: V3Transaction, message: V3Message): Delivery => ({\n  account: tx.account,\n  lt: tx.lt,\n  hash: tx.hash,\n  message: message.hash,\n});\n\n/** The outcome of the output `sent` of our wallet `from`, checked against the chain. */\nfunction outcomeOf(trace: V3Trace, from: string, sent: Sent): Outcome {\n  const { out, bounceable, jettonRecipient } = sent;\n  const hop = receiver(trace, out, from);\n  const first = delivery(hop, out);\n  const hopRan = ran(hop);\n  // A bounce phase exists only for a bounceable message, and always when its compute\n  // phase failed (collator.cpp, transaction.cpp `bounce_enabled`). A bounce on a message\n  // we signed non-bounceable would fail a delivery that credited the value; a failed\n  // bounceable delivery without one lacks data. The flag we signed decides, even when the\n  // indexer leaves the delivery's own flag out.\n  if (\n    (hop.inMsg?.bounce !== null && hop.inMsg?.bounce !== bounceable) ||\n    (hop.bounce !== undefined && !bounceable) ||\n    (bounceable && !hop.compute.success && hop.bounce === undefined)\n  ) {\n    throw inconsistent('the delivery contradicts the bounce flag we signed');\n  }\n  if (jettonRecipient === undefined) {\n    // The value stays unless the bounce phase sent it back.\n    return hop.bounce === 'ok'\n      ? { failed: REASONS.bounced, path: [first], end: 'bounced' }\n      : { delivered: true };\n  }\n  // The owner's jetton wallet ran `transfer` and sent `internal_transfer` onwards. A\n  // failed phase dropped its state: the jettons never left.\n  if (!hopRan) return { failed: REASONS.jettonBounced, path: [first], end: 'unran' };\n  const arrivalMessage = onward(hop, from);\n  if (!arrivalMessage) {\n    return { failed: REASONS.jettonBounced, path: [first], end: 'unmoved' };\n  }\n  // TEP-74 707: the receiving wallet takes it only from the sender's jetton wallet.\n  const arrival = receiver(trace, arrivalMessage, hop.account);\n  // A failed phase drops the credit: the jettons came back, or never arrived.\n  if (!ran(arrival)) {\n    return {\n      failed: REASONS.jettonBounced,\n      path: [first, delivery(arrival, arrivalMessage)],\n      end: 'unran',\n    };\n  }\n  return {\n    leg: {\n      senderWallet: hop.account,\n      recipientWallet: arrival.account,\n      recipient: jettonRecipient,\n    },\n  };\n}\n\n/** The verdict on the Attempt whose wallet transaction is `root`, within `trace`. */\nexport function attemptVerdict(root: V3Transaction, trace: V3Trace | null): Verdict {\n  if (!root.inMsg || root.inMsg.source !== null) {\n    throw inconsistent('the attempt is not an external message');\n  }\n  if (!consumesSeqno(root)) return PENDING;\n  if (!root.compute.success) return failed(REASONS.walletFailed);\n  const sent = sentMessages(root);\n  if (sent === 'threw') return failed(REASONS.walletFailed);\n  if (sent === 'skipped') return failed(REASONS.skipped);\n  if (!trace || !trace.complete) return PENDING;\n  // Every output is checked before any decides, so an early failure never hides a later\n  // contradiction.\n  const outcomes = sent.map((each) => outcomeOf(trace, root.account, each));\n  for (const outcome of outcomes) {\n    if ('failed' in outcome) {\n      const { account, lt, hash } = root;\n      return failed(\n        outcome.failed,\n        Object.freeze({\n          root: { account, lt, hash },\n          path: outcome.path,\n          end: outcome.end,\n        }),\n      );\n    }\n  }\n  const legs = outcomes.flatMap((outcome) => ('leg' in outcome ? [outcome.leg] : []));\n  return Object.freeze({ kind: 'success', legs });\n}\n"]}

package/dist/adapters/ton/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * SDK-free types of the TON family: the wallet identity, the `ext.ton` API, fee
+ * details and overrides, and the transport tags. Nothing here imports an SDK, so the
+ * composition root can export these types.
+ */
+import type { CallOptions } from '../../core/transport/types';
+declare module '../../index' {
+    interface ChainRegistry {
+        ton: {
+            family: 'ton';
+            network: 'mainnet' | 'testnet';
+        };
+    }
+    interface FamilyRegistry {
+        ton: {
+            library: '@ton/ton';
+            ext: TonExt;
+            fee: TonFeeDetails;
+        };
+    }
+}
+export type TonWalletVersion = 'v4r2' | 'v5r1';
+/**
+ * The wallet contract behind a TON address. Every field determines the address,
+ * so it is wallet config (`wallets.<name>.ton`), never a per-call option.
+ * - v4r2: `subwalletId` defaults to `698983191 + workchain`.
+ * - v5r1: `subwalletNumber` defaults to 0 (15 bits); `networkGlobalId` defaults to the
+ *   network's global id (-239 mainnet, -3 testnet) and must equal it.
+ */
+export type TonWalletIdentity = {
+    readonly version: 'v4r2';
+    readonly workchain?: 0 | -1;
+    readonly subwalletId?: number;
+} | {
+    readonly version: 'v5r1';
+    readonly workchain?: 0 | -1;
+    readonly subwalletNumber?: number;
+    readonly networkGlobalId?: number;
+};
+/** `bc.ext.ton`: the TON family extension. */
+export interface TonExt {
+    readonly ton: {
+        /** The wallet's seqno at the latest masterchain block; 0 while it is not deployed. */
+        getSeqno(address: string): Promise<bigint>;
+        /** The jetton wallet that `owner` holds for the jetton `master` (raw form). */
+        jettonWallet(owner: string, master: string): Promise<string>;
+    };
+}
+/**
+ * `FeeEstimate.details` of the `ton` fee kind, in nanograms. The `network` charge is
+ * `importFee + gasFee + storageFee + forwardFee`; a jetton transfer adds an `attached`
+ * charge (`attached` per output), whose unspent part the jetton wallet refunds.
+ */
+export interface TonFeeDetails {
+    /** The inbound external message's import fee. */
+    readonly importFee: bigint;
+    /** The wallet's compute phase, from the endpoint's emulation. */
+    readonly gasFee: bigint;
+    readonly storageFee: bigint;
+    /** The forward fees of every outgoing internal message (full `fwd_fee`), counted once. */
+    readonly forwardFee: bigint;
+    /**
+     * Where `forwardFee` comes from: the endpoint's emulation (`fwd_fee`, which follows
+     * the real action list), or, when it reports none, config params 24/25.
+     */
+    readonly forwardFeeSource: 'emulated' | 'computed';
+    /** Jetton transfers: the value attached to each jetton wallet message. */
+    readonly attached?: bigint;
+    /** Jetton transfers: `forward_ton_amount`, which pays for the recipient's notification. */
+    readonly forwardAmount?: bigint;
+    /** Whether the message deploys the wallet (its first send carries the `StateInit`). */
+    readonly deploy: boolean;
+}
+/**
+ * An explicit TON fee (`TransferIntent.fee`). TON fees are fixed by the network config, so
+ * there is nothing to bid; a jetton transfer may change the value attached to each jetton
+ * wallet message (default: the network's `jettonAttached`).
+ */
+export interface TonFeeOverride {
+    readonly attached?: bigint;
+}
+/**
+ * The seqno ordering a TON build records: the signed seqno and `valid_until`, and
+ * `validFrom`, the chain time the build ran at (the state's `sync_utime`, and never later
+ * than the local clock), in seconds. The message cannot run in a block older than that, less
+ * the builder's chain-time tolerance, so a proof that it was not included walks the
+ * wallet's history back to there, whatever the network's `validForSeconds` is now. It is a
+ * core `seqno` ordering with one more property, which the core stores whole. A store that
+ * drops `validFrom` costs only liveness (the proof and the replay guard fall back to a
+ * one-day window); one that moves it later could hide a wallet reset and prove "not
+ * included" falsely, and a `rebuild` would then pay twice.
+ */
+export interface TonSeqnoOrdering {
+    readonly kind: 'seqno';
+    readonly seqno: bigint;
+    readonly validUntil: number;
+    readonly validFrom: number;
+}
+/**
+ * The transport tags every TON I/O call carries, as the `ChainDriver` contract table sets
+ * them. A caller's `quorumKey` replaces the call's default consensus key: proofs attest a
+ * monotone predicate, such as "my seqno is above n", instead of comparing data read at a
+ * moving head.
+ */
+export type TonCallTags = Pick<CallOptions, 'purpose' | 'retry' | 'quorum' | 'quorumKey' | 'fanout' | 'signal'>;

package/dist/{type/transact.js → adapters/ton/types.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=transact.js.map
+//# sourceMappingURL=types.js.map

package/dist/adapters/ton/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/adapters/ton/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * SDK-free types of the TON family: the wallet identity, the `ext.ton` API, fee\n * details and overrides, and the transport tags. Nothing here imports an SDK, so the\n * composition root can export these types.\n */\nimport type { CallOptions } from '../../core/transport/types';\n\n// Augment the registries through the package entry, as users do with 'crypto-aio'.\ndeclare module '../../index' {\n  interface ChainRegistry {\n    ton: { family: 'ton'; network: 'mainnet' | 'testnet' };\n  }\n  interface FamilyRegistry {\n    ton: { library: '@ton/ton'; ext: TonExt; fee: TonFeeDetails };\n  }\n}\n\nexport type TonWalletVersion = 'v4r2' | 'v5r1';\n\n/**\n * The wallet contract behind a TON address. Every field determines the address,\n * so it is wallet config (`wallets.<name>.ton`), never a per-call option.\n * - v4r2: `subwalletId` defaults to `698983191 + workchain`.\n * - v5r1: `subwalletNumber` defaults to 0 (15 bits); `networkGlobalId` defaults to the\n *   network's global id (-239 mainnet, -3 testnet) and must equal it.\n */\nexport type TonWalletIdentity =\n  | {\n      readonly version: 'v4r2';\n      readonly workchain?: 0 | -1;\n      readonly subwalletId?: number;\n    }\n  | {\n      readonly version: 'v5r1';\n      readonly workchain?: 0 | -1;\n      readonly subwalletNumber?: number;\n      readonly networkGlobalId?: number;\n    };\n\n/** `bc.ext.ton`: the TON family extension. */\nexport interface TonExt {\n  readonly ton: {\n    /** The wallet's seqno at the latest masterchain block; 0 while it is not deployed. */\n    getSeqno(address: string): Promise<bigint>;\n    /** The jetton wallet that `owner` holds for the jetton `master` (raw form). */\n    jettonWallet(owner: string, master: string): Promise<string>;\n  };\n}\n\n/**\n * `FeeEstimate.details` of the `ton` fee kind, in nanograms. The `network` charge is\n * `importFee + gasFee + storageFee + forwardFee`; a jetton transfer adds an `attached`\n * charge (`attached` per output), whose unspent part the jetton wallet refunds.\n */\nexport interface TonFeeDetails {\n  /** The inbound external message's import fee. */\n  readonly importFee: bigint;\n  /** The wallet's compute phase, from the endpoint's emulation. */\n  readonly gasFee: bigint;\n  readonly storageFee: bigint;\n  /** The forward fees of every outgoing internal message (full `fwd_fee`), counted once. */\n  readonly forwardFee: bigint;\n  /**\n   * Where `forwardFee` comes from: the endpoint's emulation (`fwd_fee`, which follows\n   * the real action list), or, when it reports none, config params 24/25.\n   */\n  readonly forwardFeeSource: 'emulated' | 'computed';\n  /** Jetton transfers: the value attached to each jetton wallet message. */\n  readonly attached?: bigint;\n  /** Jetton transfers: `forward_ton_amount`, which pays for the recipient's notification. */\n  readonly forwardAmount?: bigint;\n  /** Whether the message deploys the wallet (its first send carries the `StateInit`). */\n  readonly deploy: boolean;\n}\n\n/**\n * An explicit TON fee (`TransferIntent.fee`). TON fees are fixed by the network config, so\n * there is nothing to bid; a jetton transfer may change the value attached to each jetton\n * wallet message (default: the network's `jettonAttached`).\n */\nexport interface TonFeeOverride {\n  readonly attached?: bigint;\n}\n\n/**\n * The seqno ordering a TON build records: the signed seqno and `valid_until`, and\n * `validFrom`, the chain time the build ran at (the state's `sync_utime`, and never later\n * than the local clock), in seconds. The message cannot run in a block older than that, less\n * the builder's chain-time tolerance, so a proof that it was not included walks the\n * wallet's history back to there, whatever the network's `validForSeconds` is now. It is a\n * core `seqno` ordering with one more property, which the core stores whole. A store that\n * drops `validFrom` costs only liveness (the proof and the replay guard fall back to a\n * one-day window); one that moves it later could hide a wallet reset and prove \"not\n * included\" falsely, and a `rebuild` would then pay twice.\n */\nexport interface TonSeqnoOrdering {\n  readonly kind: 'seqno';\n  readonly seqno: bigint;\n  readonly validUntil: number;\n  readonly validFrom: number;\n}\n\n/**\n * The transport tags every TON I/O call carries, as the `ChainDriver` contract table sets\n * them. A caller's `quorumKey` replaces the call's default consensus key: proofs attest a\n * monotone predicate, such as \"my seqno is above n\", instead of comparing data read at a\n * moving head.\n */\nexport type TonCallTags = Pick<\n  CallOptions,\n  'purpose' | 'retry' | 'quorum' | 'quorumKey' | 'fanout' | 'signal'\n>;\n"]}

package/dist/adapters/ton/wallets.d.ts

@@ -0,0 +1,86 @@
+/**
+ * TON wallet contracts, over `@ton/core` and `@ton/ton`: the wallet identity,
+ * its address and `StateInit`, the signing message, and the external message around it.
+ * Loaded only through the adapter manifest's `load()`.
+ *
+ * Signing flow: `build` asks the SDK for the transfer body with a zero signature and keeps
+ * the whole unsigned external message (a BOC) as the payload; the one ed25519 request signs
+ * the signing message's cell hash. `assemble` finds the 512 zero bits the signature
+ * replaces (front for v4r2, tail for v5r1) by the one position whose remainder hashes to
+ * the signed digest, so it needs no wallet version and cannot write a signature anywhere
+ * else.
+ */
+import { Cell, type MessageRelaxed, type StateInit } from '@ton/core';
+import type { WalletOptions } from '../../core/driver/types';
+import { type TonWorkchain } from './address';
+import { sdkAddress } from './messages';
+import type { TonWalletVersion } from './types';
+/** Messages one external request may carry: 4 refs per cell (v4r2), 255 (v5r1). */
+export declare const MAX_MESSAGES: Readonly<Record<TonWalletVersion, number>>;
+/** Pay forward fees separately and never fail the action phase (W5 requires +2). */
+export declare const SEND_MODE: number;
+/** The resolved wallet identity: every field that determines the address. */
+export type TonIdentity = {
+    readonly version: 'v4r2';
+    readonly workchain: TonWorkchain;
+    readonly subwalletId: number;
+} | {
+    readonly version: 'v5r1';
+    readonly workchain: TonWorkchain;
+    readonly subwalletNumber: number;
+    readonly networkGlobalId: number;
+};
+/**
+ * `wallets.<name>.ton` validated against the network: a v5r1 wallet id made for
+ * another network is refused before any key is used. Every problem is `CONFIG_INVALID`.
+ */
+export declare function resolveIdentity(wallet: WalletOptions | undefined, globalId: number): TonIdentity;
+/** The wallet's raw address: the hash of its `StateInit` in its workchain. */
+export declare function walletAddress(identity: TonIdentity, publicKey: Uint8Array): string;
+/** The code and data a first message carries to deploy the wallet. */
+export declare function walletStateInit(identity: TonIdentity, publicKey: Uint8Array): StateInit;
+/** The wallet's wire wallet id (v4r2: the subwallet id; v5r1: the signed 32-bit id). */
+export declare function walletIdOf(identity: TonIdentity, publicKey: Uint8Array): number;
+export interface UnsignedRequest {
+    /** The unsigned external message: the wallet body with 512 zero bits for the signature. */
+    readonly message: Cell;
+    /** The signing message's cell hash: what the ed25519 key signs. */
+    readonly digest: Uint8Array;
+}
+/**
+ * The external request for `messages` at `seqno`, valid while chain time is before
+ * `validUntil` (seconds). `init` deploys the wallet with its first message.
+ */
+export declare function unsignedRequest(identity: TonIdentity, publicKey: Uint8Array, args: {
+    readonly seqno: number;
+    readonly validUntil: number;
+    readonly messages: readonly MessageRelaxed[];
+    readonly deploy: boolean;
+}): Promise<UnsignedRequest>;
+/**
+ * The signed external message: `signature` in place of the 512 zero bits whose remainder
+ * hashes to `digest` (the front for v4r2, the tail for v5r1). Refuses (`SIGNING_FAILED`) a
+ * payload with no such position, so a signature can never land anywhere else.
+ */
+export declare function signedRequest(unsigned: Cell, digest: Uint8Array, signature: Uint8Array): Cell;
+/**
+ * TEP-467: the hash of the external-in message with `src` = addr_none, `import_fee` = 0,
+ * no `init`, and the body always as a reference. Stable across relays; the Attempt id.
+ */
+export declare function normalizedHash(externalMessage: Cell): Uint8Array;
+/**
+ * Whether the wallet request `body` (external, or a W5
+ * `internal_signed` request relayed in an internal message) is `from`'s own. Anyone can post
+ * a relayed body, and a lone lying indexer can make up an external one, so a request
+ * proves nothing unless its ed25519 signature verifies over the rest of the request under
+ * `publicKey`, the wallet's key (v4r2: the first 512 bits; v5r1: the last 512), and its
+ * wallet id derives `from` with that key (v4r2: the subwallet id in `from`'s workchain;
+ * v5r1: the signed wallet id). A request of another wallet sharing the key, replayed
+ * here, never counts. For a relayed request the caller also requires the transaction's
+ * compute phase to have succeeded, i.e. the wallet ran it.
+ */
+export declare function requestIsOwn(from: string, body: Cell, publicKey: Uint8Array, globalId: number): boolean;
+/** The SDK's `Address` for a raw address, parsed strictly. */
+export { sdkAddress };
+/** The TEP-467 hash (hex) of the external message `body` to `account` would travel in. */
+export declare function externalHashOf(account: string, body: Cell): string;

package/dist/adapters/ton/wallets.js

@@ -0,0 +1,373 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sdkAddress = exports.SEND_MODE = exports.MAX_MESSAGES = void 0;
+exports.resolveIdentity = resolveIdentity;
+exports.walletAddress = walletAddress;
+exports.walletStateInit = walletStateInit;
+exports.walletIdOf = walletIdOf;
+exports.unsignedRequest = unsignedRequest;
+exports.signedRequest = signedRequest;
+exports.normalizedHash = normalizedHash;
+exports.requestIsOwn = requestIsOwn;
+exports.externalHashOf = externalHashOf;
+/**
+ * TON wallet contracts, over `@ton/core` and `@ton/ton`: the wallet identity,
+ * its address and `StateInit`, the signing message, and the external message around it.
+ * Loaded only through the adapter manifest's `load()`.
+ *
+ * Signing flow: `build` asks the SDK for the transfer body with a zero signature and keeps
+ * the whole unsigned external message (a BOC) as the payload; the one ed25519 request signs
+ * the signing message's cell hash. `assemble` finds the 512 zero bits the signature
+ * replaces (front for v4r2, tail for v5r1) by the one position whose remainder hashes to
+ * the signed digest, so it needs no wallet version and cannot write a signature anywhere
+ * else.
+ */
+const core_1 = require("@ton/core");
+const ed25519_1 = require("@noble/curves/ed25519");
+const ton_1 = require("@ton/ton");
+const error_1 = require("../../core/errors/error");
+const address_1 = require("./address");
+const messages_1 = require("./messages");
+Object.defineProperty(exports, "sdkAddress", { enumerable: true, get: function () { return messages_1.sdkAddress; } });
+/** Messages one external request may carry: 4 refs per cell (v4r2), 255 (v5r1). */
+exports.MAX_MESSAGES = Object.freeze({
+    v4r2: 4,
+    v5r1: 255,
+});
+/** Pay forward fees separately and never fail the action phase (W5 requires +2). */
+exports.SEND_MODE = core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS;
+const V4_KEYS = new Set(['version', 'workchain', 'subwalletId']);
+const V5_KEYS = new Set(['version', 'workchain', 'subwalletNumber', 'networkGlobalId']);
+/**
+ * `wallets.<name>.ton` validated against the network: a v5r1 wallet id made for
+ * another network is refused before any key is used. Every problem is `CONFIG_INVALID`.
+ */
+function resolveIdentity(wallet, globalId) {
+    const fail = (reason) => {
+        throw new error_1.ConfigError('CONFIG_INVALID', `TON wallet: ${reason}`);
+    };
+    const ton = wallet?.ton;
+    if (ton === undefined || ton === null || typeof ton !== 'object') {
+        return fail(`set wallets.<name>.ton = { version: 'v4r2' | 'v5r1' }`);
+    }
+    const config = ton;
+    const version = config.version;
+    if (version !== 'v4r2' && version !== 'v5r1') {
+        return fail(`version must be 'v4r2' or 'v5r1'`);
+    }
+    const allowed = version === 'v4r2' ? V4_KEYS : V5_KEYS;
+    for (const key of Object.keys(config)) {
+        if (config[key] !== undefined && !allowed.has(key)) {
+            // The caller's key is never echoed (it could be a pasted secret).
+            fail(`a ${version} wallet takes only ${[...allowed].join(', ')}`);
+        }
+    }
+    const workchain = config.workchain ?? 0;
+    if (workchain !== 0 && workchain !== -1)
+        fail('workchain must be 0 or -1');
+    const wc = workchain;
+    if (version === 'v4r2') {
+        const subwalletId = config.subwalletId ?? 698983191 + wc;
+        if (!Number.isInteger(subwalletId) ||
+            subwalletId < 0 ||
+            subwalletId > 0xffffffff) {
+            fail('subwalletId must be an integer in [0, 2^32 - 1]');
+        }
+        return { version, workchain: wc, subwalletId: subwalletId };
+    }
+    const subwalletNumber = config.subwalletNumber ?? 0;
+    if (!Number.isInteger(subwalletNumber) ||
+        subwalletNumber < 0 ||
+        subwalletNumber > 0x7fff) {
+        fail('subwalletNumber must be an integer in [0, 32767]');
+    }
+    const networkGlobalId = config.networkGlobalId ?? globalId;
+    if (networkGlobalId !== globalId) {
+        fail(`networkGlobalId is not this network's (${globalId})`);
+    }
+    return {
+        version,
+        workchain: wc,
+        subwalletNumber: subwalletNumber,
+        networkGlobalId: globalId,
+    };
+}
+/** A strict (RFC 8032) encoding of a point that is not of small order. */
+function canonicalKey(publicKey) {
+    try {
+        return !ed25519_1.ed25519.Point.fromHex(publicKey, false).isSmallOrder();
+    }
+    catch {
+        return false;
+    }
+}
+const isInt = (value, min, max) => Number.isInteger(value) && value >= min && value <= max;
+/**
+ * Every identity field fits the wire field the SDK writes it into (workchain
+ * int8, subwallet id uint32, subwallet number uint15, network id int32), so an identity
+ * not made by `resolveIdentity` is refused rather than wrapped or thrown as a bare `Error`.
+ */
+function identityFits(identity) {
+    if (identity.workchain !== 0 && identity.workchain !== -1)
+        return false;
+    if (identity.version === 'v4r2')
+        return isInt(identity.subwalletId, 0, 0xffffffff);
+    return (identity.version === 'v5r1' &&
+        isInt(identity.subwalletNumber, 0, 0x7fff) &&
+        isInt(identity.networkGlobalId, -0x80000000, 0x7fffffff));
+}
+function contractOf(identity, publicKey) {
+    if (!identityFits(identity)) {
+        throw new error_1.ConfigError('CONFIG_INVALID', 'the TON wallet identity is out of range');
+    }
+    if (publicKey.length !== 32 || !canonicalKey(publicKey)) {
+        throw new error_1.ConfigError('CONFIG_INVALID', 'a TON wallet key must be a canonical 32-byte ed25519 public key');
+    }
+    const key = Buffer.from(publicKey);
+    if (identity.version === 'v4r2') {
+        return ton_1.WalletContractV4.create({
+            workchain: identity.workchain,
+            publicKey: key,
+            walletId: identity.subwalletId,
+        });
+    }
+    // Every field explicit: the SDK's defaults are mainnet's id and workchain 0.
+    return ton_1.WalletContractV5R1.create({
+        publicKey: key,
+        walletId: {
+            networkGlobalId: identity.networkGlobalId,
+            context: {
+                workchain: identity.workchain,
+                walletVersion: 'v5r1',
+                subwalletNumber: identity.subwalletNumber,
+            },
+        },
+    });
+}
+/** The wallet's raw address: the hash of its `StateInit` in its workchain. */
+function walletAddress(identity, publicKey) {
+    const contract = contractOf(identity, publicKey);
+    return (0, address_1.rawAddress)(identity.workchain, contract.address.hash);
+}
+/** The code and data a first message carries to deploy the wallet. */
+function walletStateInit(identity, publicKey) {
+    const { init } = contractOf(identity, publicKey);
+    return { code: init.code, data: init.data };
+}
+/** The wallet's wire wallet id (v4r2: the subwallet id; v5r1: the signed 32-bit id). */
+function walletIdOf(identity, publicKey) {
+    const contract = contractOf(identity, publicKey);
+    if (contract instanceof ton_1.WalletContractV4)
+        return contract.walletId;
+    // v5r1 data: is_signature_allowed:1 seqno:32 wallet_id:int32 public_key:256 extensions.
+    const data = contract.init.data.beginParse();
+    data.skip(1 + 32);
+    return data.loadInt(32);
+}
+/**
+ * The external request for `messages` at `seqno`, valid while chain time is before
+ * `validUntil` (seconds). `init` deploys the wallet with its first message.
+ */
+async function unsignedRequest(identity, publicKey, args) {
+    // The seqno is a uint32 on the wire, never wrapped.
+    if (!Number.isSafeInteger(args.seqno) || args.seqno < 0 || args.seqno > 0xffffffff) {
+        throw new error_1.ValidationError('INVALID_INTENT', 'seqno must be a uint32');
+    }
+    // The SDK falls back to the wall clock for a falsy timeout; never let it.
+    if (!Number.isSafeInteger(args.validUntil) ||
+        args.validUntil <= 0 ||
+        args.validUntil > 0xffffffff) {
+        throw new error_1.ValidationError('INVALID_INTENT', 'validUntil must be a uint32 above 0');
+    }
+    if (args.messages.length === 0 ||
+        args.messages.length > exports.MAX_MESSAGES[identity.version]) {
+        throw new error_1.ValidationError('INVALID_INTENT', `a ${identity.version} request carries 1 to ${exports.MAX_MESSAGES[identity.version]} messages`);
+    }
+    const contract = contractOf(identity, publicKey);
+    let signing;
+    const transfer = {
+        seqno: args.seqno,
+        timeout: args.validUntil,
+        sendMode: exports.SEND_MODE,
+        messages: [...args.messages],
+        signer: async (cell) => {
+            signing = cell;
+            return Buffer.alloc(64);
+        },
+    };
+    let message;
+    try {
+        const body = await (contract instanceof ton_1.WalletContractV4
+            ? contract.createTransfer(transfer)
+            : contract.createTransfer(transfer));
+        message = (0, core_1.beginCell)()
+            .store((0, core_1.storeMessage)((0, core_1.external)({
+            to: contract.address,
+            body,
+            ...(args.deploy
+                ? { init: { code: contract.init.code, data: contract.init.data } }
+                : {}),
+        })))
+            .endCell();
+    }
+    catch {
+        // The SDK throws bare errors that may name a value; `nativeMessage` and
+        // `jettonMessage` range-check theirs, so only a hand-built message ends here.
+        throw new error_1.ValidationError('INVALID_INTENT', 'the TON request cannot be encoded');
+    }
+    if (!signing) {
+        throw new error_1.SigningError('SIGNING_FAILED', 'the SDK did not produce a signing message');
+    }
+    return { message, digest: new Uint8Array(signing.hash()) };
+}
+/** The message in `cell`, or undefined when it holds none (the SDK throws a bare `Error`). */
+function messageOf(cell) {
+    try {
+        return (0, core_1.loadMessage)(cell.beginParse());
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A cell of `bits` then `refs`. */
+function cellOf(parts, refs) {
+    const builder = (0, core_1.beginCell)();
+    for (const part of parts) {
+        if (Buffer.isBuffer(part))
+            builder.storeBuffer(part);
+        else
+            builder.storeBits(part);
+    }
+    for (const ref of refs)
+        builder.storeRef(ref);
+    return builder.endCell();
+}
+const ZERO_SIGNATURE = Buffer.alloc(64);
+/**
+ * The signed external message: `signature` in place of the 512 zero bits whose remainder
+ * hashes to `digest` (the front for v4r2, the tail for v5r1). Refuses (`SIGNING_FAILED`) a
+ * payload with no such position, so a signature can never land anywhere else.
+ */
+function signedRequest(unsigned, digest, signature) {
+    if (signature.length !== 64) {
+        throw new error_1.SigningError('SIGNING_FAILED', 'a TON signature is 64 bytes');
+    }
+    const message = messageOf(unsigned);
+    if (message?.info.type !== 'external-in') {
+        throw new error_1.SigningError('SIGNING_FAILED', 'the unsigned TON payload is not an external message');
+    }
+    const { body } = message;
+    const length = body.bits.length;
+    const expected = Buffer.from(digest);
+    const zero = cellOf([ZERO_SIGNATURE], []).bits;
+    const sig = Buffer.from(signature);
+    let signedBody;
+    if (length >= 512) {
+        const front = body.bits.substring(0, 512);
+        const afterFront = body.bits.substring(512, length - 512);
+        const tail = body.bits.substring(length - 512, 512);
+        const beforeTail = body.bits.substring(0, length - 512);
+        if (front.equals(zero) && cellOf([afterFront], body.refs).hash().equals(expected)) {
+            signedBody = cellOf([sig, afterFront], body.refs);
+        }
+        else if (tail.equals(zero) &&
+            cellOf([beforeTail], body.refs).hash().equals(expected)) {
+            signedBody = cellOf([beforeTail, sig], body.refs);
+        }
+    }
+    if (!signedBody) {
+        throw new error_1.SigningError('SIGNING_FAILED', 'the unsigned TON payload does not match its signing request');
+    }
+    return (0, core_1.beginCell)()
+        .store((0, core_1.storeMessage)({
+        info: message.info,
+        ...(message.init ? { init: message.init } : {}),
+        body: signedBody,
+    }))
+        .endCell();
+}
+/**
+ * TEP-467: the hash of the external-in message with `src` = addr_none, `import_fee` = 0,
+ * no `init`, and the body always as a reference. Stable across relays; the Attempt id.
+ */
+function normalizedHash(externalMessage) {
+    const message = messageOf(externalMessage);
+    if (message?.info.type !== 'external-in') {
+        throw new error_1.ValidationError('INVALID_INTENT', 'not an external-in message');
+    }
+    const normalized = (0, core_1.beginCell)()
+        .storeUint(2, 2)
+        .storeUint(0, 2)
+        .storeAddress(message.info.dest)
+        .storeCoins(0)
+        .storeBit(false)
+        .storeBit(true)
+        .storeRef(message.body)
+        .endCell();
+    return new Uint8Array(normalized.hash());
+}
+/**
+ * Whether the wallet request `body` (external, or a W5
+ * `internal_signed` request relayed in an internal message) is `from`'s own. Anyone can post
+ * a relayed body, and a lone lying indexer can make up an external one, so a request
+ * proves nothing unless its ed25519 signature verifies over the rest of the request under
+ * `publicKey`, the wallet's key (v4r2: the first 512 bits; v5r1: the last 512), and its
+ * wallet id derives `from` with that key (v4r2: the subwallet id in `from`'s workchain;
+ * v5r1: the signed wallet id). A request of another wallet sharing the key, replayed
+ * here, never counts. For a relayed request the caller also requires the transaction's
+ * compute phase to have succeeded, i.e. the wallet ran it.
+ */
+function requestIsOwn(from, body, publicKey, globalId) {
+    try {
+        const length = body.bits.length;
+        if (length < 512 + 32 || publicKey.length !== 32)
+            return false;
+        const op = body.beginParse().preloadUint(32);
+        const v5 = op === messages_1.OP.w5SignedExternal || op === messages_1.OP.w5SignedInternal;
+        const [signed, rest] = v5
+            ? [body.bits.substring(length - 512, 512), body.bits.substring(0, length - 512)]
+            : [body.bits.substring(0, 512), body.bits.substring(512, length - 512)];
+        const signing = cellOf([rest], body.refs);
+        const signature = cellOf([signed], []).beginParse().loadBuffer(64);
+        if (!ed25519_1.ed25519.verify(signature, signing.hash(), publicKey))
+            return false;
+        const identity = v5
+            ? v5IdentityOf(signing.beginParse().skip(32).loadInt(32), globalId)
+            : v4IdentityOf(from, signing.beginParse().loadUint(32));
+        return identity !== undefined && walletAddress(identity, publicKey) === from;
+    }
+    catch {
+        return false;
+    }
+}
+/** The v4r2 identity a request's subwallet id names in `from`'s workchain. */
+function v4IdentityOf(from, subwalletId) {
+    const workchain = Number(from.split(':')[0]);
+    if (workchain !== 0 && workchain !== -1)
+        return undefined;
+    return { version: 'v4r2', workchain, subwalletId };
+}
+/** The v5r1 identity a signed wallet id names: 1 bit set, workchain int8, version 0, uint15. */
+function v5IdentityOf(walletId, globalId) {
+    const context = (walletId ^ globalId) | 0;
+    if (context >>> 31 !== 1 || ((context >> 15) & 0xff) !== 0)
+        return undefined;
+    const byte = (context >> 23) & 0xff;
+    const workchain = byte >= 128 ? byte - 256 : byte;
+    if (workchain !== 0 && workchain !== -1)
+        return undefined;
+    return {
+        version: 'v5r1',
+        workchain,
+        subwalletNumber: context & 0x7fff,
+        networkGlobalId: globalId,
+    };
+}
+/** The TEP-467 hash (hex) of the external message `body` to `account` would travel in. */
+function externalHashOf(account, body) {
+    const message = (0, core_1.beginCell)()
+        .store((0, core_1.storeMessage)((0, core_1.external)({ to: (0, messages_1.sdkAddress)(account), body })))
+        .endCell();
+    return Buffer.from(normalizedHash(message)).toString('hex');
+}
+//# sourceMappingURL=wallets.js.map