crypto-aio 0.0.2 → 0.1.0

package/dist/adapters/ton/builder.js

@@ -0,0 +1,701 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIRST_SEND_MS = exports.CHAIN_TIME_TOLERANCE = exports.REQUEST_ID = void 0;
+exports.createTonBuilder = createTonBuilder;
+exports.createTonBroadcaster = createTonBroadcaster;
+/**
+ * TON transfers: fees, funds, the unsigned external request, its assembly, and the
+ * broadcaster. Builds use `read` tags, except the sender's jetton wallet, which the proof
+ * quorum attests; sending uses `broadcast` / `ambiguous-on-failure` with the caller's
+ * fanout and signal.
+ *
+ * The fund-safety rules this module keeps:
+ * - One output per transfer. The verdict answers `failed` for a partly delivered batch, and
+ *   a failed Operation may be sent again whole, paying twice the outputs that moved; so a
+ *   TON transfer carries exactly one message, and TON offers no `batch-transfer`.
+ * - The built request is decoded again before it is handed out for signing, and must say
+ *   exactly what the intent says: the one message's destination, value and bounce flag, or
+ *   the jetton transfer's jetton wallet, recipient, amount and forward amount; the memo; the
+ *   seqno and lifetime; the wallet (`assertBuilt`).
+ * - An emulation that ran nothing is no estimate: every request this builder makes runs the
+ *   wallet code (deployed, or deployed by its `StateInit`) and sends one message, so a gas
+ *   fee or a forward fee of 0 is never an `expected` draft that `checkFunds` would trust.
+ *   tonlib buys the emulated gas with the balance, so a sender whose balance is below what
+ *   the transfer must at least send is answered `INSUFFICIENT_FUNDS`; any other such
+ *   emulation is a retryable `PROVIDER_INCONSISTENT`.
+ * - A node-suggested fee is bounded by the network's `maxNetworkFee` (the economic ceiling).
+ * - A frozen wallet, or an undeployed one at an allocated seqno past 0, is refused from its
+ *   state before anything is built.
+ */
+const core_1 = require("@ton/core");
+const ton_1 = require("@ton/ton");
+const error_1 = require("../../core/errors/error");
+const asset_1 = require("../../core/model/asset");
+const api_1 = require("./api");
+const errors_1 = require("./errors");
+const fees_1 = require("./fees");
+const messages_1 = require("./messages");
+const network_1 = require("./network");
+Object.defineProperty(exports, "CHAIN_TIME_TOLERANCE", { enumerable: true, get: function () { return network_1.CHAIN_TIME_TOLERANCE; } });
+const proofs_1 = require("./proofs");
+const wallets_1 = require("./wallets");
+const reader_1 = require("./reader");
+/** The id of the one signing request (1 × ed25519 over the signing cell hash). */
+exports.REQUEST_ID = 'wallet';
+/**
+ * How long after `assemble` a first send may skip the replay guard, in milliseconds. A
+ * normal transfer sends milliseconds after `assemble`. A first send that comes later (a
+ * slow store, a paused process) may follow another process's send of the same bytes
+ * through a shared store, and a wallet reset in between would make an unguarded late send
+ * pay twice, so it is guarded like a resend. The bound stays well below any sane
+ * `lifecycle.leaseMs`; a slower first send only costs one guard.
+ */
+exports.FIRST_SEND_MS = 2_000;
+/** Whether a first send `age` ms after `assemble` may skip the guard (never below 0). */
+const soonAfter = (age) => age >= 0 && age < exports.FIRST_SEND_MS;
+const hex = (bytes) => Buffer.from(bytes).toString('hex');
+const inconsistent = (reason) => new error_1.ProviderError('PROVIDER_INCONSISTENT', reason, { retryable: true });
+/**
+ * The funds path's answer when the balance is below what the transfer must at least send
+ * (`required`: a lower bound, before gas), as the engine reports a failed funds check.
+ */
+const insufficient = (required, available) => new error_1.ChainError('INSUFFICIENT_FUNDS', 'insufficient funds for this transfer', {
+    details: { required: required.toString(), available: available.toString() },
+});
+/**
+ * The recipient's bounce flag: the variant is `{ bounceable }` only, and a raw address
+ * without one is bounceable. Any other variant did not come from the TON codec, and the
+ * driver never guesses what it meant.
+ */
+function bounceOf(output) {
+    const variant = output.variant;
+    if (variant === undefined)
+        return true;
+    const keys = Object.keys(variant);
+    const flag = Object.hasOwn(variant, 'bounceable') ? variant.bounceable : undefined;
+    if (keys.length !== 1 || typeof flag !== 'boolean') {
+        throw new error_1.ValidationError('INVALID_INTENT', `a TON recipient's variant holds only its bounce flag`);
+    }
+    return flag;
+}
+/**
+ * The checks every builder method runs before any codec, signing or I/O work:
+ * the wallet identity derives exactly `from`, the intent is one output with a memo that
+ * fits, and the fee is TON's.
+ */
+function planOf(ctx, intent, build) {
+    const identity = (0, wallets_1.resolveIdentity)(build.wallet, ctx.config.globalId);
+    const key = build.keys.find((k) => k.scheme === 'ed25519');
+    if (!key)
+        throw new error_1.ConfigError('CONFIG_INVALID', 'the TON wallet has no ed25519 key');
+    if ((0, wallets_1.walletAddress)(identity, key.publicKey) !== build.from ||
+        intent.from !== build.from) {
+        throw new error_1.ConfigError('CONFIG_INVALID', 'the TON wallet identity does not derive the sending address');
+    }
+    if (intent.outputs.length > 1) {
+        throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', 'a TON transfer carries exactly one output (no batch transfers)');
+    }
+    const [first] = intent.outputs;
+    if (!first)
+        throw new error_1.ValidationError('INVALID_INTENT', 'a TON transfer needs an output');
+    if (intent.memo !== undefined && (0, messages_1.memoBytes)(intent.memo) > messages_1.MAX_MEMO_BYTES) {
+        throw new error_1.ValidationError('INVALID_INTENT', `a TON memo is at most ${messages_1.MAX_MEMO_BYTES} bytes`);
+    }
+    (0, messages_1.sdkAddress)(first.to); // INVALID_ADDRESS unless raw
+    const output = { to: first.to, amount: first.amount, bounce: bounceOf(first) };
+    const asset = intent.asset;
+    let jetton;
+    if (asset !== 'native') {
+        const master = (0, reader_1.jettonMaster)(ctx, asset);
+        jetton = { master, asset: { standard: 'jetton', contract: master } };
+    }
+    const request = (0, fees_1.feeRequest)(intent.fee, jetton !== undefined);
+    const attached = jetton ? (request.attached ?? ctx.config.jettonAttached) : undefined;
+    // The attached value pays the recipient's notification and more: at or below the forward
+    // amount the jetton wallet cannot run the transfer.
+    if (attached !== undefined && attached <= ctx.config.jettonForwardAmount) {
+        throw new error_1.ValidationError('INVALID_INTENT', `'attached' must exceed the network's jetton forward amount`);
+    }
+    return {
+        identity,
+        key,
+        output,
+        ...(jetton ? { jetton } : {}),
+        request,
+        ...(attached !== undefined ? { attached } : {}),
+    };
+}
+/** The allocated seqno (a uint32, never wrapped); a build never runs without one. */
+function seqnoOf(build) {
+    const ordering = build.ordering;
+    if (ordering?.kind !== 'seqno' || ordering.seqno > 0xffffffffn || ordering.seqno < 0n) {
+        throw new error_1.ValidationError('INVALID_INTENT', 'a TON transfer needs its allocated seqno');
+    }
+    return Number(ordering.seqno);
+}
+/**
+ * The fee draft `build` and `checkFunds` are given, read strictly as a stored record:
+ * TON's, and made for this transfer's attached value (none for native coin).
+ */
+function feeOf(fee, plan) {
+    const details = (0, fees_1.tonFeeDetails)(fee.details);
+    if (fee.kind !== 'ton' || details.attached !== plan.attached) {
+        throw new error_1.ValidationError('INVALID_INTENT', 'the fee estimate was not made for this TON transfer');
+    }
+    return details;
+}
+/** The wallet's state; a frozen wallet runs no message, its deploy `StateInit` included. */
+async function walletState(ctx, from) {
+    const state = await ctx.api.account(from, api_1.READ);
+    if (state.status === 'frozen') {
+        throw new error_1.ChainError('TX_REFUSED', 'the wallet account is frozen');
+    }
+    return state;
+}
+/**
+ * An undeployed wallet only runs a request at seqno 0 (its `StateInit`'s). At a later
+ * allocated seqno the state lags, or the wallet was deleted, and its `StateInit` would
+ * restart it at 0: either way nothing is built, and a later read decides.
+ */
+function assertDeployable(state, seqno) {
+    if (state.status === 'uninitialized' && seqno !== 0) {
+        throw inconsistent('the wallet is not deployed at the allocated seqno');
+    }
+}
+/**
+ * The endpoint's chain time, when it is within the tolerance of the local clock: one bad
+ * read must not set a lifetime the core then waits out.
+ */
+function chainTime(ctx, state) {
+    if (Math.abs(state.syncUtime - ctx.clock.now() / 1000) > network_1.CHAIN_TIME_TOLERANCE) {
+        throw inconsistent('the endpoint reports a chain time far from the local clock');
+    }
+    return state.syncUtime;
+}
+/** The one message, and for jettons the sender's jetton wallet it goes to. */
+async function messageOf(ctx, intent, plan, from, queryId) {
+    const { output } = plan;
+    const memo = intent.memo !== undefined ? { memo: intent.memo } : {};
+    if (!plan.jetton || plan.attached === undefined) {
+        return {
+            message: (0, messages_1.nativeMessage)({
+                to: output.to,
+                value: output.amount,
+                bounce: output.bounce,
+                ...memo,
+            }),
+        };
+    }
+    // The jetton wallet is the one the intent's master names for our wallet, as
+    // the proof quorum attests it (cached only so). The verdict's legs carry no master, so
+    // this is what binds a transfer to the intended jetton.
+    const jettonWallet = await (0, reader_1.jettonWalletAddress)(ctx, plan.jetton.master, from, api_1.PROOF);
+    return {
+        jettonWallet,
+        message: (0, messages_1.jettonMessage)({
+            jettonWallet,
+            attached: plan.attached,
+            queryId,
+            amount: output.amount,
+            destination: output.to,
+            responseDestination: from,
+            forwardAmount: ctx.config.jettonForwardAmount,
+            ...memo,
+        }),
+    };
+}
+const malformedConfig = () => new error_1.ProviderError('PROVIDER_UNAVAILABLE', 'malformed message prices in the config', {
+    retryable: true,
+});
+/**
+ * The config's forward fee of `message`: param 25, or 24 when the masterchain is
+ * involved (transaction.cpp prices a message by the source's or the destination's chain).
+ * The cell goes through the capped `cellFromBoc`; an answer that does not parse is the
+ * endpoint's fault, retryable, never a bare SDK error.
+ */
+async function configForwardFee(ctx, from, message) {
+    const masterchain = from.startsWith('-1:') ||
+        (message.info.type === 'internal' && message.info.dest.workChain === -1);
+    const cell = (0, messages_1.cellFromBoc)(await ctx.api.configParam(masterchain ? 24 : 25, api_1.READ));
+    if (!cell)
+        throw malformedConfig();
+    try {
+        const prices = (0, ton_1.configParseMsgPrices)(cell.beginParse());
+        const stored = (0, core_1.beginCell)().store((0, core_1.storeMessageRelaxed)(message)).endCell();
+        const { fees, remaining } = (0, ton_1.computeMessageForwardFees)(prices, stored);
+        return fees + remaining;
+    }
+    catch {
+        throw malformedConfig();
+    }
+}
+/** `gas_prices#dd` and `gas_prices_ext#de` (block.tlb): gas prices without a flat part. */
+const GAS_PRICES_TAGS = new Set([0xdd, 0xde]);
+/**
+ * The least gas fee a wallet run pays, `flat_gas_price` of
+ * config param 21 (basechain) or 20 (masterchain), by the sender's workchain, which prices
+ * the account's own compute phase. It is the price of the first `flat_gas_limit` gas units,
+ * which every run that computes pays in full (transaction.cpp `gas_fee`); never
+ * `flat_gas_limit × flat_gas_price`, a units error about 100 times too high. A config
+ * without the flat part (`gas_prices`, `gas_prices_ext`) gives no floor; one that does not
+ * parse is the endpoint's fault, retryable. One endpoint's answer: the caller holds it to
+ * the ceiling before trusting it.
+ */
+async function configGasFloor(ctx, from) {
+    const malformed = () => new error_1.ProviderError('PROVIDER_UNAVAILABLE', 'malformed gas prices in the config', {
+        retryable: true,
+    });
+    const cell = (0, messages_1.cellFromBoc)(await ctx.api.configParam(from.startsWith('-1:') ? 20 : 21, api_1.READ));
+    if (!cell)
+        throw malformed();
+    try {
+        const slice = cell.beginParse();
+        if (GAS_PRICES_TAGS.has(slice.preloadUint(8)))
+            return 0n;
+        return (0, ton_1.configParseGasLimitsPrices)(slice).flatGasPrice;
+    }
+    catch {
+        throw malformed();
+    }
+}
+/** The external message's body (the wallet request) as a base64 BOC. */
+const bodyOf = (external) => (0, core_1.loadMessage)(external.beginParse()).body.toBoc().toString('base64');
+/**
+ * The recipient binding: the unsigned external message, decoded again, says exactly what
+ * the intent says. It goes to `from`, deploys exactly when asked, carries our wallet's
+ * request at `seqno` until `validUntil`, and sends one message with `SEND_MODE` exactly
+ * (never +128, which sends the whole balance, nor +32), no extra currencies and no
+ * `StateInit`: native coin to the recipient with its value, bounce flag and memo; or a
+ * jetton `transfer` to the attested jetton wallet with the attached value, bounceable, naming
+ * the recipient, the amount, `from` for the excess, no custom payload, the network's forward
+ * amount, the memo and the seqno as query id. Anything else is never handed out for signing
+ * (`INVALID_INTENT`, fixed text).
+ */
+function assertBuilt(ctx, intent, plan, unsigned, expected) {
+    const refuse = () => {
+        throw new error_1.ValidationError('INVALID_INTENT', 'the built TON message does not match the intent');
+    };
+    let external;
+    try {
+        external = (0, core_1.loadMessage)(unsigned.beginParse());
+    }
+    catch {
+        return refuse();
+    }
+    if (external.info.type !== 'external-in' ||
+        external.info.dest.toRawString() !== expected.from ||
+        Boolean(external.init) !== expected.deploy) {
+        refuse();
+    }
+    const request = (0, messages_1.decodeWalletRequest)(external.body);
+    if (request?.auth !== 'external' ||
+        request.seqno !== expected.seqno ||
+        request.validUntil !== expected.validUntil ||
+        request.walletId !== (0, wallets_1.walletIdOf)(plan.identity, plan.key.publicKey) ||
+        request.messages.length !== 1 ||
+        request.modes.length !== 1 ||
+        request.modes[0] !== wallets_1.SEND_MODE) {
+        return refuse();
+    }
+    const message = request.messages[0];
+    const facts = (0, messages_1.messageFacts)(message);
+    if (!facts ||
+        message.info.type !== 'internal' ||
+        (message.info.value.other?.size ?? 0) > 0 ||
+        message.init) {
+        return refuse();
+    }
+    const { output } = plan;
+    if (!plan.jetton) {
+        const memo = intent.memo !== undefined
+            ? (0, messages_1.decodeComment)(facts.body) === intent.memo
+            : facts.body.bits.length === 0 && facts.body.refs.length === 0;
+        if (facts.to !== output.to ||
+            facts.value !== output.amount ||
+            message.info.bounce !== output.bounce ||
+            !memo) {
+            refuse();
+        }
+        return;
+    }
+    const transfer = (0, messages_1.decodeJettonTransfer)(facts.body);
+    if (facts.to !== expected.jettonWallet ||
+        facts.value !== plan.attached ||
+        !message.info.bounce ||
+        transfer?.destination !== output.to ||
+        transfer.amount !== output.amount ||
+        transfer.queryId !== BigInt(expected.seqno) ||
+        transfer.responseDestination !== expected.from ||
+        transfer.customPayload ||
+        transfer.forwardAmount !== ctx.config.jettonForwardAmount ||
+        transfer.comment !== intent.memo) {
+        refuse();
+    }
+}
+function createTonBuilder(ctx) {
+    const { api, config } = ctx;
+    return {
+        async estimateFee(intent, build) {
+            const plan = planOf(ctx, intent, build);
+            const state = await walletState(ctx, build.from);
+            const now = chainTime(ctx, state);
+            const deploy = state.status === 'uninitialized';
+            // The engine allocates the seqno; an estimate outside it (`Blockchain.estimateFee`)
+            // runs at the wallet's live one, read at the state's own block, since the
+            // wallet code refuses any other and the emulation would then run nothing.
+            const seqno = build.ordering !== undefined
+                ? seqnoOf(build)
+                : deploy
+                    ? 0
+                    : Number(await (0, reader_1.walletSeqno)(ctx, build.from, api_1.READ));
+            assertDeployable(state, seqno);
+            const { message } = await messageOf(ctx, intent, plan, build.from, BigInt(seqno));
+            const unsigned = await (0, wallets_1.unsignedRequest)(plan.identity, plan.key.publicKey, {
+                seqno,
+                validUntil: now + config.validForSeconds,
+                messages: [message],
+                deploy: false,
+            });
+            const init = deploy
+                ? (0, wallets_1.walletStateInit)(plan.identity, plan.key.publicKey)
+                : undefined;
+            const emulated = await api.estimateFee({
+                address: build.from,
+                body: bodyOf(unsigned.message),
+                ...(init?.code && init.data
+                    ? {
+                        initCode: init.code.toBoc().toString('base64'),
+                        initData: init.data.toBoc().toString('base64'),
+                    }
+                    : {}),
+            }, api_1.READ);
+            // The forward fee counts once. The emulation's follows the real action list; the
+            // config's formula is its floor, so an endpoint that reports less cannot shrink it.
+            const computed = await configForwardFee(ctx, build.from, message);
+            // The economic ceiling by the sender's workchain. The config's forward fee
+            // comes from one endpoint too, so it is held to the ceiling before anything trusts it:
+            // an inflated param 25 must never turn an empty emulation into a definitive shortfall.
+            const ceiling = build.from.startsWith('-1:')
+                ? config.maxNetworkFee.masterchain
+                : config.maxNetworkFee.basechain;
+            if (computed > ceiling) {
+                throw inconsistent("the endpoint's config prices a forward fee above the policy maximum");
+            }
+            // The wallet runs (deployed, or by its `StateInit`) and sends one
+            // message, so an emulation without gas or without a forward fee ran nothing.
+            if (emulated.gasFee === 0n || emulated.forwardFee === 0n) {
+                // tonlib buys the emulated gas with the balance (`compute_gas_limits`), so
+                // a sender that cannot pay emulates to nothing too. Below what the transfer must at
+                // least pay (the amount, or the jetton attached value, plus the config's forward
+                // fee and the wallet run's flat gas price) that is the answer; otherwise
+                // the endpoint's view lags, or it refused the request (another seqno), and a later
+                // read decides. The gas floor comes from one endpoint too, so it is held to the
+                // ceiling first.
+                const gas = await configGasFloor(ctx, build.from);
+                if (computed + gas > ceiling) {
+                    throw inconsistent("the endpoint's config prices gas above the policy maximum");
+                }
+                const minimum = (plan.attached ?? plan.output.amount) + computed + gas;
+                if (state.balance < minimum)
+                    throw insufficient(minimum, state.balance);
+                throw inconsistent("the endpoint's emulation did not run the transfer");
+            }
+            const details = {
+                importFee: emulated.importFee,
+                gasFee: emulated.gasFee,
+                storageFee: emulated.storageFee,
+                ...(emulated.forwardFee >= computed
+                    ? { forwardFee: emulated.forwardFee, forwardFeeSource: 'emulated' }
+                    : { forwardFee: computed, forwardFeeSource: 'computed' }),
+                deploy,
+                ...(plan.attached !== undefined
+                    ? { attached: plan.attached, forwardAmount: config.jettonForwardAmount }
+                    : {}),
+            };
+            if ((0, fees_1.networkFee)(details) > ceiling) {
+                throw inconsistent('the endpoint suggests a fee above the policy maximum');
+            }
+            return (0, fees_1.tonFeeDraft)({
+                speed: plan.request.speed,
+                details,
+                ...(plan.jetton ? { jettonOutputs: 1 } : {}),
+                payer: build.from,
+            });
+        },
+        async checkFunds(intent, fee, build) {
+            const plan = planOf(ctx, intent, build);
+            const details = feeOf(fee, plan);
+            const charges = (0, fees_1.networkFee)(details) + (details.attached ?? 0n);
+            const available = (await walletState(ctx, build.from)).balance;
+            const required = charges + (plan.jetton ? 0n : plan.output.amount);
+            if (available < required) {
+                return { ok: false, asset: 'native', required, available };
+            }
+            if (plan.jetton) {
+                const wanted = plan.output.amount;
+                const held = await (0, reader_1.jettonBalance)(ctx, plan.jetton.master, build.from, api_1.READ);
+                if (held < wanted) {
+                    return {
+                        ok: false,
+                        asset: plan.jetton.asset,
+                        required: wanted,
+                        available: held,
+                    };
+                }
+            }
+            return { ok: true };
+        },
+        async build(intent, fee, build) {
+            const plan = planOf(ctx, intent, build);
+            const seqno = seqnoOf(build);
+            feeOf(fee, plan);
+            const state = await walletState(ctx, build.from);
+            // The lifetime runs from the endpoint's chain time, bounded by the local clock; the
+            // proof checks expiry against attested chain time, never a node's clock.
+            const now = chainTime(ctx, state);
+            const validUntil = now + config.validForSeconds;
+            // When the message may first run, for the proof's window: the chain time, but
+            // never later than the local clock (an endpoint ahead of it sets only the lifetime).
+            const validFrom = Math.min(now, Math.floor(ctx.clock.now() / 1000));
+            const ordering = {
+                kind: 'seqno',
+                seqno: BigInt(seqno),
+                validUntil,
+                validFrom,
+            };
+            assertDeployable(state, seqno);
+            const deploy = state.status === 'uninitialized';
+            const { message, jettonWallet } = await messageOf(ctx, intent, plan, build.from, BigInt(seqno));
+            const unsigned = await (0, wallets_1.unsignedRequest)(plan.identity, plan.key.publicKey, {
+                seqno,
+                validUntil,
+                messages: [message],
+                deploy,
+            });
+            assertBuilt(ctx, intent, plan, unsigned.message, {
+                from: build.from,
+                deploy,
+                seqno,
+                validUntil,
+                ...(jettonWallet !== undefined ? { jettonWallet } : {}),
+            });
+            const request = {
+                id: exports.REQUEST_ID,
+                scheme: 'ed25519',
+                payload: unsigned.digest,
+                payloadKind: 'message',
+                publicKey: plan.key.publicKey,
+                ...(plan.key.keyRef ? { keyRef: plan.key.keyRef } : {}),
+            };
+            return {
+                payload: {
+                    encoding: 'base64',
+                    data: unsigned.message.toBoc().toString('base64'),
+                },
+                signingRequests: [request],
+                ordering,
+                fee,
+                summary: {
+                    asset: (0, asset_1.assetId)(ctx.chain.id, ctx.network.id, plan.jetton?.asset ?? 'native'),
+                    outputs: [{ to: plan.output.to, amount: plan.output.amount.toString() }],
+                    ...(intent.memo !== undefined ? { memo: intent.memo } : {}),
+                },
+            };
+        },
+        async assemble(unsigned, signatures) {
+            const request = unsigned.signingRequests[0];
+            const signature = signatures.find((s) => s.requestId === request?.id);
+            if (!request || !signature || signature.bytes.length !== 64) {
+                throw new error_1.SigningError('SIGNING_FAILED', 'the wallet signature is missing');
+            }
+            const payload = unsigned.payload.encoding === 'base64'
+                ? (0, messages_1.cellFromBoc)(unsigned.payload.data)
+                : null;
+            if (!payload) {
+                throw new error_1.SigningError('SIGNING_FAILED', 'the unsigned TON payload does not parse');
+            }
+            // The signature goes only where the rest of the request hashes to its digest.
+            const signed = (0, wallets_1.signedRequest)(payload, request.payload, signature.bytes);
+            const validFrom = boundOrdering(unsigned.ordering, signed, request.publicKey, ctx.config.globalId);
+            const id = hex((0, wallets_1.normalizedHash)(signed));
+            // Assembled here and not sent yet, for the replay guard. A repeat keeps the record
+            // as it is, so it never makes sent bytes look unsent.
+            if (!ctx.assembled.has(id)) {
+                const record = {
+                    validFrom,
+                    assembledAt: ctx.clock.now(),
+                    sent: false,
+                };
+                (0, reader_1.keep)(ctx.assembled, id, record, reader_1.ASSEMBLED_MEMO);
+            }
+            return {
+                raw: { encoding: 'base64', data: signed.toBoc().toString('base64') },
+                ref: { id, idKind: 'message-hash', canonical: false },
+            };
+        },
+    };
+}
+/**
+ * The proofs and the replay guard read the Attempt's stored ordering, never the bytes, so
+ * it must be the signed request's own (the Tron and Solana builders bind theirs the same
+ * way): a `seqno` ordering with the request's seqno and `valid_until`, a well-formed
+ * recorded start, and a request whose signature verifies under the signing key and whose
+ * wallet id that key derives into the message's destination. An ordering changed on its
+ * way through a store would otherwise move the proof's window. Returns the recorded
+ * start.
+ */
+function boundOrdering(ordering, signed, publicKey, globalId) {
+    const refuse = () => new error_1.SigningError('SIGNING_FAILED', "the Attempt's ordering does not match the signed TON request");
+    let external;
+    try {
+        external = (0, core_1.loadMessage)(signed.beginParse());
+    }
+    catch {
+        throw refuse();
+    }
+    const slot = ordering;
+    const request = external.info.type === 'external-in' ? (0, messages_1.decodeWalletRequest)(external.body) : null;
+    if (external.info.type !== 'external-in' ||
+        request === null ||
+        slot?.kind !== 'seqno' ||
+        typeof slot.seqno !== 'bigint' ||
+        slot.seqno !== BigInt(request.seqno) ||
+        slot.validUntil !== request.validUntil ||
+        !(0, wallets_1.requestIsOwn)(external.info.dest.toRawString(), external.body, publicKey, globalId)) {
+        throw refuse();
+    }
+    const validFrom = (0, network_1.recordedValidFrom)({ ...slot, validUntil: request.validUntil });
+    if (validFrom === undefined)
+        throw refuse();
+    return validFrom;
+}
+const MALFORMED = Object.freeze({
+    kind: 'rejected',
+    reason: 'malformed message',
+});
+const ALREADY_KNOWN = Object.freeze({ kind: 'already-known' });
+/**
+ * Raw bytes as the broadcaster reads them (through the capped `cellFromBoc`: a bare
+ * broadcast's bytes are anyone's): their TEP-467 hash, and, when their body carries a
+ * wallet request's signed header, what the replay guard needs. Null when they are no
+ * external message.
+ */
+function storedOf(data) {
+    const cell = (0, messages_1.cellFromBoc)(data);
+    if (!cell)
+        return null;
+    try {
+        const external = (0, core_1.loadMessage)(cell.beginParse());
+        if (external.info.type !== 'external-in')
+            return null;
+        const id = hex((0, wallets_1.normalizedHash)(cell));
+        const header = (0, messages_1.requestHeaderOf)(external.body);
+        if (!header)
+            return { id };
+        return {
+            id,
+            message: {
+                wallet: external.info.dest.toRawString(),
+                id,
+                seqno: BigInt(header.seqno),
+                validUntil: header.validUntil,
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The replay guard's answer for stored bytes (`replayVerdict`). One that cannot decide
+ * never sends: its reason is logged by code, and the send fails with a retryable error,
+ * which the engine records as ambiguous (the monitor and the proof go on), never as a
+ * refusal: a non-retryable `TX_REFUSED` would invite a caller's retry with a new seqno.
+ */
+async function guarded(ctx, message) {
+    try {
+        return await (0, proofs_1.replayVerdict)(ctx, message);
+    }
+    catch (error) {
+        ctx.log.warn('stored bytes were not sent again: they may already have run', {
+            code: 'RESEND_WITHHELD',
+        });
+        throw new error_1.ProviderError('PROVIDER_UNAVAILABLE', 'not sent: the replay guard could not rule out an earlier run of this message', { retryable: true, ...((0, error_1.isCryptoAioError)(error) ? { cause: error } : {}) });
+    }
+}
+/** The node's own error text inside a v2 error body (`{ ok: false, error }`), if any. */
+function nodeText(body) {
+    if (typeof body !== 'string')
+        return undefined;
+    try {
+        const parsed = JSON.parse(body);
+        if (parsed !== null && typeof parsed === 'object') {
+            const text = parsed.error;
+            if (typeof text === 'string')
+                return text;
+        }
+    }
+    catch {
+        // Not JSON, or cut by the transport: the body itself is the text.
+    }
+    return body;
+}
+function createTonBroadcaster(ctx) {
+    return {
+        async broadcast(signed, options = {}) {
+            // Bytes that are no external message can never be valid anywhere: `rejected`, from
+            // our own parse, is the only rejection, never a node's text: toncenter's refusals
+            // are unstructured, and a lying endpoint could claim one for bytes it then relays.
+            if (signed.raw.encoding !== 'base64')
+                return MALFORMED;
+            const stored = storedOf(signed.raw.data);
+            if (stored === null)
+                return MALFORMED;
+            const expected = stored.id;
+            // Bytes this driver assembled and never sent cannot have run anywhere, so a first
+            // send goes out at once, within FIRST_SEND_MS of `assemble` (later, another process
+            // sharing the store may have sent them). Every other send of stored bytes (a
+            // resend, a dropped rebroadcast, recovery, a caller's same-key retry, bytes from
+            // another process or a bare broadcast) asks the chain first: already run means
+            // never again. Resending the same bytes is not idempotent on TON: a wallet deleted
+            // and re-deployed from its `StateInit` counts its seqno from 0 again, so a message
+            // that already ran can run, and pay, twice.
+            const record = ctx.assembled.get(expected);
+            const first = record?.sent === false && soonAfter(ctx.clock.now() - record.assembledAt);
+            if (stored.message !== undefined && !first) {
+                const verdict = await guarded(ctx, {
+                    ...stored.message,
+                    ...(record ? { validFrom: record.validFrom } : {}),
+                });
+                if (verdict === 'ours')
+                    return ALREADY_KNOWN;
+            }
+            if (record)
+                record.sent = true;
+            try {
+                const sent = await ctx.api.send(signed.raw.data, {
+                    ...api_1.BROADCAST,
+                    ...(options.fanout !== undefined ? { fanout: options.fanout } : {}),
+                    ...(options.signal ? { signal: options.signal } : {}),
+                });
+                if (sent.hashNorm !== expected) {
+                    ctx.log.warn('the node reports another normalized message hash', {
+                        code: 'MESSAGE_HASH_MISMATCH',
+                    });
+                }
+                return { kind: 'accepted' };
+            }
+            catch (error) {
+                // Only a definitive 4xx answer is classified, and the classifier itself throws a
+                // retryable, ambiguous error for a "not now" answer. A
+                // 429, 408, 5xx (toncenter's refusals), a timeout or any answer after an attempt
+                // that may have been delivered goes back unchanged: the ambiguous path.
+                if ((0, error_1.isCryptoAioError)(error, 'RPC_ERROR') && !error.ambiguous) {
+                    return (0, errors_1.classifyBroadcastError)(nodeText(error.details?.body) ?? error.message);
+                }
+                throw error;
+            }
+        },
+    };
+}
+//# sourceMappingURL=builder.js.map