@chainlink/ccip-sdk 0.91.1 → 0.92.0

package/dist/errors/specialized.js

@@ -0,0 +1,1298 @@
+import { CCIPError } from "./CCIPError.js";
+import { CCIPErrorCode } from "./codes.js";
+// Chain/Network
+/** Thrown when chain not found by chainId, selector, or name. */
+export class CCIPChainNotFoundError extends CCIPError {
+    name = 'CCIPChainNotFoundError';
+    /** Creates a chain not found error. */
+    constructor(chainIdOrSelector, options) {
+        super(CCIPErrorCode.CHAIN_NOT_FOUND, `Chain not found: ${chainIdOrSelector}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, chainIdOrSelector },
+        });
+    }
+}
+/** Thrown when chain family is not supported. */
+export class CCIPChainFamilyUnsupportedError extends CCIPError {
+    name = 'CCIPChainFamilyUnsupportedError';
+    /** Creates a chain family unsupported error. */
+    constructor(family, options) {
+        super(CCIPErrorCode.CHAIN_FAMILY_UNSUPPORTED, `Unsupported chain family: ${family}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, family },
+        });
+    }
+}
+// Block & Transaction
+/** Thrown when block not found. Transient: block may not be indexed yet. */
+export class CCIPBlockNotFoundError extends CCIPError {
+    name = 'CCIPBlockNotFoundError';
+    /** Creates a block not found error. */
+    constructor(block, options) {
+        super(CCIPErrorCode.BLOCK_NOT_FOUND, `Block not found: ${block}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 12000,
+            context: { ...options?.context, block },
+        });
+    }
+}
+/** Thrown when transaction not found. Transient: tx may be pending. */
+export class CCIPTransactionNotFoundError extends CCIPError {
+    name = 'CCIPTransactionNotFoundError';
+    /** Creates a transaction not found error. */
+    constructor(hash, options) {
+        super(CCIPErrorCode.TRANSACTION_NOT_FOUND, `Transaction not found: ${hash}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 5000,
+            context: { ...options?.context, hash },
+        });
+    }
+}
+// CCIP Message
+/** Thrown when message format is invalid. */
+export class CCIPMessageInvalidError extends CCIPError {
+    name = 'CCIPMessageInvalidError';
+    /** Creates a message invalid error. */
+    constructor(data, options) {
+        const dataStr = typeof data === 'object' && data !== null ? JSON.stringify(data) : String(data);
+        super(CCIPErrorCode.MESSAGE_INVALID, `Invalid CCIP message format: ${dataStr}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, data },
+        });
+    }
+}
+/** Thrown when no CCIPSendRequested event in tx. Transient: tx may not be indexed. */
+export class CCIPMessageNotFoundInTxError extends CCIPError {
+    name = 'CCIPMessageNotFoundInTxError';
+    /** Creates a message not found in transaction error. */
+    constructor(txHash, options) {
+        super(CCIPErrorCode.MESSAGE_NOT_FOUND_IN_TX, `Could not find any CCIPSendRequested message in tx: ${txHash}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 30000,
+            context: { ...options?.context, txHash },
+        });
+    }
+}
+/** Thrown when message with messageId not found. Transient: message may be in transit. */
+export class CCIPMessageIdNotFoundError extends CCIPError {
+    name = 'CCIPMessageIdNotFoundError';
+    /** Creates a message ID not found error. */
+    constructor(messageId, options) {
+        super(CCIPErrorCode.MESSAGE_ID_NOT_FOUND, `Could not find a CCIPSendRequested message with messageId: ${messageId}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 30000,
+            context: { ...options?.context, messageId },
+        });
+    }
+}
+/** Thrown when not all messages in batch were found. Transient: may still be indexing. */
+export class CCIPMessageBatchIncompleteError extends CCIPError {
+    name = 'CCIPMessageBatchIncompleteError';
+    /** Creates a message batch incomplete error. */
+    constructor(seqNumRange, foundSeqNums, options) {
+        super(CCIPErrorCode.MESSAGE_BATCH_INCOMPLETE, `Could not find all messages in batch [${seqNumRange.min}..${seqNumRange.max}], got=[${foundSeqNums.join(',')}]`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 30000,
+            context: { ...options?.context, seqNumRange, foundSeqNums },
+        });
+    }
+}
+/** Thrown when message not in expected batch. */
+export class CCIPMessageNotInBatchError extends CCIPError {
+    name = 'CCIPMessageNotInBatchError';
+    /** Creates a message not in batch error. */
+    constructor(messageId, seqNumRange, options) {
+        super(CCIPErrorCode.MESSAGE_NOT_IN_BATCH, `Could not find ${messageId} in batch seqNums=[${seqNumRange.min}..${seqNumRange.max}]`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, messageId, seqNumRange },
+        });
+    }
+}
+// Lane & Routing
+/** Thrown when no offRamp found for lane. */
+export class CCIPOffRampNotFoundError extends CCIPError {
+    name = 'CCIPOffRampNotFoundError';
+    /** Creates an offRamp not found error. */
+    constructor(onRamp, destNetwork, options) {
+        super(CCIPErrorCode.OFFRAMP_NOT_FOUND, `No matching offRamp found for "${onRamp}" on "${destNetwork}"`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, onRamp, destNetwork },
+        });
+    }
+}
+/** Thrown when onRamp required but not provided. */
+export class CCIPOnRampRequiredError extends CCIPError {
+    name = 'CCIPOnRampRequiredError';
+    /** Creates an onRamp required error. */
+    constructor(options) {
+        super(CCIPErrorCode.ONRAMP_REQUIRED, 'onRamp address is required for this operation', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+// Commit & Merkle
+/** Thrown when commit report not found. Transient: DON may not have committed yet. */
+export class CCIPCommitNotFoundError extends CCIPError {
+    name = 'CCIPCommitNotFoundError';
+    /** Creates a commit not found error. */
+    constructor(startBlock, sequenceNumber, options) {
+        super(CCIPErrorCode.COMMIT_NOT_FOUND, `Could not find commit after ${startBlock} for sequenceNumber=${sequenceNumber}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 60000,
+            context: { ...options?.context, startBlock, sequenceNumber },
+        });
+    }
+}
+/** Thrown when merkle root verification fails. */
+export class CCIPMerkleRootMismatchError extends CCIPError {
+    name = 'CCIPMerkleRootMismatchError';
+    /** Creates a merkle root mismatch error. */
+    constructor(expected, got, options) {
+        super(CCIPErrorCode.MERKLE_ROOT_MISMATCH, `Merkle root created from send events doesn't match ReportAccepted merkle root: expected=${expected}, got=${got}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, expected, got },
+        });
+    }
+}
+/** Thrown when attempting to create tree without leaves. */
+export class CCIPMerkleTreeEmptyError extends CCIPError {
+    name = 'CCIPMerkleTreeEmptyError';
+    /** Creates a merkle tree empty error. */
+    constructor(options) {
+        super(CCIPErrorCode.MERKLE_TREE_EMPTY, 'Cannot construct merkle tree: no leaf hashes provided', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+// Version
+/** Thrown when CCIP version not supported. */
+export class CCIPVersionUnsupportedError extends CCIPError {
+    name = 'CCIPVersionUnsupportedError';
+    /** Creates a version unsupported error. */
+    constructor(version, options) {
+        super(CCIPErrorCode.VERSION_UNSUPPORTED, `Unsupported version: ${version}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, version },
+        });
+    }
+}
+/** Thrown when hasher version not supported for chain. */
+export class CCIPHasherVersionUnsupportedError extends CCIPError {
+    name = 'CCIPHasherVersionUnsupportedError';
+    /** Creates a hasher version unsupported error. */
+    constructor(chain, version, options) {
+        super(CCIPErrorCode.HASHER_VERSION_UNSUPPORTED, `Unsupported hasher version for ${chain}: ${version}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, chain, version },
+        });
+    }
+}
+// ExtraArgs
+/** Thrown when extraArgs cannot be parsed. */
+export class CCIPExtraArgsParseError extends CCIPError {
+    name = 'CCIPExtraArgsParseError';
+    /** Creates an extraArgs parse error. */
+    constructor(from, options) {
+        super(CCIPErrorCode.EXTRA_ARGS_PARSE_FAILED, `Could not parse extraArgs from "${from}"`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, from },
+        });
+    }
+}
+/**
+ * Thrown when extraArgs format invalid for chain family.
+ *
+ * @param chainFamily - Display name for the chain family (user-facing, differs from ChainFamily enum)
+ * @param extraArgs - The actual invalid extraArgs value (for debugging)
+ */
+export class CCIPExtraArgsInvalidError extends CCIPError {
+    name = 'CCIPExtraArgsInvalidError';
+    /** Creates an extraArgs invalid error. */
+    constructor(chainFamily, extraArgs, options) {
+        const ERROR_CODE_MAP = {
+            EVM: CCIPErrorCode.EXTRA_ARGS_INVALID_EVM,
+            SVM: CCIPErrorCode.EXTRA_ARGS_INVALID_SVM,
+            Sui: CCIPErrorCode.EXTRA_ARGS_INVALID_SUI,
+            Aptos: CCIPErrorCode.EXTRA_ARGS_INVALID_APTOS,
+            TON: CCIPErrorCode.EXTRA_ARGS_INVALID_TON,
+        };
+        const code = ERROR_CODE_MAP[chainFamily];
+        const message = extraArgs
+            ? `Invalid extraArgs "${extraArgs}" for ${chainFamily}`
+            : `Invalid extraArgs for ${chainFamily}`;
+        super(code, message, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, chainFamily, extraArgs },
+        });
+    }
+}
+// Token & Registry
+/** Thrown when token not found in registry. */
+export class CCIPTokenNotInRegistryError extends CCIPError {
+    name = 'CCIPTokenNotInRegistryError';
+    /** Creates a token not in registry error. */
+    constructor(token, registry, options) {
+        super(CCIPErrorCode.TOKEN_NOT_IN_REGISTRY, `Token=${token} not found in registry=${registry}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, token, registry },
+        });
+    }
+}
+/** Thrown when token not configured in registry. */
+export class CCIPTokenNotConfiguredError extends CCIPError {
+    name = 'CCIPTokenNotConfiguredError';
+    /** Creates a token not configured error. */
+    constructor(token, registry, options) {
+        super(CCIPErrorCode.TOKEN_NOT_CONFIGURED, `Token ${token} is not configured in registry ${registry}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, token, registry },
+        });
+    }
+}
+/** Thrown when destination token decimals insufficient. */
+export class CCIPTokenDecimalsInsufficientError extends CCIPError {
+    name = 'CCIPTokenDecimalsInsufficientError';
+    /** Creates a token decimals insufficient error. */
+    constructor(token, destDecimals, destChain, amount, options) {
+        super(CCIPErrorCode.TOKEN_DECIMALS_INSUFFICIENT, `not enough decimals=${destDecimals} for token=${token} on dest=${destChain} to express ${amount}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, token, destDecimals, destChain, amount },
+        });
+    }
+}
+// Contract Type
+/** Thrown when contract type is not as expected. */
+export class CCIPContractTypeInvalidError extends CCIPError {
+    name = 'CCIPContractTypeInvalidError';
+    /** Creates a contract type invalid error. */
+    constructor(address, actualType, expectedTypes, options) {
+        super(CCIPErrorCode.CONTRACT_TYPE_INVALID, `Not a ${expectedTypes.join(', ')}: ${address} is "${actualType}"`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, address, actualType, expectedTypes },
+        });
+    }
+}
+// Wallet & Signer
+/** Thrown when wallet must be Signer but isn't. */
+export class CCIPWalletNotSignerError extends CCIPError {
+    name = 'CCIPWalletNotSignerError';
+    /** Creates a wallet not signer error. */
+    constructor(wallet, options) {
+        super(CCIPErrorCode.WALLET_NOT_SIGNER, `Wallet must be a Signer, got=${typeof wallet}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, walletType: typeof wallet },
+        });
+    }
+}
+// Execution
+/** Thrown when exec tx not confirmed. Transient: may need more time. */
+export class CCIPExecTxNotConfirmedError extends CCIPError {
+    name = 'CCIPExecTxNotConfirmedError';
+    /** Creates an exec transaction not confirmed error. */
+    constructor(txHash, options) {
+        super(CCIPErrorCode.EXEC_TX_NOT_CONFIRMED, `Could not confirm exec tx: ${txHash}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 5000,
+            context: { ...options?.context, txHash },
+        });
+    }
+}
+/** Thrown when exec tx reverted. */
+export class CCIPExecTxRevertedError extends CCIPError {
+    name = 'CCIPExecTxRevertedError';
+    /** Creates an exec transaction reverted error. */
+    constructor(txHash, options) {
+        super(CCIPErrorCode.EXEC_TX_REVERTED, `Exec transaction reverted: ${txHash}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, txHash },
+        });
+    }
+}
+// Attestation (USDC/LBTC)
+/** Thrown when USDC attestation fetch fails. Transient: attestation may not be ready. */
+export class CCIPUsdcAttestationError extends CCIPError {
+    name = 'CCIPUsdcAttestationError';
+    /** Creates a USDC attestation error. */
+    constructor(messageHash, response, options) {
+        super(CCIPErrorCode.USDC_ATTESTATION_FAILED, `Could not fetch USDC attestation for hash: ${messageHash}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 10000,
+            context: { ...options?.context, messageHash, response },
+        });
+    }
+}
+/** Thrown when LBTC attestation fetch fails. Transient: attestation may not be ready. */
+export class CCIPLbtcAttestationError extends CCIPError {
+    name = 'CCIPLbtcAttestationError';
+    /** Creates an LBTC attestation error. */
+    constructor(response, options) {
+        super(CCIPErrorCode.LBTC_ATTESTATION_ERROR, `Error while fetching LBTC attestation. Response: ${JSON.stringify(response)}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 10000,
+            context: { ...options?.context, response },
+        });
+    }
+}
+/** Thrown when LBTC attestation not found for payload hash. Transient: may not be processed yet. */
+export class CCIPLbtcAttestationNotFoundError extends CCIPError {
+    name = 'CCIPLbtcAttestationNotFoundError';
+    /** Creates an LBTC attestation not found error. */
+    constructor(payloadHash, response, options) {
+        super(CCIPErrorCode.LBTC_ATTESTATION_NOT_FOUND, `Could not find LBTC attestation for hash: ${payloadHash}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 30000,
+            context: { ...options?.context, payloadHash, response },
+        });
+    }
+}
+/** Thrown when LBTC attestation is not yet approved. Transient: may be pending notarization. */
+export class CCIPLbtcAttestationNotApprovedError extends CCIPError {
+    name = 'CCIPLbtcAttestationNotApprovedError';
+    /** Creates an LBTC attestation not approved error. */
+    constructor(payloadHash, attestation, options) {
+        super(CCIPErrorCode.LBTC_ATTESTATION_NOT_APPROVED, `LBTC attestation not yet approved for hash: ${payloadHash}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 30000,
+            context: { ...options?.context, payloadHash, attestation },
+        });
+    }
+}
+// Solana
+/** Thrown when lookup table not found. Transient: may not be synced yet. */
+export class CCIPSolanaLookupTableNotFoundError extends CCIPError {
+    name = 'CCIPSolanaLookupTableNotFoundError';
+    /** Creates a Solana lookup table not found error. */
+    constructor(address, options) {
+        super(CCIPErrorCode.SOLANA_LOOKUP_TABLE_NOT_FOUND, `Lookup table account not found: ${address}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 5000,
+            context: { ...options?.context, address },
+        });
+    }
+}
+// Aptos
+/** Thrown for invalid Aptos transaction hash or version. */
+export class CCIPAptosTransactionInvalidError extends CCIPError {
+    name = 'CCIPAptosTransactionInvalidError';
+    /** Creates an Aptos transaction invalid error. */
+    constructor(hashOrVersion, options) {
+        super(CCIPErrorCode.APTOS_TX_INVALID, `Invalid transaction hash or version: ${hashOrVersion}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, hashOrVersion },
+        });
+    }
+}
+// HTTP & Data
+/** Thrown for HTTP errors. Transient if 429 or 5xx. */
+export class CCIPHttpError extends CCIPError {
+    name = 'CCIPHttpError';
+    /** Creates an HTTP error. */
+    constructor(status, statusText, options) {
+        super(CCIPErrorCode.HTTP_ERROR, `HTTP ${status}: ${statusText}`, {
+            ...options,
+            isTransient: status === 429 || status >= 500,
+            context: { ...options?.context, status, statusText },
+        });
+    }
+}
+/** Thrown for not implemented features. */
+export class CCIPNotImplementedError extends CCIPError {
+    name = 'CCIPNotImplementedError';
+    /** Creates a not implemented error. */
+    constructor(feature, options) {
+        super(CCIPErrorCode.NOT_IMPLEMENTED, feature ? `Not implemented: ${feature}` : 'Not implemented', {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, feature },
+        });
+    }
+}
+// Data Format & Parsing
+/** Thrown when data format is not supported. */
+export class CCIPDataFormatUnsupportedError extends CCIPError {
+    name = 'CCIPDataFormatUnsupportedError';
+    /** Creates a data format unsupported error. */
+    constructor(data, options) {
+        super(CCIPErrorCode.DATA_FORMAT_UNSUPPORTED, `Unsupported data format: ${String(data)}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, data },
+        });
+    }
+}
+/** Thrown when typeAndVersion string cannot be parsed. */
+export class CCIPTypeVersionInvalidError extends CCIPError {
+    name = 'CCIPTypeVersionInvalidError';
+    /** Creates a type version invalid error. */
+    constructor(typeAndVersion, options) {
+        super(CCIPErrorCode.TYPE_VERSION_INVALID, `Invalid typeAndVersion: "${typeAndVersion}"`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, typeAndVersion },
+        });
+    }
+}
+/** Thrown when no block found before timestamp. */
+export class CCIPBlockBeforeTimestampNotFoundError extends CCIPError {
+    name = 'CCIPBlockBeforeTimestampNotFoundError';
+    /** Creates a block before timestamp not found error. */
+    constructor(timestamp, options) {
+        super(CCIPErrorCode.BLOCK_BEFORE_TIMESTAMP_NOT_FOUND, `Could not find a block prior to timestamp=${timestamp}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, timestamp },
+        });
+    }
+}
+/** Thrown when message decoding fails. */
+export class CCIPMessageDecodeError extends CCIPError {
+    name = 'CCIPMessageDecodeError';
+    /** Creates a message decode error. */
+    constructor(reason, options) {
+        super(CCIPErrorCode.MESSAGE_DECODE_FAILED, reason ? `Failed to decode message: ${reason}` : 'Failed to decode message', {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, reason },
+        });
+    }
+}
+/** Thrown when network family is not supported for an operation. */
+export class CCIPNetworkFamilyUnsupportedError extends CCIPError {
+    name = 'CCIPNetworkFamilyUnsupportedError';
+    /** Creates a network family unsupported error. */
+    constructor(family, options) {
+        super(CCIPErrorCode.NETWORK_FAMILY_UNSUPPORTED, `Unsupported network family: ${family}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, family },
+        });
+    }
+}
+/** Thrown when RPC endpoint not found. */
+export class CCIPRpcNotFoundError extends CCIPError {
+    name = 'CCIPRpcNotFoundError';
+    /** Creates an RPC not found error. */
+    constructor(chainId, options) {
+        super(CCIPErrorCode.RPC_NOT_FOUND, `No RPC found for chainId=${chainId}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, chainId },
+        });
+    }
+}
+/** Thrown when logs not found for filter criteria. */
+export class CCIPLogsNotFoundError extends CCIPError {
+    name = 'CCIPLogsNotFoundError';
+    /** Creates a logs not found error. */
+    constructor(filter, options) {
+        super(CCIPErrorCode.LOGS_NOT_FOUND, 'No logs found matching the filter criteria', {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 5000,
+            context: { ...options?.context, filter },
+        });
+    }
+}
+/** Thrown when log topics not found. */
+export class CCIPLogTopicsNotFoundError extends CCIPError {
+    name = 'CCIPLogTopicsNotFoundError';
+    /** Creates a log topics not found error. */
+    constructor(topics, options) {
+        super(CCIPErrorCode.LOG_TOPICS_NOT_FOUND, `Could not find matching topics: ${String(topics)}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, topics },
+        });
+    }
+}
+/** Thrown when trying to `watch` logs but giving a fixed `endBlock` */
+export class CCIPLogsWatchRequiresFinalityError extends CCIPError {
+    name = 'CCIPLogsWatchRequiresFinalityError';
+    /** Creates a block not found error. */
+    constructor(endBlock, options) {
+        super(CCIPErrorCode.LOGS_WATCH_REQUIRES_FINALITY, `Watch mode requires finality config for endBlock (latest, finalized or block depth=negative)`, { ...options, isTransient: false, context: { ...options?.context, endBlock } });
+    }
+}
+/** Thrown when trying to `watch` logs but giving a fixed `endBlock` */
+export class CCIPLogsWatchRequiresStartError extends CCIPError {
+    name = 'CCIPLogsWatchRequiresStartError';
+    /** Creates a block not found error. */
+    constructor(options) {
+        super(CCIPErrorCode.LOGS_WATCH_REQUIRES_START, `Watch mode requires startBlock or startTime`, {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when address is required for logs filtering, but not provided. */
+export class CCIPLogsAddressRequiredError extends CCIPError {
+    name = 'CCIPLogsAddressRequiredError';
+    /** Creates a Solana program address required error. */
+    constructor(options) {
+        super(CCIPErrorCode.LOGS_ADDRESS_REQUIRED, 'Address is required for logs filtering', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+// Chain Family
+/** Thrown when network family does not match expected for a Chain constructor. */
+export class CCIPChainFamilyMismatchError extends CCIPError {
+    name = 'CCIPChainFamilyMismatchError';
+    /** Creates a chain family mismatch error. */
+    constructor(chainName, expected, actual, options) {
+        super(CCIPErrorCode.CHAIN_FAMILY_MISMATCH, `Invalid network family for ${chainName}: expected ${expected}, got ${actual}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, chainName, expected, actual },
+        });
+    }
+}
+// Token Pool
+/** Thrown when legacy (pre-1.5) token pools are not supported. */
+export class CCIPLegacyTokenPoolsUnsupportedError extends CCIPError {
+    name = 'CCIPLegacyTokenPoolsUnsupportedError';
+    /** Creates a legacy token pools unsupported error. */
+    constructor(options) {
+        super(CCIPErrorCode.LEGACY_TOKEN_POOLS_UNSUPPORTED, 'Legacy <1.5 token pools not supported', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+// Merkle Validation
+/** Thrown when merkle proof is empty. */
+export class CCIPMerkleProofEmptyError extends CCIPError {
+    name = 'CCIPMerkleProofEmptyError';
+    /** Creates a merkle proof empty error. */
+    constructor(options) {
+        super(CCIPErrorCode.MERKLE_PROOF_EMPTY, 'Cannot verify merkle proof: leaves and proofs are empty', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when merkle leaves or proofs exceed max limit. */
+export class CCIPMerkleProofTooLargeError extends CCIPError {
+    name = 'CCIPMerkleProofTooLargeError';
+    /** Creates a merkle proof too large error. */
+    constructor(limit, options) {
+        super(CCIPErrorCode.MERKLE_PROOF_TOO_LARGE, `Leaves or proofs exceed limit of ${limit}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, limit },
+        });
+    }
+}
+/** Thrown when total hashes exceed max merkle tree size. */
+export class CCIPMerkleHashesTooLargeError extends CCIPError {
+    name = 'CCIPMerkleHashesTooLargeError';
+    /** Creates a merkle hashes too large error. */
+    constructor(totalHashes, limit, options) {
+        super(CCIPErrorCode.MERKLE_HASHES_TOO_LARGE, `Total hashes ${totalHashes} exceeds limit ${limit}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, totalHashes, limit },
+        });
+    }
+}
+/** Thrown when source flags count does not match expected total. */
+export class CCIPMerkleFlagsMismatchError extends CCIPError {
+    name = 'CCIPMerkleFlagsMismatchError';
+    /** Creates a merkle flags mismatch error. */
+    constructor(totalHashes, flagsLength, options) {
+        super(CCIPErrorCode.MERKLE_FLAGS_MISMATCH, `Hashes ${totalHashes} != sourceFlags ${flagsLength}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, totalHashes, flagsLength },
+        });
+    }
+}
+/** Thrown when proof source flags count does not match proof hashes. */
+export class CCIPMerkleProofFlagsMismatchError extends CCIPError {
+    name = 'CCIPMerkleProofFlagsMismatchError';
+    /** Creates a merkle proof flags mismatch error. */
+    constructor(sourceProofCount, proofsLength, options) {
+        super(CCIPErrorCode.MERKLE_PROOF_FLAGS_MISMATCH, `Proof source flags ${sourceProofCount} != proof hashes ${proofsLength}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, sourceProofCount, proofsLength },
+        });
+    }
+}
+/** Thrown when not all proofs were consumed during verification. */
+export class CCIPMerkleProofIncompleteError extends CCIPError {
+    name = 'CCIPMerkleProofIncompleteError';
+    /** Creates a merkle proof incomplete error. */
+    constructor(options) {
+        super(CCIPErrorCode.MERKLE_PROOF_INCOMPLETE, 'Merkle verification failed: not all proofs were consumed', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown on internal merkle computation error. */
+export class CCIPMerkleInternalError extends CCIPError {
+    name = 'CCIPMerkleInternalError';
+    /** Creates a merkle internal error. */
+    constructor(message, options) {
+        super(CCIPErrorCode.MERKLE_INTERNAL_ERROR, message, {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+// Address Validation
+/** Thrown when EVM address is invalid. */
+export class CCIPAddressInvalidEvmError extends CCIPError {
+    name = 'CCIPAddressInvalidEvmError';
+    /** Creates an EVM address invalid error. */
+    constructor(address, options) {
+        super(CCIPErrorCode.ADDRESS_INVALID_EVM, `Invalid EVM address: ${address}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, address },
+        });
+    }
+}
+// Version Requirements
+/** Thrown when CCIP version requires lane info. */
+export class CCIPVersionRequiresLaneError extends CCIPError {
+    name = 'CCIPVersionRequiresLaneError';
+    /** Creates a version requires lane error. */
+    constructor(version, options) {
+        super(CCIPErrorCode.VERSION_REQUIRES_LANE, `Decoding commits from CCIP ${version} requires lane`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, version },
+        });
+    }
+}
+/** Thrown when version feature is unavailable. */
+export class CCIPVersionFeatureUnavailableError extends CCIPError {
+    name = 'CCIPVersionFeatureUnavailableError';
+    /** Creates a version feature unavailable error. */
+    constructor(feature, version, minVersion, options) {
+        const msg = minVersion
+            ? `${feature} requires version >= ${minVersion}, got ${version}`
+            : `${feature} not available in version ${version}`;
+        super(CCIPErrorCode.VERSION_FEATURE_UNAVAILABLE, msg, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, feature, version, minVersion },
+        });
+    }
+}
+// Contract Validation
+/** Thrown when contract is not a Router or expected CCIP contract. */
+export class CCIPContractNotRouterError extends CCIPError {
+    name = 'CCIPContractNotRouterError';
+    /** Creates a contract not router error. */
+    constructor(address, typeAndVersion, options) {
+        super(CCIPErrorCode.CONTRACT_NOT_ROUTER, `Not a Router, Ramp or expected contract: ${address} is "${typeAndVersion}"`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, address, typeAndVersion },
+        });
+    }
+}
+// Log Data
+/** Thrown when log data is invalid. */
+export class CCIPLogDataInvalidError extends CCIPError {
+    name = 'CCIPLogDataInvalidError';
+    /** Creates a log data invalid error. */
+    constructor(data, options) {
+        super(CCIPErrorCode.LOG_DATA_INVALID, `Invalid log data: ${String(data)}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, data },
+        });
+    }
+}
+// Wallet
+/** Thrown when wallet is not a valid signer. */
+export class CCIPWalletInvalidError extends CCIPError {
+    name = 'CCIPWalletInvalidError';
+    /** Creates a wallet invalid error. */
+    constructor(wallet, options) {
+        super(CCIPErrorCode.WALLET_INVALID, `Wallet must be a Signer, got ${String(wallet)}`, {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+// Source Chain
+/** Thrown when source chain is unsupported for EVM hasher. */
+export class CCIPSourceChainUnsupportedError extends CCIPError {
+    name = 'CCIPSourceChainUnsupportedError';
+    /** Creates a source chain unsupported error. */
+    constructor(chainSelector, options) {
+        super(CCIPErrorCode.SOLANA_SOURCE_CHAIN_UNSUPPORTED, `Unsupported source chain: ${chainSelector}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, chainSelector: String(chainSelector) },
+        });
+    }
+}
+// Solana-specific errors
+/** Thrown when block time cannot be retrieved for a slot. */
+export class CCIPBlockTimeNotFoundError extends CCIPError {
+    name = 'CCIPBlockTimeNotFoundError';
+    /** Creates a block time not found error. */
+    constructor(block, options) {
+        super(CCIPErrorCode.BLOCK_TIME_NOT_FOUND, `Could not get block time for slot ${block}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 5000,
+            context: { ...options?.context, block },
+        });
+    }
+}
+/** Thrown when Solana topics are not valid strings. */
+export class CCIPSolanaTopicsInvalidError extends CCIPError {
+    name = 'CCIPSolanaTopicsInvalidError';
+    /** Creates a Solana topics invalid error. */
+    constructor(options) {
+        super(CCIPErrorCode.SOLANA_TOPICS_INVALID, 'Solana event topics must be string values', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when reference addresses account not found for offRamp. */
+export class CCIPSolanaRefAddressesNotFoundError extends CCIPError {
+    name = 'CCIPSolanaRefAddressesNotFoundError';
+    /** Creates a reference addresses not found error. */
+    constructor(offRamp, options) {
+        super(CCIPErrorCode.SOLANA_REF_ADDRESSES_NOT_FOUND, `referenceAddresses account not found for offRamp=${offRamp}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 5000,
+            context: { ...options?.context, offRamp },
+        });
+    }
+}
+/** Thrown when OffRamp events not found in feeQuoter transactions. */
+export class CCIPSolanaOffRampEventsNotFoundError extends CCIPError {
+    name = 'CCIPSolanaOffRampEventsNotFoundError';
+    /** Creates an offRamp events not found error. */
+    constructor(feeQuoter, options) {
+        super(CCIPErrorCode.SOLANA_OFFRAMP_EVENTS_NOT_FOUND, `Could not find OffRamp events in feeQuoter=${feeQuoter} txs`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 10000,
+            context: { ...options?.context, feeQuoter },
+        });
+    }
+}
+/** Thrown when token pool info not found. */
+export class CCIPTokenPoolInfoNotFoundError extends CCIPError {
+    name = 'CCIPTokenPoolInfoNotFoundError';
+    /** Creates a token pool info not found error. */
+    constructor(tokenPool, options) {
+        super(CCIPErrorCode.TOKEN_POOL_INFO_NOT_FOUND, `TokenPool info not found: ${tokenPool}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, tokenPool },
+        });
+    }
+}
+/** Thrown when SPL token is invalid or not Token-2022. */
+export class CCIPSplTokenInvalidError extends CCIPError {
+    name = 'CCIPSplTokenInvalidError';
+    /** Creates an SPL token invalid error. */
+    constructor(token, options) {
+        super(CCIPErrorCode.TOKEN_INVALID_SPL, `Invalid SPL token or Token-2022: ${token}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, token },
+        });
+    }
+}
+/** Thrown when token data cannot be parsed. */
+export class CCIPTokenDataParseError extends CCIPError {
+    name = 'CCIPTokenDataParseError';
+    /** Creates a token data parse error. */
+    constructor(token, options) {
+        super(CCIPErrorCode.TOKEN_DATA_PARSE_FAILED, `Unable to parse token data for ${token}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, token },
+        });
+    }
+}
+/** Thrown when EVMExtraArgsV2 has unsupported length. */
+export class CCIPExtraArgsLengthInvalidError extends CCIPError {
+    name = 'CCIPExtraArgsLengthInvalidError';
+    /** Creates an extraArgs length invalid error. */
+    constructor(length, options) {
+        super(CCIPErrorCode.EXTRA_ARGS_LENGTH_INVALID, `Unsupported EVMExtraArgsV2 length: ${length}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, length },
+        });
+    }
+}
+/** Thrown when Solana can only encode EVMExtraArgsV2 but got different args. */
+export class CCIPSolanaExtraArgsEncodingError extends CCIPError {
+    name = 'CCIPSolanaExtraArgsEncodingError';
+    /** Creates a Solana extraArgs encoding error. */
+    constructor(options) {
+        super(CCIPErrorCode.EXTRA_ARGS_SOLANA_EVM_ONLY, 'Solana extraArgs encoding only supports EVMExtraArgsV2 format', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when log data is missing or not a string. */
+export class CCIPLogDataMissingError extends CCIPError {
+    name = 'CCIPLogDataMissingError';
+    /** Creates a log data missing error. */
+    constructor(options) {
+        super(CCIPErrorCode.LOG_DATA_MISSING, 'Log data is missing or invalid: expected string value', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when ExecutionState is invalid. */
+export class CCIPExecutionStateInvalidError extends CCIPError {
+    name = 'CCIPExecutionStateInvalidError';
+    /** Creates an execution state invalid error. */
+    constructor(state, options) {
+        super(CCIPErrorCode.EXECUTION_STATE_INVALID, `Invalid ExecutionState: ${String(state)}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, state },
+        });
+    }
+}
+/** Thrown when execution report message is not for Solana. */
+export class CCIPExecutionReportChainMismatchError extends CCIPError {
+    name = 'CCIPExecutionReportChainMismatchError';
+    /** Creates an execution report chain mismatch error. */
+    constructor(chain, options) {
+        super(CCIPErrorCode.MESSAGE_CHAIN_MISMATCH, `ExecutionReport's message not for ${chain}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, chain },
+        });
+    }
+}
+/** Thrown when token pool state PDA not found. */
+export class CCIPTokenPoolStateNotFoundError extends CCIPError {
+    name = 'CCIPTokenPoolStateNotFoundError';
+    /** Creates a token pool state not found error. */
+    constructor(tokenPool, options) {
+        super(CCIPErrorCode.TOKEN_POOL_STATE_NOT_FOUND, `TokenPool State PDA not found at ${tokenPool}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, tokenPool },
+        });
+    }
+}
+/** Thrown when ChainConfig not found for token pool and remote chain. */
+export class CCIPTokenPoolChainConfigNotFoundError extends CCIPError {
+    name = 'CCIPTokenPoolChainConfigNotFoundError';
+    /** Creates a token pool chain config not found error. */
+    constructor(address, tokenPool, remoteNetwork, options) {
+        super(CCIPErrorCode.TOKEN_NOT_CONFIGURED, `ChainConfig not found at ${address} for tokenPool=${tokenPool} and remoteNetwork=${remoteNetwork}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, address, tokenPool, remoteNetwork },
+        });
+    }
+}
+// Aptos-specific errors
+/** Thrown when Aptos network is unknown. */
+export class CCIPAptosNetworkUnknownError extends CCIPError {
+    name = 'CCIPAptosNetworkUnknownError';
+    /** Creates an Aptos network unknown error. */
+    constructor(url, options) {
+        super(CCIPErrorCode.APTOS_NETWORK_UNKNOWN, `Unknown Aptos network: ${url}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, url },
+        });
+    }
+}
+/** Thrown when Aptos transaction type is invalid. */
+export class CCIPAptosTransactionTypeInvalidError extends CCIPError {
+    name = 'CCIPAptosTransactionTypeInvalidError';
+    /** Creates an Aptos transaction type invalid error. */
+    constructor(options) {
+        super(CCIPErrorCode.APTOS_TX_TYPE_INVALID, 'Invalid Aptos transaction type: expected user_transaction', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when Aptos registry type is invalid. */
+export class CCIPAptosRegistryTypeInvalidError extends CCIPError {
+    name = 'CCIPAptosRegistryTypeInvalidError';
+    /** Creates an Aptos registry type invalid error. */
+    constructor(registry, actualType, options) {
+        super(CCIPErrorCode.REGISTRY_TYPE_INVALID, `Expected ${registry} to have TokenAdminRegistry type, got=${actualType}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, registry, actualType },
+        });
+    }
+}
+/** Thrown when Aptos log data is invalid. */
+export class CCIPAptosLogInvalidError extends CCIPError {
+    name = 'CCIPAptosLogInvalidError';
+    /** Creates an Aptos log invalid error. */
+    constructor(log, options) {
+        super(CCIPErrorCode.LOG_APTOS_INVALID, `Invalid aptos log: ${String(log)}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, log },
+        });
+    }
+}
+/** Thrown when Aptos address is invalid. */
+export class CCIPAptosAddressInvalidError extends CCIPError {
+    name = 'CCIPAptosAddressInvalidError';
+    /** Creates an Aptos address invalid error. */
+    constructor(address, options) {
+        super(CCIPErrorCode.ADDRESS_INVALID_APTOS, `Invalid aptos address: "${address}"`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, address },
+        });
+    }
+}
+/** Thrown when Aptos can only encode specific extra args types. */
+export class CCIPAptosExtraArgsEncodingError extends CCIPError {
+    name = 'CCIPAptosExtraArgsEncodingError';
+    /** Creates an Aptos extraArgs encoding error. */
+    constructor(options) {
+        super(CCIPErrorCode.EXTRA_ARGS_APTOS_RESTRICTION, 'Aptos can only encode EVMExtraArgsV2 & SVMExtraArgsV1', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when Aptos wallet is invalid. */
+export class CCIPAptosWalletInvalidError extends CCIPError {
+    name = 'CCIPAptosWalletInvalidError';
+    /** Creates an Aptos wallet invalid error. */
+    constructor(className, wallet, options) {
+        super(CCIPErrorCode.WALLET_INVALID, `${className}.sendMessage requires an Aptos account wallet, got=${wallet}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, className, wallet },
+        });
+    }
+}
+/** Thrown when Aptos expects EVMExtraArgsV2 reports. */
+export class CCIPAptosExtraArgsV2RequiredError extends CCIPError {
+    name = 'CCIPAptosExtraArgsV2RequiredError';
+    /** Creates an Aptos EVMExtraArgsV2 required error. */
+    constructor(options) {
+        super(CCIPErrorCode.EXTRA_ARGS_APTOS_V2_REQUIRED, 'Aptos expects EVMExtraArgsV2 reports', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when token is not registered in Aptos registry. */
+export class CCIPAptosTokenNotRegisteredError extends CCIPError {
+    name = 'CCIPAptosTokenNotRegisteredError';
+    /** Creates an Aptos token not registered error. */
+    constructor(token, registry, options) {
+        super(CCIPErrorCode.TOKEN_NOT_REGISTERED, `Token=${token} not registered in registry=${registry}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, token, registry },
+        });
+    }
+}
+/** Thrown for unexpected Aptos transaction type. */
+export class CCIPAptosTransactionTypeUnexpectedError extends CCIPError {
+    name = 'CCIPAptosTransactionTypeUnexpectedError';
+    /** Creates an Aptos transaction type unexpected error. */
+    constructor(type, options) {
+        super(CCIPErrorCode.APTOS_TX_TYPE_UNEXPECTED, `Unexpected transaction type="${type}"`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, type },
+        });
+    }
+}
+/** Thrown when Aptos address with module is required. */
+export class CCIPAptosAddressModuleRequiredError extends CCIPError {
+    name = 'CCIPAptosAddressModuleRequiredError';
+    /** Creates an Aptos address module required error. */
+    constructor(options) {
+        super(CCIPErrorCode.APTOS_ADDRESS_MODULE_REQUIRED, 'Aptos address with module name is required for this operation', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when Aptos topic is invalid. */
+export class CCIPAptosTopicInvalidError extends CCIPError {
+    name = 'CCIPAptosTopicInvalidError';
+    /** Creates an Aptos topic invalid error. */
+    constructor(topic, options) {
+        super(CCIPErrorCode.APTOS_TOPIC_INVALID, topic ? `Unknown topic event handler="${topic}"` : 'single string topic required', {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, topic },
+        });
+    }
+}
+// Borsh
+/** Thrown when Borsh type is unknown. */
+export class CCIPBorshTypeUnknownError extends CCIPError {
+    name = 'CCIPBorshTypeUnknownError';
+    /** Creates a Borsh type unknown error. */
+    constructor(name, options) {
+        super(CCIPErrorCode.BORSH_TYPE_UNKNOWN, `Unknown type: ${name}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, name },
+        });
+    }
+}
+/** Thrown when Borsh method is unknown. */
+export class CCIPBorshMethodUnknownError extends CCIPError {
+    name = 'CCIPBorshMethodUnknownError';
+    /** Creates a Borsh method unknown error. */
+    constructor(method, options) {
+        super(CCIPErrorCode.BORSH_METHOD_UNKNOWN, `Unknown method: ${method}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, method },
+        });
+    }
+}
+// CLI & Validation
+/** Thrown when CLI argument is invalid. */
+export class CCIPArgumentInvalidError extends CCIPError {
+    name = 'CCIPArgumentInvalidError';
+    /** Creates an argument invalid error. */
+    constructor(argument, reason, options) {
+        super(CCIPErrorCode.ARGUMENT_INVALID, `Invalid argument "${argument}": ${reason}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, argument, reason },
+        });
+    }
+}
+/** Thrown when execution receipt not found in tx logs. Transient: receipt may not be indexed yet. */
+export class CCIPReceiptNotFoundError extends CCIPError {
+    name = 'CCIPReceiptNotFoundError';
+    /** Creates a receipt not found error. */
+    constructor(txHash, options) {
+        super(CCIPErrorCode.RECEIPT_NOT_FOUND, `Could not find receipt in tx logs: ${txHash}`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 5000,
+            context: { ...options?.context, txHash },
+        });
+    }
+}
+/** Thrown when data cannot be parsed. */
+export class CCIPDataParseError extends CCIPError {
+    name = 'CCIPDataParseError';
+    /** Creates a data parse error. */
+    constructor(data, options) {
+        const truncated = data.length > 66 ? `${data.slice(0, 66)}...` : data;
+        super(CCIPErrorCode.DATA_PARSE_FAILED, `Could not parse data: ${truncated}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, data },
+        });
+    }
+}
+/** Thrown when token not found in supported tokens list. */
+export class CCIPTokenNotFoundError extends CCIPError {
+    name = 'CCIPTokenNotFoundError';
+    /** Creates a token not found error. */
+    constructor(token, options) {
+        super(CCIPErrorCode.TOKEN_NOT_FOUND, `Token not found: ${token}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, token },
+        });
+    }
+}
+// Solana-specific (additional)
+/** Thrown when router config not found at PDA. */
+export class CCIPSolanaRouterConfigNotFoundError extends CCIPError {
+    name = 'CCIPSolanaRouterConfigNotFoundError';
+    /** Creates a Solana router config not found error. */
+    constructor(configPda, options) {
+        super(CCIPErrorCode.SOLANA_ROUTER_CONFIG_NOT_FOUND, `Router config not found at ${configPda}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, configPda },
+        });
+    }
+}
+/** Thrown when fee result from router is invalid. */
+export class CCIPSolanaFeeResultInvalidError extends CCIPError {
+    name = 'CCIPSolanaFeeResultInvalidError';
+    /** Creates a Solana fee result invalid error. */
+    constructor(result, options) {
+        super(CCIPErrorCode.SOLANA_FEE_RESULT_INVALID, `Invalid fee result from router: ${result}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, result },
+        });
+    }
+}
+/** Thrown when token mint not found. */
+export class CCIPTokenMintNotFoundError extends CCIPError {
+    name = 'CCIPTokenMintNotFoundError';
+    /** Creates a token mint not found error. */
+    constructor(token, options) {
+        super(CCIPErrorCode.TOKEN_MINT_NOT_FOUND, `Mint ${token} not found`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, token },
+        });
+    }
+}
+/** Thrown when token amount is invalid. */
+export class CCIPTokenAmountInvalidError extends CCIPError {
+    name = 'CCIPTokenAmountInvalidError';
+    /** Creates a token amount invalid error. */
+    constructor(options) {
+        super(CCIPErrorCode.TOKEN_AMOUNT_INVALID, 'Invalid token amount: token address and positive amount required', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when transaction not finalized after timeout. */
+export class CCIPTransactionNotFinalizedError extends CCIPError {
+    name = 'CCIPTransactionNotFinalizedError';
+    /** Creates a transaction not finalized error. */
+    constructor(signature, options) {
+        super(CCIPErrorCode.TRANSACTION_NOT_FINALIZED, `Transaction ${signature} not finalized after timeout`, {
+            ...options,
+            isTransient: true,
+            retryAfterMs: 10000,
+            context: { ...options?.context, signature },
+        });
+    }
+}
+/** Thrown when CCTP event decode fails. */
+export class CCIPCctpDecodeError extends CCIPError {
+    name = 'CCIPCctpDecodeError';
+    /** Creates a CCTP decode error. */
+    constructor(log, options) {
+        super(CCIPErrorCode.CCTP_DECODE_FAILED, `Failed to decode CCTP event: ${log}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, log },
+        });
+    }
+}
+/** Thrown when Sui hasher version is unsupported. */
+export class CCIPSuiHasherVersionUnsupportedError extends CCIPError {
+    name = 'CCIPSuiHasherVersionUnsupportedError';
+    /** Creates a Sui hasher version unsupported error. */
+    constructor(version, options) {
+        super(CCIPErrorCode.HASHER_VERSION_UNSUPPORTED, `Unsupported hasher version for Sui: ${version}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, version },
+        });
+    }
+}
+/** Thrown when Sui message version is invalid. */
+export class CCIPSuiMessageVersionInvalidError extends CCIPError {
+    name = 'CCIPSuiMessageVersionInvalidError';
+    /** Creates a Sui message version invalid error. */
+    constructor(options) {
+        super(CCIPErrorCode.MESSAGE_VERSION_INVALID, 'Invalid Sui message: only CCIP v1.6 format is supported', {
+            ...options,
+            isTransient: false,
+        });
+    }
+}
+/** Thrown when Solana lane version is unsupported. */
+export class CCIPSolanaLaneVersionUnsupportedError extends CCIPError {
+    name = 'CCIPSolanaLaneVersionUnsupportedError';
+    /** Creates a Solana lane version unsupported error. */
+    constructor(version, options) {
+        super(CCIPErrorCode.LANE_VERSION_UNSUPPORTED, `Unsupported lane version: ${version}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, version },
+        });
+    }
+}
+/** Thrown when multiple CCTP events found in transaction. */
+export class CCIPCctpMultipleEventsError extends CCIPError {
+    name = 'CCIPCctpMultipleEventsError';
+    /** Creates a CCTP multiple events error. */
+    constructor(count, txSignature, options) {
+        super(CCIPErrorCode.CCTP_MULTIPLE_EVENTS, `Expected only 1 CcipCctpMessageSentEvent, found ${count} in transaction ${txSignature}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, count, txSignature },
+        });
+    }
+}
+/** Thrown when compute units exceed limit. */
+export class CCIPSolanaComputeUnitsExceededError extends CCIPError {
+    name = 'CCIPSolanaComputeUnitsExceededError';
+    /** Creates a compute units exceeded error. */
+    constructor(simulated, limit, options) {
+        super(CCIPErrorCode.SOLANA_COMPUTE_UNITS_EXCEEDED, `Main simulation exceeds specified computeUnits limit. simulated=${simulated}, limit=${limit}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, simulated, limit },
+        });
+    }
+}
+/** Thrown when Aptos hasher version is unsupported. */
+export class CCIPAptosHasherVersionUnsupportedError extends CCIPError {
+    name = 'CCIPAptosHasherVersionUnsupportedError';
+    /** Creates an Aptos hasher version unsupported error. */
+    constructor(version, options) {
+        super(CCIPErrorCode.APTOS_HASHER_VERSION_UNSUPPORTED, `Unsupported hasher version for Aptos: ${version}`, {
+            ...options,
+            isTransient: false,
+            context: { ...options?.context, version },
+        });
+    }
+}
+//# sourceMappingURL=specialized.js.map