@getomnichain/omnichain 0.6.2 → 0.7.0

package/dist/cjs/ton/ton_messages.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TON_W5_SIGNED_EXTERNAL_OP = exports.TON_W5_SIGNED_INTERNAL_OP = exports.TON_JETTON_INTERNAL_TRANSFER_OP = exports.TON_JETTON_TRANSFER_OP = exports.TON_COMMENT_OP = exports.TON_DEFAULT_SEND_MODE = exports.TON_MAX_MESSAGES_PER_REQUEST = exports.TonSignedMessage = void 0;
+exports.tonMessageHash = tonMessageHash;
+exports.tonOutAction = tonOutAction;
+exports.tonOutActions = tonOutActions;
+exports.tonCommentBody = tonCommentBody;
+exports.tonJettonTransferBody = tonJettonTransferBody;
+exports.tonW5RequestFields = tonW5RequestFields;
+exports.tonWalletRequestFields = tonWalletRequestFields;
+exports.tonInternalRequestOf = tonInternalRequestOf;
+exports.tonRelayMessage = tonRelayMessage;
+exports.tonNormalizedExternalHash = tonNormalizedExternalHash;
+exports.parseTonAddress = parseTonAddress;
+const core_1 = require("@ton/core");
+const node_crypto_1 = require("node:crypto");
+const errors_ts_1 = require("../errors.js");
+const wallet_base_ts_1 = require("../wallet.base.js");
+const TON_MESSAGE_PREFIX = 'TON Signed Message:\n';
+/**
+ * What `signMessage` signs: SHA-256 of a fixed prefix and the message's UTF-8
+ * bytes, as Stellar's SEP-53 does. The same key authorizes W5 requests by
+ * signing a 32-byte cell hash, so signing a message's bytes directly would let
+ * a crafted 32-byte message stand in for a request; a prefixed digest cannot
+ * equal a cell hash without a SHA-256 preimage.
+ */
+function tonMessageHash(message) {
+    return (0, node_crypto_1.createHash)('sha256').update(TON_MESSAGE_PREFIX, 'utf8').update(message, 'utf8').digest();
+}
+class TonSignedMessage extends wallet_base_ts_1.AbstractSignedMessage {
+    constructor(signature) {
+        super(signature);
+    }
+}
+exports.TonSignedMessage = TonSignedMessage;
+/** W5's limit on outgoing messages per request. */
+exports.TON_MAX_MESSAGES_PER_REQUEST = 255;
+/** The send mode a message gets unless it names one: the wallet pays forward fees on top of `value`. */
+exports.TON_DEFAULT_SEND_MODE = core_1.SendMode.PAY_GAS_SEPARATELY;
+exports.TON_COMMENT_OP = 0;
+exports.TON_JETTON_TRANSFER_OP = 0x0f8a7ea5;
+exports.TON_JETTON_INTERNAL_TRANSFER_OP = 0x178d4519;
+function tonOutAction(message) {
+    if (message.value < 0n) {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `TON message value must be >= 0, got ${message.value}`);
+    }
+    return {
+        type: 'sendMsg',
+        mode: message.mode ?? exports.TON_DEFAULT_SEND_MODE,
+        outMsg: (0, core_1.internal)({
+            to: parseTonAddress(message.to),
+            value: message.value,
+            bounce: message.bounce ?? message.body !== undefined,
+            body: message.body,
+            init: message.stateInit,
+        }),
+    };
+}
+function tonOutActions(messages) {
+    if (messages.length === 0 || messages.length > exports.TON_MAX_MESSAGES_PER_REQUEST) {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidArgument, `A TON request carries 1 to ${exports.TON_MAX_MESSAGES_PER_REQUEST} messages, got ${messages.length}`);
+    }
+    return messages.map(tonOutAction);
+}
+/** A text comment body (op 0), the form wallets show as a memo. */
+function tonCommentBody(text) {
+    return (0, core_1.beginCell)().storeUint(exports.TON_COMMENT_OP, 32).storeStringTail(text).endCell();
+}
+/** The TEP-74 `transfer` body, sent to the sender's own jetton wallet. */
+function tonJettonTransferBody(args) {
+    const builder = (0, core_1.beginCell)()
+        .storeUint(exports.TON_JETTON_TRANSFER_OP, 32)
+        .storeUint(args.queryId ?? 0n, 64)
+        .storeCoins(args.amount)
+        .storeAddress(parseTonAddress(args.destination))
+        .storeAddress(parseTonAddress(args.responseDestination))
+        .storeBit(false)
+        .storeCoins(args.forwardTonAmount ?? 0n);
+    return args.forwardPayload === undefined
+        ? builder.storeBit(false).endCell()
+        : builder.storeBit(true).storeRef(args.forwardPayload).endCell();
+}
+exports.TON_W5_SIGNED_INTERNAL_OP = 0x73696e74;
+exports.TON_W5_SIGNED_EXTERNAL_OP = 0x7369676e;
+/**
+ * The fields of a signed W5R1 request body: op, wallet id, `valid_until` and
+ * seqno lead the body, the signature trails it. Throws `TransactionDecodeFailed`
+ * for anything that is not one.
+ */
+function tonW5RequestFields(body) {
+    try {
+        const slice = body.beginParse();
+        const op = slice.loadUint(32);
+        if (op !== exports.TON_W5_SIGNED_EXTERNAL_OP && op !== exports.TON_W5_SIGNED_INTERNAL_OP)
+            throw new Error(`op 0x${op.toString(16)}`);
+        return {
+            authType: op === exports.TON_W5_SIGNED_EXTERNAL_OP ? 'external' : 'internal',
+            walletId: slice.loadInt(32),
+            validUntil: slice.loadUint(32),
+            seqno: slice.loadUint(32),
+        };
+    }
+    catch (err) {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, `Not a signed W5 request: ${err.message}`, undefined, err);
+    }
+}
+const ED25519_SIGNATURE_BITS = 512;
+/**
+ * The fields of any signed wallet request body the SDK builds. A v3r2 / v4r2
+ * body is the signature, then wallet id, valid_until and seqno, every field
+ * whole bytes; a W5 body leads with its op and is never byte-aligned (its
+ * action-list flags are two bits). Throws `TransactionDecodeFailed` for
+ * anything else.
+ */
+function tonWalletRequestFields(body) {
+    if (body.bits.length % 8 !== 0)
+        return { layout: 'w5', ...tonW5RequestFields(body) };
+    try {
+        const slice = body.beginParse();
+        slice.skip(ED25519_SIGNATURE_BITS);
+        return { layout: 'legacy', walletId: slice.loadUint(32), validUntil: slice.loadUint(32), seqno: slice.loadUint(32) };
+    }
+    catch (err) {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, `Not a signed wallet request: ${err.message}`, undefined, err);
+    }
+}
+/** A signed internal request read back from its body, e.g. one found in a trace. */
+function tonInternalRequestOf(body) {
+    const fields = tonW5RequestFields(body);
+    if (fields.authType !== 'internal') {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.TransactionDecodeFailed, 'Not a signed W5 internal request: it is an external one');
+    }
+    return { body, seqno: fields.seqno, validUntil: fields.validUntil };
+}
+/**
+ * The message a relayer sends to deliver a wallet's signed internal request.
+ *
+ * Bounceable, so a request that fails in the wallet returns the value. A
+ * request the wallet does not accept (a bad signature, a stale seqno) is
+ * dropped without a bounce and the wallet keeps the value; the transaction
+ * status reports that as `request_not_executed`.
+ */
+function tonRelayMessage(args) {
+    if (args.wallet.version !== undefined && args.wallet.version !== 'v5r1') {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.FeatureNotSupported, `Only W5 (v5r1) wallets take relayed requests; ${args.wallet.address} is ${args.wallet.version}`);
+    }
+    return {
+        to: args.wallet.address,
+        value: args.value,
+        body: args.request.body,
+        bounce: true,
+        stateInit: args.deploy ? args.wallet.stateInit : undefined,
+    };
+}
+/**
+ * The normalized hash of an external message (TEP-467): source, import fee and
+ * StateInit dropped, body stored as a reference. It is what both TON Center and
+ * TonAPI index the external message under, and is used as the transaction id.
+ */
+function tonNormalizedExternalHash(destination, body) {
+    const normalized = (0, core_1.beginCell)()
+        .store((0, core_1.storeMessage)({ info: { type: 'external-in', src: null, dest: parseTonAddress(destination), importFee: 0n }, body }, { forceRef: true }))
+        .endCell();
+    return normalized.hash().toString('hex');
+}
+function parseTonAddress(address) {
+    try {
+        return core_1.Address.parse(address);
+    }
+    catch (err) {
+        throw new errors_ts_1.ChainError(errors_ts_1.ChainErrorKinds.InvalidAddress, `Invalid TON address: ${address}`, { address }, err);
+    }
+}
+//# sourceMappingURL=ton_messages.js.map

package/dist/cjs/ton/ton_messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ton_messages.js","sourceRoot":"","sources":["../../../ton/ton_messages.ts"],"names":[],"mappings":"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"}

package/dist/cjs/ton/ton_provider.js

@@ -0,0 +1,456 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonFallbackProvider = exports.TonBroadcastUncertainError = exports.TonProviderError = void 0;
+exports.tonHttpJson = tonHttpJson;
+exports.tonBroadcastReply = tonBroadcastReply;
+exports.errorMessageOf = errorMessageOf;
+exports.asRecord = asRecord;
+exports.asBigInt = asBigInt;
+exports.asRequiredInteger = asRequiredInteger;
+exports.asRequiredRecord = asRequiredRecord;
+exports.stackCellOf = stackCellOf;
+exports.jettonWalletDataOf = jettonWalletDataOf;
+exports.asRequiredBoolean = asRequiredBoolean;
+exports.tonTransactionOutcome = tonTransactionOutcome;
+exports.asStatedAccountStatus = asStatedAccountStatus;
+exports.asAccountStatus = asAccountStatus;
+exports.tonTraceMessageOf = tonTraceMessageOf;
+exports.assertTraceConsistent = assertTraceConsistent;
+exports.assertTraceOf = assertTraceOf;
+exports.assertTonTxHash = assertTonTxHash;
+exports.definiteError = definiteError;
+const core_1 = require("@ton/core");
+const errors_ts_1 = require("../errors.js");
+const ton_messages_ts_1 = require("./ton_messages.js");
+/**
+ * A provider failure. `retryable` is true only for failures that say nothing
+ * about the answer (transport, timeout, 429, 5xx); the fallback retries those
+ * and nothing else.
+ */
+class TonProviderError extends errors_ts_1.ChainError {
+    retryable;
+    constructor(kind, message, retryable, meta, cause) {
+        super(kind, message, meta, cause);
+        this.name = 'TonProviderError';
+        this.retryable = retryable;
+    }
+}
+exports.TonProviderError = TonProviderError;
+/**
+ * A broadcast whose outcome is unknown: a provider failed without an answer,
+ * so the message may have reached the network even if another provider then
+ * refused it (a refusal can mean it was already accepted). Read the status of
+ * `meta.txHash`, or wait until the request is expired, before signing again.
+ */
+class TonBroadcastUncertainError extends TonProviderError {
+    constructor(message, meta, cause) {
+        super(errors_ts_1.ChainErrorKinds.BroadcastUncertain, message, false, meta, cause);
+        this.name = 'TonBroadcastUncertainError';
+    }
+}
+exports.TonBroadcastUncertainError = TonBroadcastUncertainError;
+/**
+ * TON Center v3 first; TonAPI only when TON Center fails without an answer.
+ *
+ * A definite answer from the primary (not found, a refused emulation, a
+ * refused broadcast) is final. A broadcast retried on the fallback sends the
+ * same BOC: the wallet's seqno makes a second landing impossible.
+ */
+class TonFallbackProvider {
+    primary;
+    fallback;
+    onFallback;
+    name;
+    constructor(primary, fallback, onFallback = () => { }) {
+        this.primary = primary;
+        this.fallback = fallback;
+        this.onFallback = onFallback;
+        this.name = fallback === null ? primary.name : `${primary.name}+${fallback.name}`;
+    }
+    getAccountState(address) {
+        return this.call('getAccountState', (p) => p.getAccountState(address));
+    }
+    getSeqno(address) {
+        return this.call('getSeqno', (p) => p.getSeqno(address));
+    }
+    getJettonWalletAddress(jettonMaster, owner) {
+        return this.call('getJettonWalletAddress', (p) => p.getJettonWalletAddress(jettonMaster, owner));
+    }
+    getJettonBalance(jettonWallet) {
+        return this.call('getJettonBalance', (p) => p.getJettonBalance(jettonWallet));
+    }
+    getJettonContent(jettonMaster) {
+        return this.call('getJettonContent', (p) => p.getJettonContent(jettonMaster));
+    }
+    getJettonWalletData(jettonWallet) {
+        return this.call('getJettonWalletData', (p) => p.getJettonWalletData(jettonWallet));
+    }
+    /**
+     * A refusal is definite only when no provider failed before it: once one
+     * failed without an answer, the message may already be in flight, and a
+     * later refusal may be the network rejecting a duplicate.
+     */
+    async sendBoc(boc) {
+        try {
+            await this.primary.sendBoc(boc);
+            return;
+        }
+        catch (err) {
+            if (!(err instanceof TonProviderError) || !err.retryable)
+                throw err;
+            if (this.fallback === null)
+                throw new TonBroadcastUncertainError(`broadcast outcome unknown: ${err.message}`, undefined, err);
+            this.onFallback('sendBoc', err);
+            try {
+                await this.fallback.sendBoc(boc);
+            }
+            catch (fallbackErr) {
+                throw new TonBroadcastUncertainError(`broadcast outcome unknown: ${err.message}; then ${fallbackErr.message}`, undefined, fallbackErr);
+            }
+        }
+    }
+    getTrace(hash) {
+        return this.call('getTrace', (p) => p.getTrace(hash));
+    }
+    emulate(boc) {
+        return this.call('emulate', (p) => p.emulate(boc));
+    }
+    getMasterchainHead() {
+        return this.call('getMasterchainHead', (p) => p.getMasterchainHead());
+    }
+    /**
+     * Runs several reads on one provider throughout: the primary, or — when any
+     * of them fails without an answer — all of them again on the fallback. Reads
+     * that must see the chain at one point never mix providers that lag
+     * differently.
+     */
+    onOneProvider(method, run) {
+        return this.call(method, run);
+    }
+    async call(method, run) {
+        try {
+            return await run(this.primary);
+        }
+        catch (err) {
+            if (this.fallback === null || !(err instanceof TonProviderError) || !err.retryable)
+                throw err;
+            this.onFallback(method, err);
+            return run(this.fallback);
+        }
+    }
+}
+exports.TonFallbackProvider = TonFallbackProvider;
+const DEFAULT_TIMEOUT_MS = 10_000;
+/** Enough of an error reply to keep the lite server's exit code, which follows a long preamble. */
+const ERROR_TEXT_LIMIT = 1_000;
+/** One JSON request; maps every failure to a {@link TonProviderError}. Returns `null` on a 404. */
+async function tonHttpJson(provider, endpoint, path, init) {
+    const url = `${endpoint.url.replace(/\/$/, '')}${path}`;
+    let response;
+    try {
+        response = await fetch(url, {
+            method: init.method ?? 'GET',
+            headers: { accept: 'application/json', ...(init.body === undefined ? {} : { 'content-type': 'application/json' }), ...init.headers },
+            body: init.body === undefined ? undefined : JSON.stringify(init.body),
+            signal: AbortSignal.timeout(endpoint.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+            redirect: 'error',
+        });
+    }
+    catch (err) {
+        throw new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `${provider} ${path} request failed: ${err.message}`, true, undefined, err);
+    }
+    const text = await response.text();
+    if (response.status === 404)
+        return null;
+    if (response.status === 429 || response.status >= 500) {
+        throw new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `${provider} ${path} answered HTTP ${response.status}: ${text.slice(0, ERROR_TEXT_LIMIT)}`, true);
+    }
+    let payload;
+    try {
+        payload = text.length === 0 ? {} : JSON.parse(text);
+    }
+    catch {
+        throw new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `${provider} ${path} answered non-JSON (HTTP ${response.status})`, true);
+    }
+    if (response.status >= 400) {
+        const message = errorMessageOf(payload) ?? text.slice(0, ERROR_TEXT_LIMIT);
+        throw new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `${provider} ${path} refused (HTTP ${response.status}): ${message}`, false);
+    }
+    return payload;
+}
+const EXTERNAL_MESSAGE_REFUSED = /cannot apply external message/i;
+const EXTERNAL_MESSAGE_DUPLICATE = /duplicate message/i;
+const REFUSAL_EXIT_CODE = /exit\s*code\s*[=:]?\s*(-?\d+)/i;
+/**
+ * The wallets' refusals of an external request, by exit code.
+ *
+ * W5R1 checks the signature, then the seqno (133), the wallet id, then
+ * `valid_until`: a message that already landed fails on the seqno, and only
+ * there — every later refusal means the seqno still matched.
+ *
+ * v3r2 and v4r2 check `valid_until` first (v3r2: 35, which is also its bad
+ * signature; v4r2: 36), then the seqno (33), the wallet id (34), the
+ * signature (35). An expiry refusal therefore says nothing about whether the
+ * message landed earlier.
+ */
+const SEQNO_MOVED_EXIT_CODES = new Set([133, 33]);
+/**
+ * The account refused to run the request at all — typically it holds nothing
+ * to pay for it, as a wallet that sent everything away does. No check ran, so
+ * this says nothing about whether the same request landed earlier.
+ */
+const REFUSED_BEFORE_EXECUTION = /before smart-contract execution/i;
+const MAYBE_LANDED_EXIT_CODES = new Set([35, 36]);
+/**
+ * The reply to a broadcast, read for what the lite server said rather than
+ * the HTTP status (both answers come as HTTP 500 from TON Center, and from
+ * TonAPI as 500 or 406):
+ * - "duplicate message": the network already has this exact message, so the
+ *   broadcast succeeded;
+ * - "cannot apply external message": the wallet does not accept it now. On a
+ *   seqno check (W5 133, v3r2 / v4r2 33) this is `NonceTooLow` — this
+ *   message or another with its seqno already landed, so read the status
+ *   before signing again; on a v3r2 / v4r2 expiry (35, 36), or a refusal "before
+ *   smart-contract execution" (an account that cannot pay to run it), it may
+ *   have landed earlier, so it is `BroadcastUncertain`; any other refusal is
+ *   a definite `BroadcastRejected`.
+ */
+async function tonBroadcastReply(provider, reply) {
+    try {
+        return await reply;
+    }
+    catch (err) {
+        if (!(err instanceof TonProviderError))
+            throw err;
+        if (EXTERNAL_MESSAGE_DUPLICATE.test(err.message))
+            return {};
+        if (EXTERNAL_MESSAGE_REFUSED.test(err.message)) {
+            if (REFUSED_BEFORE_EXECUTION.test(err.message)) {
+                throw new TonBroadcastUncertainError(`${provider} refused the message before running it (the account cannot pay for it); it may be a request that landed earlier: ${err.message}`, undefined, err);
+            }
+            const exitCode = Number(REFUSAL_EXIT_CODE.exec(err.message)?.[1]);
+            if (MAYBE_LANDED_EXIT_CODES.has(exitCode)) {
+                throw new TonBroadcastUncertainError(`${provider} refused the message as expired (v3r2 / v4r2 check that first, so it may have landed earlier) or for its signature: ${err.message}`, undefined, err);
+            }
+            if (SEQNO_MOVED_EXIT_CODES.has(exitCode)) {
+                throw new TonProviderError(errors_ts_1.ChainErrorKinds.NonceTooLow, `${provider} refused the message: the wallet's seqno has moved past it, so it or another request with its seqno landed: ${err.message}`, false, undefined, err);
+            }
+            throw new TonProviderError(errors_ts_1.ChainErrorKinds.BroadcastRejected, `${provider} refused the message: ${err.message}`, false, undefined, err);
+        }
+        throw err;
+    }
+}
+/** The `error` field some replies carry with a 2xx status. */
+function errorMessageOf(payload) {
+    if (payload === null || typeof payload !== 'object')
+        return null;
+    const error = payload.error;
+    return typeof error === 'string' && error.length > 0 ? error : null;
+}
+function asRecord(value, what) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `Malformed TON provider reply: ${what} is not an object`, false);
+    }
+    return value;
+}
+function asBigInt(value, what) {
+    if (typeof value === 'bigint')
+        return value;
+    if ((typeof value === 'number' && Number.isInteger(value)) || (typeof value === 'string' && /^-?(\d+|0x[0-9a-fA-F]+)$/.test(value))) {
+        return BigInt(value);
+    }
+    if (value === undefined || value === null)
+        return 0n;
+    throw new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `Malformed TON provider reply: ${what} is not an integer`, false);
+}
+/** A required integer field; a reply without one says nothing definite, so the fallback is asked. */
+function asRequiredInteger(value, what) {
+    const parsed = typeof value === 'number' ? value : typeof value === 'string' && /^-?\d+$/.test(value) ? Number(value) : NaN;
+    if (!Number.isSafeInteger(parsed)) {
+        throw new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `Malformed TON provider reply: ${what} is missing or not an integer`, true);
+    }
+    return parsed;
+}
+function malformed(what) {
+    return new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `Malformed TON provider reply: ${what}`, true);
+}
+/** A required object field; a reply without one says nothing definite, so the fallback is asked. */
+function asRequiredRecord(value, what) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw malformed(`${what} is missing or not an object`);
+    return value;
+}
+/** A get-method stack entry that is a cell or slice: TON Center gives base64 (`value`), TonAPI hex (`cell`). */
+function stackCellOf(item, what) {
+    const entry = asRequiredRecord(item, what);
+    if (entry.type !== 'cell' && entry.type !== 'slice')
+        throw malformed(`${what} is not a cell`);
+    try {
+        if (typeof entry.value === 'string')
+            return core_1.Cell.fromBase64(entry.value);
+        if (typeof entry.cell === 'string')
+            return core_1.Cell.fromBoc(Buffer.from(entry.cell, 'hex'))[0];
+    }
+    catch {
+        throw malformed(`${what} is not a valid cell`);
+    }
+    throw malformed(`${what} carries no cell`);
+}
+/** `get_wallet_data`'s stack — balance, owner, master, code — as both providers give it. */
+function jettonWalletDataOf(stack) {
+    if (!Array.isArray(stack) || stack.length < 3)
+        throw malformed('get_wallet_data returned a short stack');
+    const balanceEntry = asRequiredRecord(stack[0], 'jetton balance');
+    const balance = asBigInt(balanceEntry.value ?? balanceEntry.num, 'jetton balance');
+    try {
+        return {
+            balance,
+            owner: stackCellOf(stack[1], 'jetton wallet owner').beginParse().loadAddress().toRawString(),
+            jettonMaster: stackCellOf(stack[2], 'jetton master').beginParse().loadAddress().toRawString(),
+        };
+    }
+    catch (err) {
+        if (err instanceof TonProviderError)
+            throw err;
+        throw malformed('get_wallet_data returned no addresses');
+    }
+}
+/** A required boolean field; see {@link asRequiredRecord}. */
+function asRequiredBoolean(value, what) {
+    if (typeof value !== 'boolean')
+        throw malformed(`${what} is missing or not a boolean`);
+    return value;
+}
+/**
+ * A transaction succeeds when its compute phase succeeded — or was skipped
+ * only because the account has no code yet — and its action phase, if any,
+ * succeeded without skipping a message. Phases that cannot be what the chain
+ * recorded (a successful compute phase without an action phase) are a
+ * malformed reply, never a success.
+ */
+function tonTransactionOutcome(phases) {
+    const ran = phases.computeSkipped === null;
+    if (ran && phases.computeSuccess && phases.action === null)
+        throw malformed('a compute phase that succeeded has no action phase');
+    if ((!ran || !phases.computeSuccess) && phases.action !== null)
+        throw malformed('an action phase follows a compute phase that did not succeed');
+    const computeOk = ran ? phases.computeSuccess : phases.computeSkipped === 'no_state';
+    const skippedActions = phases.action?.skippedActions ?? 0;
+    return {
+        success: computeOk && (phases.action === null || (phases.action.success && skippedActions === 0)),
+        skippedActions,
+        aborted: phases.aborted,
+        computeExitCode: ran ? phases.computeExitCode : null,
+        actionResultCode: phases.action?.resultCode ?? null,
+    };
+}
+/** An account's status as the provider stated it; anything else says nothing definite. */
+function asStatedAccountStatus(value) {
+    if (value === 'active' || value === 'frozen' || value === 'uninit' || value === 'nonexist')
+        return value;
+    throw new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `Malformed TON provider reply: unknown account status ${String(value)}`, true);
+}
+function asAccountStatus(value) {
+    return value === 'active' || value === 'frozen' || value === 'uninit' || value === 'nonexist' ? value : 'nonexist';
+}
+/** A decoded message in the trace form (raw addresses, opcode from the body). */
+function tonTraceMessageOf(message) {
+    const info = message.info;
+    const body = message.body.bits.length === 0 && message.body.refs.length === 0 ? null : message.body;
+    return {
+        source: info.type === 'external-in' || info.src === null ? null : info.src.toRawString(),
+        destination: info.type === 'external-out' ? null : info.dest.toRawString(),
+        value: info.type === 'internal' ? info.value.coins : 0n,
+        fwdFee: info.type === 'internal' ? info.forwardFee : 0n,
+        bounce: info.type === 'internal' && info.bounce,
+        bounced: info.type === 'internal' && info.bounced,
+        opcode: body !== null && body.bits.length >= 32 ? body.beginParse().loadUint(32) : null,
+        createdLt: info.type === 'external-in' ? null : info.createdLt,
+        body,
+    };
+}
+/**
+ * Checks a trace before anything is judged from it. On TON every internal
+ * message produces a transaction where it lands, so a provider's trace must
+ * hold together:
+ * - one root (the first transaction); every other transaction has a parent in
+ *   the trace and an incoming message. A trace still running may lack a
+ *   parent, the root included;
+ * - every internal message sent names its source and `created_lt`;
+ * - every incoming message is one its parent sent: same source, `created_lt`,
+ *   destination and value;
+ * - in a complete trace, every internal message sent has the transaction
+ *   that received it.
+ * A trace that breaks any of these is the provider's error, not the chain's:
+ * the error is retryable, so the fallback provider is asked instead, and no
+ * gap is ever read as an undelivered message.
+ */
+function assertTraceConsistent(source, trace) {
+    const inconsistent = (detail) => new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `Inconsistent trace from ${source}: ${detail}`, true);
+    const byHash = new Map(trace.transactions.map((tx) => [tx.hash, tx]));
+    const received = new Set();
+    trace.transactions.forEach((tx, index) => {
+        const unnamed = tx.outMsgs.find((m) => m.destination !== null && (m.source === null || m.createdLt === null));
+        if (unnamed !== undefined)
+            throw inconsistent(`transaction ${tx.hash} sent a message to ${unnamed.destination} with no source or created_lt`);
+        if (index === 0 && tx.parent === null)
+            return;
+        if (tx.parent === null)
+            throw inconsistent(`transaction ${tx.hash} has no parent but is not the root`);
+        if (tx.inMsg === null || tx.inMsg.source === null || tx.inMsg.createdLt === null) {
+            throw inconsistent(`transaction ${tx.hash} has no incoming internal message`);
+        }
+        const parent = byHash.get(tx.parent);
+        if (parent === undefined) {
+            if (trace.complete)
+                throw inconsistent(`transaction ${tx.hash} names a parent ${tx.parent} the trace does not hold`);
+            return;
+        }
+        const inMsg = tx.inMsg;
+        const sent = parent.outMsgs.find((m) => m.source === inMsg.source && m.createdLt === inMsg.createdLt);
+        if (sent === undefined || sent.destination !== tx.account || sent.value !== inMsg.value) {
+            throw inconsistent(`transaction ${tx.hash} received no message its parent ${parent.hash} sent`);
+        }
+        received.add(`${parent.hash}:${inMsg.createdLt}`);
+    });
+    if (trace.complete) {
+        for (const tx of trace.transactions) {
+            const lost = tx.outMsgs.find((m) => m.destination !== null && !received.has(`${tx.hash}:${m.createdLt}`));
+            if (lost !== undefined) {
+                throw inconsistent(`the trace is complete, but the message ${tx.hash} sent to ${lost.destination} reached no transaction`);
+            }
+        }
+    }
+    return trace;
+}
+/**
+ * The trace a provider returned for `hash` must be that message's: its root
+ * received an external message whose normalized hash is `hash`. A trace still
+ * running may not hold its root yet.
+ */
+function assertTraceOf(source, hash, trace) {
+    const root = trace.transactions[0];
+    if (root === undefined || root.parent !== null)
+        return trace;
+    const inMsg = root.inMsg;
+    if (inMsg === null || inMsg.source !== null || inMsg.body === null || (0, ton_messages_ts_1.tonNormalizedExternalHash)(root.account, inMsg.body) !== hash) {
+        throw new TonProviderError(errors_ts_1.ChainErrorKinds.RpcError, `${source} returned the trace of another message than ${hash}`, true);
+    }
+    return trace;
+}
+const TX_HASH_REGEX = /^[0-9a-f]{64}$/;
+/**
+ * Refuses anything but a transaction id as the SDK gives it — the normalized
+ * external-message hash, 64 lowercase hex characters. A base64 hash or a typo
+ * would otherwise find no trace, and "no trace" counts as "never landed".
+ */
+function assertTonTxHash(hash) {
+    if (typeof hash !== 'string' || !TX_HASH_REGEX.test(hash)) {
+        throw new TonProviderError(errors_ts_1.ChainErrorKinds.InvalidArgument, `A TON transaction id is 64 lowercase hex characters, got ${JSON.stringify(hash)}`, false);
+    }
+    return hash;
+}
+function definiteError(kind, message) {
+    return new TonProviderError(kind, message, false);
+}
+//# sourceMappingURL=ton_provider.js.map