@vultisig/core-chain 5.0.0 → 5.2.0

package/dist/chains/ton/failure.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Why a TON transaction did not move funds, in terms a user can act on. The
+ * wallet contract's own checks (`seqno-mismatch`, `expired`, `invalid-signature`,
+ * `wallet-id-mismatch`) fire in the compute phase of the sender's wallet; the
+ * money-related ones fire when the wallet tries to emit the transfer (action
+ * phase) or in the jetton wallet's compute phase.
+ */
+export declare const tonTxFailureReasons: readonly ["seqno-mismatch", "expired", "invalid-signature", "wallet-id-mismatch", "insufficient-funds", "out-of-gas", "invalid-destination", "not-enough-jettons", "jetton-unauthorized", "action-failed", "action-partially-failed", "aborted", "contract-rejected"];
+export type TonTxFailureReason = (typeof tonTxFailureReasons)[number];
+/** Which phase of the TON transaction produced the code: TVM execution or emitting the outgoing messages. */
+export type TonTxPhase = 'compute' | 'action';
+export type TonTxFailure = {
+    reason: TonTxFailureReason;
+    phase: TonTxPhase;
+    exitCode?: number;
+    /** Plain-language explanation with the remedy, in English. */
+    message: string;
+};
+/** Classifies a compute-phase exit code (0 and 1 are success and yield `undefined`). */
+export declare const getTonComputeFailure: (exitCode: number | undefined) => TonTxFailure | undefined;
+type TonActionPhaseOutcome = {
+    success?: boolean;
+    no_funds?: boolean;
+    result_code?: number;
+    skipped_actions?: number;
+    /** Outgoing messages the phase actually produced, when the node reports it. */
+    msgs_created?: number;
+};
+/**
+ * Classifies a failed action phase. A result code the table names wins; an
+ * unnamed one is read as a funding failure only when `no_funds` backs it, and
+ * otherwise stays generic with the code attached. `no_funds` without any code
+ * still means the transfer could not be paid for, and a skipped or unsuccessful
+ * action with neither is generic — worded by `genericActionReason`, which will not
+ * claim nothing was sent unless the node says so.
+ */
+export declare const getTonActionFailure: (action: TonActionPhaseOutcome | undefined) => TonTxFailure | undefined;
+type TonTransactionOutcome = {
+    aborted?: boolean;
+    compute_ph?: {
+        exit_code?: number;
+    };
+    action?: TonActionPhaseOutcome;
+};
+/**
+ * Explains why an indexed TON transaction failed, or `undefined` when it did
+ * not. The compute phase is consulted first because it carries the specific
+ * exit code; an aborted transaction with no readable phase is reported as such.
+ */
+export declare const getTonTxFailure: (description: TonTransactionOutcome) => TonTxFailure | undefined;
+/**
+ * Reads the wallet contract's exit code out of a toncenter `sendBoc` rejection
+ * ("… inbound external message rejected by transaction …: exitcode=133, steps=49,
+ * gas_used=0 …"). The message never reached the chain, so the code is always the
+ * sender's wallet refusing it in its compute phase. Returns `undefined` for
+ * transport errors and any other rejection shape.
+ */
+export declare const parseTonBroadcastRejection: (error: unknown) => TonTxFailure | undefined;
+/**
+ * A TON broadcast the sender's wallet contract refused, with the refusal
+ * classified. `message` is the human-readable explanation so any consumer that
+ * only prints `error.message` already shows the right remedy; the original
+ * toncenter error stays in `cause`.
+ */
+export declare class TonBroadcastRejectedError extends Error {
+    readonly failure: TonTxFailure;
+    constructor(failure: TonTxFailure, cause: unknown);
+}
+export {};
+//# sourceMappingURL=failure.d.ts.map

package/dist/chains/ton/failure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/chain/chains/ton/failure.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,uQActB,CAAA;AAEV,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAErE,6GAA6G;AAC7G,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAA;AAE7C,MAAM,MAAM,YAAY,GAAG;IACzB,MAAM,EAAE,kBAAkB,CAAA;IAC1B,KAAK,EAAE,UAAU,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAsFD,wFAAwF;AACxF,eAAO,MAAM,oBAAoB,GAAI,UAAU,MAAM,GAAG,SAAS,KAAG,YAAY,GAAG,SAIlF,CAAA;AAED,KAAK,qBAAqB,GAAG;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,+EAA+E;IAC/E,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAeD;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,qBAAqB,GAAG,SAAS,KAAG,YAAY,GAAG,SAkB9F,CAAA;AAED,KAAK,qBAAqB,GAAG;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,UAAU,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IACnC,MAAM,CAAC,EAAE,qBAAqB,CAAA;CAC/B,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,aAAa,qBAAqB,KAAG,YAAY,GAAG,SAGJ,CAAA;AAIhF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GAAI,OAAO,OAAO,KAAG,YAAY,GAAG,SAK1E,CAAA;AAED;;;;;GAKG;AACH,qBAAa,yBAA0B,SAAQ,KAAK;aAEhC,OAAO,EAAE,YAAY;gBAArB,OAAO,EAAE,YAAY,EACrC,KAAK,EAAE,OAAO;CAKjB"}

package/dist/chains/ton/failure.js

@@ -0,0 +1,170 @@
+import { extractErrorMsg } from '@vultisig/lib-utils/error/extractErrorMsg';
+/**
+ * Why a TON transaction did not move funds, in terms a user can act on. The
+ * wallet contract's own checks (`seqno-mismatch`, `expired`, `invalid-signature`,
+ * `wallet-id-mismatch`) fire in the compute phase of the sender's wallet; the
+ * money-related ones fire when the wallet tries to emit the transfer (action
+ * phase) or in the jetton wallet's compute phase.
+ */
+export const tonTxFailureReasons = [
+    'seqno-mismatch',
+    'expired',
+    'invalid-signature',
+    'wallet-id-mismatch',
+    'insufficient-funds',
+    'out-of-gas',
+    'invalid-destination',
+    'not-enough-jettons',
+    'jetton-unauthorized',
+    'action-failed',
+    'action-partially-failed',
+    'aborted',
+    'contract-rejected',
+];
+/**
+ * Compute-phase exit codes. The sender's wallet contract throws the first block
+ * from `recv_external`: wallet v3/v4 use 33–36, W5 uses 133–136 for the same
+ * checks. 13 / -14 are the TVM's out-of-gas codes. 705 and 706 come from the
+ * standard jetton wallet (TEP-74) and mean the same thing on a transfer and on
+ * a burn; its 707 and 709 are deliberately absent because the reference
+ * contract reuses each for two unrelated checks (707: unauthorized incoming
+ * transfer, or too little TON on a burn; 709: too little TON on a transfer, or
+ * an unexpected bounced op), and the code alone cannot tell which. Everything
+ * else is a contract-specific revert we can only report by number.
+ */
+const computeExitCodeReasons = {
+    33: 'seqno-mismatch',
+    133: 'seqno-mismatch',
+    34: 'wallet-id-mismatch',
+    134: 'wallet-id-mismatch',
+    35: 'invalid-signature',
+    135: 'invalid-signature',
+    36: 'expired',
+    136: 'expired',
+    13: 'out-of-gas',
+    [-14]: 'out-of-gas',
+    705: 'jetton-unauthorized',
+    706: 'not-enough-jettons',
+};
+/**
+ * Action-phase result codes that mean one thing. 36 here is an invalid destination,
+ * not the wallet's `expired` (36), which can only come from the compute phase. 37 is
+ * "Not enough GRAMs" and says so on its own.
+ *
+ * 40 is deliberately absent. It reads "Cannot process a message — not enough funds,
+ * the message is too large, or its Merkle depth is too big", so naming it a funding
+ * failure would send a user to top up their balance when the payload is what has to
+ * change. Codes like it fall through to `no_funds` below, the only authoritative
+ * funding signal in the phase.
+ */
+const actionResultCodeReasons = {
+    36: 'invalid-destination',
+    37: 'insufficient-funds',
+};
+/**
+ * Human-readable explanations. Each says what happened and what to do; the
+ * remedy matters more than the code, because the two failures that dominate
+ * TON support — a replayed seqno and an expired `valid_until` — both look like
+ * "the network rejected it" and have opposite fixes.
+ */
+const failureMessages = {
+    'seqno-mismatch': 'Another transaction from this wallet was processed first, so the network rejected this one as out of order. Check your history: if this transfer is not there, send it again.',
+    expired: "The transaction's time window closed before the network processed it. Make sure your device's date and time are set automatically, then send it again.",
+    'invalid-signature': 'The wallet contract rejected the signature. Sign the transaction again; if it keeps failing, the wallet contract at this address does not match this vault.',
+    'wallet-id-mismatch': 'The transaction was built for a different wallet contract version than the one deployed at this address.',
+    'insufficient-funds': 'Not enough TON to cover the amount plus network fees. Keep about 0.05 TON spare for fees and try again.',
+    'out-of-gas': 'The transaction ran out of gas before it could finish. Attach more TON to the transfer and try again.',
+    'invalid-destination': 'The destination address is not valid on TON. Check the address and try again.',
+    'not-enough-jettons': 'This wallet does not hold enough of the token to send that amount.',
+    'jetton-unauthorized': 'The token contract refused the transfer because this wallet is not allowed to move these tokens.',
+    'action-failed': 'The wallet accepted the transaction but could not carry out the transfer, so nothing was sent. The network fee was still charged. Check the transaction and try again.',
+    'action-partially-failed': 'The wallet could not carry out at least one transfer in this transaction, and others in it may have gone through. The network fee was still charged. Check your transaction history before sending again.',
+    aborted: 'The network aborted this transaction before it could carry out the transfer.',
+    'contract-rejected': 'The contract rejected the transaction.',
+};
+const describe = (reason, exitCode) => reason === 'contract-rejected' && exitCode !== undefined
+    ? `The contract rejected the transaction (exit code ${exitCode}).`
+    : failureMessages[reason];
+const makeFailure = (reason, phase, exitCode) => ({
+    reason,
+    phase,
+    ...(exitCode === undefined ? {} : { exitCode }),
+    message: describe(reason, exitCode),
+});
+/** Classifies a compute-phase exit code (0 and 1 are success and yield `undefined`). */
+export const getTonComputeFailure = (exitCode) => {
+    if (exitCode === undefined || exitCode === 0 || exitCode === 1)
+        return undefined;
+    return makeFailure(computeExitCodeReasons[exitCode] ?? 'contract-rejected', 'compute', exitCode);
+};
+/**
+ * Which generic explanation a failed action phase gets.
+ *
+ * Under `IGNORE_ERRORS` — the mode every Vultisig TON send uses — a failing action
+ * is skipped and the remaining ones still go out, so a batch can lose one transfer
+ * and deliver the rest. Telling that user nothing was sent and to try again is how a
+ * duplicate transfer happens, so only the node's own `msgs_created: 0` earns the
+ * "nothing was sent" wording. A node that reports nothing proves nothing either way
+ * and gets the neutral explanation, which reads correctly for both outcomes.
+ */
+const genericActionReason = ({ msgs_created }) => msgs_created === 0 ? 'action-failed' : 'action-partially-failed';
+/**
+ * Classifies a failed action phase. A result code the table names wins; an
+ * unnamed one is read as a funding failure only when `no_funds` backs it, and
+ * otherwise stays generic with the code attached. `no_funds` without any code
+ * still means the transfer could not be paid for, and a skipped or unsuccessful
+ * action with neither is generic — worded by `genericActionReason`, which will not
+ * claim nothing was sent unless the node says so.
+ */
+export const getTonActionFailure = (action) => {
+    if (!action)
+        return undefined;
+    const { success, no_funds, result_code, skipped_actions } = action;
+    if (result_code !== undefined && result_code !== 0) {
+        // A code the table does not name is a funding failure only when the node says so.
+        const reason = actionResultCodeReasons[result_code] ?? (no_funds === true ? 'insufficient-funds' : genericActionReason(action));
+        return makeFailure(reason, 'action', result_code);
+    }
+    if (no_funds === true)
+        return makeFailure('insufficient-funds', 'action');
+    if (success === false || (skipped_actions ?? 0) > 0)
+        return makeFailure(genericActionReason(action), 'action');
+    return undefined;
+};
+/**
+ * Explains why an indexed TON transaction failed, or `undefined` when it did
+ * not. The compute phase is consulted first because it carries the specific
+ * exit code; an aborted transaction with no readable phase is reported as such.
+ */
+export const getTonTxFailure = (description) => getTonComputeFailure(description.compute_ph?.exit_code) ??
+    getTonActionFailure(description.action) ??
+    (description.aborted === true ? makeFailure('aborted', 'compute') : undefined);
+const rejectionExitCodePattern = /exitcode=(-?\d+)/i;
+/**
+ * Reads the wallet contract's exit code out of a toncenter `sendBoc` rejection
+ * ("… inbound external message rejected by transaction …: exitcode=133, steps=49,
+ * gas_used=0 …"). The message never reached the chain, so the code is always the
+ * sender's wallet refusing it in its compute phase. Returns `undefined` for
+ * transport errors and any other rejection shape.
+ */
+export const parseTonBroadcastRejection = (error) => {
+    const match = rejectionExitCodePattern.exec(String(extractErrorMsg(error)));
+    if (!match)
+        return undefined;
+    return getTonComputeFailure(Number(match[1]));
+};
+/**
+ * A TON broadcast the sender's wallet contract refused, with the refusal
+ * classified. `message` is the human-readable explanation so any consumer that
+ * only prints `error.message` already shows the right remedy; the original
+ * toncenter error stays in `cause`.
+ */
+export class TonBroadcastRejectedError extends Error {
+    failure;
+    constructor(failure, cause) {
+        super(failure.message, { cause });
+        this.failure = failure;
+        this.name = 'TonBroadcastRejectedError';
+    }
+}
+//# sourceMappingURL=failure.js.map

package/dist/chains/ton/failure.js.map

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

package/dist/chains/ton/jetton/symbol.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Collapses a jetton symbol or name to the Latin skeleton a user perceives, so
+ * `USD₮`, `UЅDT` (Cyrillic Ѕ), `$USĐ₮` and `usdt` all compare equal to `USDT`.
+ * Compatibility decomposition folds full-width and mathematical letter forms,
+ * diacritics are dropped, known homoglyphs are mapped, and everything that is
+ * not `A–Z`/`0–9` is removed. Returns an empty string when nothing survives.
+ */
+export declare const normalizeJettonSymbol: (value: string) => string;
+//# sourceMappingURL=symbol.d.ts.map

package/dist/chains/ton/jetton/symbol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/ton/jetton/symbol.ts"],"names":[],"mappings":"AAmDA;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI,OAAO,MAAM,KAAG,MAIxB,CAAA"}

package/dist/chains/ton/jetton/symbol.js

@@ -0,0 +1,61 @@
+/**
+ * Homoglyphs scammers substitute into a jetton symbol so it *reads* like a
+ * verified one while differing byte-for-byte: Cyrillic/Greek capitals that look
+ * like Latin ones, the tugrik sign standing in for `T`, and stroked `D`s. Keys
+ * are already upper-cased because the map is applied after `toUpperCase()`.
+ */
+const confusables = {
+    // Cyrillic
+    А: 'A',
+    В: 'B',
+    Е: 'E',
+    Ё: 'E',
+    Ѕ: 'S',
+    І: 'I',
+    Ј: 'J',
+    К: 'K',
+    М: 'M',
+    Н: 'H',
+    О: 'O',
+    Р: 'P',
+    С: 'C',
+    Т: 'T',
+    У: 'Y',
+    Х: 'X',
+    Ԛ: 'Q',
+    Ԝ: 'W',
+    // Greek
+    Α: 'A',
+    Β: 'B',
+    Ε: 'E',
+    Ζ: 'Z',
+    Η: 'H',
+    Ι: 'I',
+    Κ: 'K',
+    Μ: 'M',
+    Ν: 'N',
+    Ο: 'O',
+    Ρ: 'P',
+    Τ: 'T',
+    Υ: 'Y',
+    Χ: 'X',
+    // Currency and stroked letters
+    '₮': 'T',
+    Đ: 'D',
+    Ð: 'D',
+    Ɖ: 'D',
+    Ŧ: 'T',
+};
+const combiningMarks = /[̀-ͯ]/g;
+/**
+ * Collapses a jetton symbol or name to the Latin skeleton a user perceives, so
+ * `USD₮`, `UЅDT` (Cyrillic Ѕ), `$USĐ₮` and `usdt` all compare equal to `USDT`.
+ * Compatibility decomposition folds full-width and mathematical letter forms,
+ * diacritics are dropped, known homoglyphs are mapped, and everything that is
+ * not `A–Z`/`0–9` is removed. Returns an empty string when nothing survives.
+ */
+export const normalizeJettonSymbol = (value) => Array.from(value.normalize('NFKD').replace(combiningMarks, '').toUpperCase())
+    .map(char => confusables[char] ?? char)
+    .join('')
+    .replace(/[^A-Z0-9]/g, '');
+//# sourceMappingURL=symbol.js.map

package/dist/chains/ton/jetton/symbol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/ton/jetton/symbol.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,GAA2B;IAC1C,WAAW;IACX,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,QAAQ;IACR,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,+BAA+B;IAC/B,GAAG,EAAE,GAAG;IACR,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;IACN,CAAC,EAAE,GAAG;CACP,CAAA;AAED,MAAM,cAAc,GAAG,QAAQ,CAAA;AAE/B;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,KAAa,EAAU,EAAE,CAC7D,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;KAC1E,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC;KACtC,IAAI,CAAC,EAAE,CAAC;KACR,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAA"}

package/dist/chains/ton/jetton/verification.d.ts

@@ -0,0 +1,35 @@
+import { TokenVerification } from '@vultisig/core-chain/coin/tokenVerification';
+import { TonVerifiedJettonRegistry } from './verifiedRegistry.js';
+type ResolveTonJettonVerificationInput = {
+    /** Jetton master address, raw or user-friendly. */
+    address: string;
+    symbol?: string;
+    name?: string;
+    /** Toncenter's own scam flag for the master, when known. */
+    isFlaggedScam?: boolean;
+    registry: TonVerifiedJettonRegistry;
+};
+/**
+ * Classifies a jetton against the verified registry. A listed address is
+ * `verified` whatever it calls itself. An unlisted jetton is `scam` when the
+ * indexer flags it or when its symbol or name collapses (see
+ * `normalizeJettonSymbol`) onto a verified jetton's symbol or name — the
+ * fake-USDT pattern, where the counterfeit is only distinguishable by address.
+ * Anything else is `unverified`.
+ */
+export declare const resolveTonJettonVerification: ({ address, symbol, name, isFlaggedScam, registry, }: ResolveTonJettonVerificationInput) => TokenVerification;
+type GetTonJettonVerificationInput = {
+    /** Jetton master address, raw or user-friendly. */
+    id: string;
+    /** Ticker already known locally, used when Toncenter has no symbol for the master. */
+    ticker?: string;
+};
+/**
+ * Verification tier for one jetton, for token rows and approval cards. Reads the
+ * master's on-chain symbol and name from Toncenter so a counterfeit is judged by
+ * what it actually claims to be, not by the ticker stored locally; falls back to
+ * that ticker when the lookup fails, so the label still renders offline.
+ */
+export declare const getTonJettonVerification: ({ id, ticker, }: GetTonJettonVerificationInput) => Promise<TokenVerification>;
+export {};
+//# sourceMappingURL=verification.d.ts.map

package/dist/chains/ton/jetton/verification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/ton/jetton/verification.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,6CAA6C,CAAA;AAI/E,OAAO,EAAgC,yBAAyB,EAAE,MAAM,oBAAoB,CAAA;AAE5F,KAAK,iCAAiC,GAAG;IACvC,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,4DAA4D;IAC5D,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,EAAE,yBAAyB,CAAA;CACpC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,GAAI,qDAM1C,iCAAiC,KAAG,iBAYtC,CAAA;AAED,KAAK,6BAA6B,GAAG;IACnC,mDAAmD;IACnD,EAAE,EAAE,MAAM,CAAA;IACV,sFAAsF;IACtF,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GAAU,iBAG5C,6BAA6B,KAAG,OAAO,CAAC,iBAAiB,CAe3D,CAAA"}

package/dist/chains/ton/jetton/verification.js

@@ -0,0 +1,45 @@
+import { tonAddressToRawKey } from '@vultisig/core-chain/chains/ton/address';
+import { getJettonMastersMetadata } from '@vultisig/core-chain/chains/ton/api';
+import { attempt } from '@vultisig/lib-utils/attempt';
+import { normalizeJettonSymbol } from './symbol.js';
+import { getTonVerifiedJettonRegistry } from './verifiedRegistry.js';
+/**
+ * Classifies a jetton against the verified registry. A listed address is
+ * `verified` whatever it calls itself. An unlisted jetton is `scam` when the
+ * indexer flags it or when its symbol or name collapses (see
+ * `normalizeJettonSymbol`) onto a verified jetton's symbol or name — the
+ * fake-USDT pattern, where the counterfeit is only distinguishable by address.
+ * Anything else is `unverified`.
+ */
+export const resolveTonJettonVerification = ({ address, symbol, name, isFlaggedScam, registry, }) => {
+    if (registry.byAddress[tonAddressToRawKey(address)])
+        return 'verified';
+    if (isFlaggedScam)
+        return 'scam';
+    const impersonates = [symbol, name].some(label => {
+        const skeleton = label ? normalizeJettonSymbol(label) : '';
+        return !!skeleton && (registry.symbols.has(skeleton) || registry.names.has(skeleton));
+    });
+    return impersonates ? 'scam' : 'unverified';
+};
+/**
+ * Verification tier for one jetton, for token rows and approval cards. Reads the
+ * master's on-chain symbol and name from Toncenter so a counterfeit is judged by
+ * what it actually claims to be, not by the ticker stored locally; falls back to
+ * that ticker when the lookup fails, so the label still renders offline.
+ */
+export const getTonJettonVerification = async ({ id, ticker, }) => {
+    const [registry, metadata] = await Promise.all([
+        getTonVerifiedJettonRegistry(),
+        attempt(getJettonMastersMetadata([id])),
+    ]);
+    const master = 'data' in metadata ? metadata.data?.[tonAddressToRawKey(id)] : undefined;
+    return resolveTonJettonVerification({
+        address: id,
+        symbol: master?.symbol ?? ticker,
+        name: master?.name,
+        isFlaggedScam: master?.isFlaggedScam,
+        registry,
+    });
+};
+//# sourceMappingURL=verification.js.map

package/dist/chains/ton/jetton/verification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/ton/jetton/verification.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAA;AAC5E,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAA;AAE9E,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAA;AAErD,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAChD,OAAO,EAAE,4BAA4B,EAA6B,MAAM,oBAAoB,CAAA;AAY5F;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,EAC3C,OAAO,EACP,MAAM,EACN,IAAI,EACJ,aAAa,EACb,QAAQ,GAC0B,EAAqB,EAAE;IACzD,IAAI,QAAQ,CAAC,SAAS,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QAAE,OAAO,UAAU,CAAA;IAEtE,IAAI,aAAa;QAAE,OAAO,MAAM,CAAA;IAEhC,MAAM,YAAY,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;QAC/C,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;QAE1D,OAAO,CAAC,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAA;IACvF,CAAC,CAAC,CAAA;IAEF,OAAO,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,YAAY,CAAA;AAC7C,CAAC,CAAA;AASD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,KAAK,EAAE,EAC7C,EAAE,EACF,MAAM,GACwB,EAA8B,EAAE;IAC9D,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAC7C,4BAA4B,EAAE;QAC9B,OAAO,CAAC,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;KACxC,CAAC,CAAA;IAEF,MAAM,MAAM,GAAG,MAAM,IAAI,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;IAEvF,OAAO,4BAA4B,CAAC;QAClC,OAAO,EAAE,EAAE;QACX,MAAM,EAAE,MAAM,EAAE,MAAM,IAAI,MAAM;QAChC,IAAI,EAAE,MAAM,EAAE,IAAI;QAClB,aAAa,EAAE,MAAM,EAAE,aAAa;QACpC,QAAQ;KACT,CAAC,CAAA;AACJ,CAAC,CAAA"}

package/dist/chains/ton/jetton/verifiedRegistry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Tonkeeper's community-reviewed jetton whitelist, the list every major TON
+ * wallet uses as its "verified" tier. Compiled from the repo's YAML sources on
+ * every merge; served with `Access-Control-Allow-Origin: *`.
+ */
+export declare const tonAssetsJettonsUrl = "https://raw.githubusercontent.com/tonkeeper/ton-assets/main/jettons.json";
+/** A jetton we treat as legitimate, keyed by its lower-cased raw master address. */
+export type VerifiedJetton = {
+    address: string;
+    symbol: string;
+    name?: string;
+    decimals?: number;
+    logo?: string;
+    priceProviderId?: string;
+};
+/**
+ * Verified jettons indexed for the two questions verification asks: "is this
+ * address listed?" and "does this symbol or name belong to a listed jetton?".
+ * `symbols` and `names` hold `normalizeJettonSymbol` skeletons.
+ */
+export type TonVerifiedJettonRegistry = {
+    byAddress: Record<string, VerifiedJetton>;
+    symbols: Set<string>;
+    names: Set<string>;
+};
+/**
+ * Builds a registry from a list of verified jettons. On an address collision the
+ * earlier entry's metadata is kept in `byAddress`, but every entry's symbol and
+ * name are indexed: two entries for one address describe the same verified
+ * contract, and a counterfeit may copy either spelling. Our curated USDT carries
+ * the ticker `USDT` and no name; only the ton-assets duplicate contributes
+ * `USD₮` and `Tether USD`, so dropping it would let a "Tether USD" impostor
+ * through as merely unverified.
+ */
+export declare const makeTonVerifiedJettonRegistry: (jettons: VerifiedJetton[]) => TonVerifiedJettonRegistry;
+/**
+ * The jettons we consider verified: our own curated TON tokens (which win, so
+ * their tickers and price ids are kept) merged with the ton-assets whitelist.
+ * Degrades to the curated list alone when the whitelist cannot be fetched, so
+ * discovery and labels keep working offline — with fewer jettons recognised.
+ */
+export declare const getTonVerifiedJettonRegistry: () => Promise<TonVerifiedJettonRegistry>;
+//# sourceMappingURL=verifiedRegistry.d.ts.map

package/dist/chains/ton/jetton/verifiedRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifiedRegistry.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/ton/jetton/verifiedRegistry.ts"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,6EAA6E,CAAA;AAW7G,oFAAoF;AACpF,MAAM,MAAM,cAAc,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAED;;;;GAIG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;IACzC,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACpB,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CACnB,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,GAAI,SAAS,cAAc,EAAE,KAAG,yBAezE,CAAA;AA4DD;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,QAAa,OAAO,CAAC,yBAAyB,CAOtF,CAAA"}

package/dist/chains/ton/jetton/verifiedRegistry.js

@@ -0,0 +1,94 @@
+import { Chain } from '@vultisig/core-chain/Chain';
+import { tonAddressToRawKey } from '@vultisig/core-chain/chains/ton/address';
+import { knownTokens } from '@vultisig/core-chain/coin/knownTokens';
+import { attempt } from '@vultisig/lib-utils/attempt';
+import { memoizeAsync } from '@vultisig/lib-utils/memoizeAsync';
+import { queryUrl } from '@vultisig/lib-utils/query/queryUrl';
+import { convertDuration } from '@vultisig/lib-utils/time/convertDuration';
+import { normalizeJettonSymbol } from './symbol.js';
+/**
+ * Tonkeeper's community-reviewed jetton whitelist, the list every major TON
+ * wallet uses as its "verified" tier. Compiled from the repo's YAML sources on
+ * every merge; served with `Access-Control-Allow-Origin: *`.
+ */
+export const tonAssetsJettonsUrl = 'https://raw.githubusercontent.com/tonkeeper/ton-assets/main/jettons.json';
+/**
+ * Builds a registry from a list of verified jettons. On an address collision the
+ * earlier entry's metadata is kept in `byAddress`, but every entry's symbol and
+ * name are indexed: two entries for one address describe the same verified
+ * contract, and a counterfeit may copy either spelling. Our curated USDT carries
+ * the ticker `USDT` and no name; only the ton-assets duplicate contributes
+ * `USD₮` and `Tether USD`, so dropping it would let a "Tether USD" impostor
+ * through as merely unverified.
+ */
+export const makeTonVerifiedJettonRegistry = (jettons) => {
+    const registry = { byAddress: {}, symbols: new Set(), names: new Set() };
+    for (const jetton of jettons) {
+        const address = tonAddressToRawKey(jetton.address);
+        registry.byAddress[address] ??= { ...jetton, address };
+        const symbol = normalizeJettonSymbol(jetton.symbol);
+        if (symbol)
+            registry.symbols.add(symbol);
+        const name = jetton.name ? normalizeJettonSymbol(jetton.name) : '';
+        if (name)
+            registry.names.add(name);
+    }
+    return registry;
+};
+const getCuratedJettons = () => knownTokens[Chain.Ton].flatMap(({ id, ticker, decimals, logo, priceProviderId }) => id
+    ? [
+        {
+            address: tonAddressToRawKey(id),
+            symbol: ticker,
+            decimals,
+            logo,
+            ...(priceProviderId === undefined ? {} : { priceProviderId }),
+        },
+    ]
+    : []);
+const isTonAssetsJetton = (value) => typeof value === 'object' && value !== null && typeof value.address === 'string';
+const fetchTonAssetsJettons = async () => {
+    const response = await queryUrl(tonAssetsJettonsUrl);
+    if (!Array.isArray(response)) {
+        throw new Error('ton-assets jettons.json is not a list');
+    }
+    return response.filter(isTonAssetsJetton).flatMap(({ address, name, symbol, decimals, image, coingecko }) => {
+        const ticker = symbol?.trim();
+        if (!ticker)
+            return [];
+        return [
+            {
+                address: tonAddressToRawKey(address),
+                symbol: ticker,
+                ...(name ? { name } : {}),
+                ...(typeof decimals === 'number' ? { decimals } : {}),
+                ...(image ? { logo: image } : {}),
+                ...(coingecko ? { priceProviderId: coingecko } : {}),
+            },
+        ];
+    });
+};
+// Only a successful fetch is cached: a rejected promise is never stored, so an
+// outage is retried on the next call instead of pinning the degraded registry.
+const getFullRegistry = memoizeAsync(async () => makeTonVerifiedJettonRegistry([...getCuratedJettons(), ...(await fetchTonAssetsJettons())]), { cacheTime: convertDuration(1, 'h', 'ms') });
+let curatedRegistry;
+const getCuratedRegistry = () => {
+    if (!curatedRegistry) {
+        curatedRegistry = makeTonVerifiedJettonRegistry(getCuratedJettons());
+    }
+    return curatedRegistry;
+};
+/**
+ * The jettons we consider verified: our own curated TON tokens (which win, so
+ * their tickers and price ids are kept) merged with the ton-assets whitelist.
+ * Degrades to the curated list alone when the whitelist cannot be fetched, so
+ * discovery and labels keep working offline — with fewer jettons recognised.
+ */
+export const getTonVerifiedJettonRegistry = async () => {
+    const result = await attempt(getFullRegistry());
+    if ('data' in result && result.data)
+        return result.data;
+    console.warn('[ton] verified jetton list unavailable; using the curated list only', result.error);
+    return getCuratedRegistry();
+};
+//# sourceMappingURL=verifiedRegistry.js.map

package/dist/chains/ton/jetton/verifiedRegistry.js.map

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

package/dist/chains/ton/wallet.d.ts

@@ -0,0 +1,50 @@
+import { PublicKey, WalletCore } from '@trustwallet/wallet-core/dist/src/wallet-core';
+import { tonV5R1WalletId } from '@vultisig/core-chain/chains/ton/walletV5R1';
+/**
+ * The wallet contracts a Vultisig TON account can live in. The same Ed25519
+ * key yields a different address under each, so they are different accounts.
+ */
+export declare const tonWalletVersions: readonly ["v4r2", "v5r1"];
+export type TonWalletVersion = (typeof tonWalletVersions)[number];
+/**
+ * The contract every Vultisig TON address has been derived from so far. W5 is
+ * an explicit opt-in: switching a key's default would silently move the user
+ * to an empty account.
+ */
+export declare const defaultTonWalletVersion: TonWalletVersion;
+export { tonV5R1WalletId };
+/**
+ * How many outgoing messages one external request may carry. V4 is limited by
+ * the wallet code; W5 by the 255-entry action list.
+ */
+export declare const tonMaxMessagesPerRequest: Record<TonWalletVersion, number>;
+type DeriveTonAddressInput = {
+    publicKey: PublicKey;
+    walletCore: WalletCore;
+    version: TonWalletVersion;
+};
+/**
+ * The user-friendly, non-bounceable (`UQ…`) address of this key's wallet
+ * under the given contract. V4R2 is WalletCore's own TON derivation; W5 is the
+ * hash of the StateInit the contract is deployed from, built with `@ton/core`
+ * from the key bytes alone — no WalletCore feature beyond the public key, so it
+ * also works on React Native, whose native bridge exposes no `TONWallet`.
+ */
+export declare const deriveTonAddress: ({ publicKey, walletCore, version }: DeriveTonAddressInput) => string;
+type ResolveTonWalletVersionInput = {
+    address: string;
+    publicKey: PublicKey;
+    walletCore: WalletCore;
+};
+/**
+ * Which wallet contract an address is, for this key.
+ *
+ * The keysign payload carries no wallet-version field, so the sender address
+ * is the contract's identity: every co-signer derives both candidate addresses
+ * from the shared vault key and matches. An address that is neither is refused
+ * rather than assumed V4R2 — signing a V4R2 request for a wallet that is not
+ * one would either be rejected on chain or, worse, accepted by a contract we
+ * never meant to drive.
+ */
+export declare const resolveTonWalletVersion: ({ address, publicKey, walletCore }: ResolveTonWalletVersionInput) => "v4r2" | "v5r1";
+//# sourceMappingURL=wallet.d.ts.map

package/dist/chains/ton/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../../../../../packages/core/chain/chains/ton/wallet.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,+CAA+C,CAAA;AACrF,OAAO,EAAqB,eAAe,EAAE,MAAM,4CAA4C,CAAA;AAG/F;;;GAGG;AACH,eAAO,MAAM,iBAAiB,2BAA4B,CAAA;AAE1D,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEjE;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,gBAAyB,CAAA;AAE/D,OAAO,EAAE,eAAe,EAAE,CAAA;AAE1B;;;GAGG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAA0B,CAAA;AAEhG,KAAK,qBAAqB,GAAG;IAC3B,SAAS,EAAE,SAAS,CAAA;IACpB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,gBAAgB,CAAA;CAC1B,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,oCAAoC,qBAAqB,KAAG,MASzF,CAAA;AAEJ,KAAK,4BAA4B,GAAG;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,SAAS,CAAA;IACpB,UAAU,EAAE,UAAU,CAAA;CACvB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,GAAI,oCAAoC,4BAA4B,oBAcvG,CAAA"}