@rabby-wallet/rabby-bridge 0.0.13-alpha.1 → 0.0.13

package/dist/quote.js

@@ -1,20 +1,14 @@
-import { BRIDGE_ERRORS, BridgeError, asBridgeError, reportBridgeError } from './errors/index.js';
-import { InvalidBridgeCalldataError, validateBridgeCalldata, } from './calldata/index.js';
-import { calldataDiagnostics } from './calldata/diagnostics.js';
-import { sanitizeBridgeError } from './errors/sanitize.js';
 import { BRIDGE_ENUM } from './consts.js';
 import { getBridgeAltContracts, getBridgeRouter, getBridgeSpender, isSupportedBridgeAggregator, isSupportedBridgeChain, } from './list.js';
-export class InvalidBridgeContractError extends BridgeError {
+export class InvalidBridgeContractError extends Error {
     constructor(kind, aggregatorId, chainId, expected, received, bridgeId) {
-        super(kind === 'router' ? BRIDGE_ERRORS.ROUTER_NOT_ALLOWED : BRIDGE_ERRORS.SPENDER_NOT_ALLOWED, { aggregatorId, chainId, bridgeId });
+        super(`Invalid bridge ${kind} for ${aggregatorId} on ${chainId}: expected ${expected}, got ${received}`);
         this.kind = kind;
         this.aggregatorId = aggregatorId;
         this.chainId = chainId;
         this.expected = expected;
         this.received = received;
         this.bridgeId = bridgeId;
-        this.message =
-            `Invalid bridge ${kind} for ${aggregatorId} on ${chainId}: expected ${expected}, got ${received}`;
         this.name = 'InvalidBridgeContractError';
     }
 }
@@ -26,19 +20,15 @@ const isSameAddress = (left, right) => {
 };
 function assertSupported(aggregatorId, fromChainId) {
     if (!isSupportedBridgeAggregator(aggregatorId)) {
-        const error = new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_BRIDGE_AGGREGATOR, { aggregatorId, chainId: fromChainId });
-        error.message = `${aggregatorId} is not supported`;
-        throw error;
+        throw new Error(`${aggregatorId} is not supported`);
     }
     if (!isSupportedBridgeChain(aggregatorId, fromChainId)) {
-        const error = new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOURCE_CHAIN, { aggregatorId, chainId: fromChainId });
-        error.message = `${aggregatorId} does not support ${fromChainId}`;
-        throw error;
+        throw new Error(`${aggregatorId} does not support ${fromChainId}`);
     }
 }
 const requireSlippage = (slippage) => {
     if (!slippage) {
-        throw new BridgeError(BRIDGE_ERRORS.SLIPPAGE_IS_REQUIRED_FOR_THIS_API_CALL);
+        throw new Error('slippage is required for this API call');
     }
     return slippage;
 };
@@ -49,22 +39,13 @@ const stringifyQuoteKey = (quoteKey) => {
     return JSON.stringify(quoteKey || {});
 };
 const shouldValidateBridgeContracts = (aggregatorId) => aggregatorId !== BRIDGE_ENUM.NEAR_INTENTS;
-const handleNewValidationError = (error, options, context) => {
-    if (!options.lite)
-        throw error;
-    reportBridgeError(options.onError, asBridgeError(error), { ...context, lite: true, blocking: false });
-};
-export const validateBridgeQuote = (aggregatorId, fromChainId, quote, options = {}) => {
+export const validateBridgeQuote = (aggregatorId, fromChainId, quote) => {
     if (!shouldValidateBridgeContracts(aggregatorId)) {
         return true;
     }
     const expectedSpender = getBridgeSpender(aggregatorId, fromChainId);
     const receivedSpender = quote.approve_contract_id;
-    if (!receivedSpender) {
-        return true;
-    }
-    if (!expectedSpender) {
-        handleNewValidationError(new InvalidBridgeContractError('spender', aggregatorId, fromChainId, 'configured spender', receivedSpender, quote.bridge_id), options, { aggregatorId, chainId: fromChainId, bridgeId: quote.bridge_id, operation: 'getQuote' });
+    if (!expectedSpender || !receivedSpender) {
         return true;
     }
     const allowedSpenders = [
@@ -76,191 +57,81 @@ export const validateBridgeQuote = (aggregatorId, fromChainId, quote, options =
     }
     return true;
 };
-const quotedToAmount = (quoteKey) => {
-    let key = quoteKey;
-    if (typeof key === 'string') {
-        try {
-            key = JSON.parse(key);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    if (!key || typeof key !== 'object' || Array.isArray(key))
-        return undefined;
-    const amount = key.to_token_raw_amount;
-    if (typeof amount === 'string' || (typeof amount === 'number' && Number.isSafeInteger(amount))) {
-        return String(amount);
-    }
-    return undefined;
-};
-const validateBridgeRouter = (aggregatorId, fromChainId, bridgeId, tx) => {
+export const validateBridgeTx = (aggregatorId, fromChainId, bridgeId, tx) => {
     if (!shouldValidateBridgeContracts(aggregatorId)) {
         return true;
     }
     const expectedRouter = getBridgeRouter(aggregatorId, fromChainId);
+    if (!expectedRouter) {
+        return true;
+    }
     const allowedRouters = [
-        ...(expectedRouter ? [expectedRouter] : []),
+        expectedRouter,
         ...getBridgeAltContracts(aggregatorId),
     ];
     if (!allowedRouters.some((addr) => isSameAddress(addr, tx.to))) {
-        throw asBridgeError(new InvalidBridgeContractError('router', aggregatorId, fromChainId, expectedRouter || allowedRouters.join(',') || 'configured router', tx.to, bridgeId), BRIDGE_ERRORS.ROUTER_NOT_ALLOWED, { ...calldataDiagnostics(tx.data),
-            pass: false, routerPass: false, fromPass: false, toPass: false, receiverPass: false, blocking: true });
+        throw new InvalidBridgeContractError('router', aggregatorId, fromChainId, expectedRouter, tx.to, bridgeId);
     }
     return true;
 };
-const fieldErrors = {
-    fromPass: [BRIDGE_ERRORS.FROM_ADDRESS_MISMATCH, BRIDGE_ERRORS.FROM_CHAIN_MISMATCH,
-        BRIDGE_ERRORS.FROM_TOKEN_MISMATCH, BRIDGE_ERRORS.FROM_AMOUNT_MISMATCH,
-        BRIDGE_ERRORS.DEPOSITOR_MISMATCH, BRIDGE_ERRORS.MISSING_SOURCE_TOKEN, BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT],
-    toPass: [BRIDGE_ERRORS.TO_CHAIN_MISMATCH, BRIDGE_ERRORS.TO_TOKEN_MISMATCH,
-        BRIDGE_ERRORS.MIN_RECEIVE_MISMATCH, BRIDGE_ERRORS.MISSING_DESTINATION,
-        BRIDGE_ERRORS.MISSING_DESTINATION_CHAIN, BRIDGE_ERRORS.MISSING_OUTPUT_TOKEN,
-        BRIDGE_ERRORS.MISSING_MIN_OUTPUT, BRIDGE_ERRORS.UNSUPPORTED_DESTINATION_CALL],
-    receiverPass: [BRIDGE_ERRORS.RECEIVER_MISMATCH, BRIDGE_ERRORS.MISSING_RECEIVER,
-        BRIDGE_ERRORS.UNSUPPORTED_DESTINATION_CALL],
-};
-const bindingErrors = [
-    BRIDGE_ERRORS.QUOTE_ID_MISMATCH, BRIDGE_ERRORS.REQUEST_ID_MISMATCH, BRIDGE_ERRORS.SOCKET_RFQ_QUOTE_ID_MISMATCH,
-];
-const checkBridgeTx = (aggregatorId, fromChainId, bridgeId, tx, expectation, options = {}, operation = 'verifyTx') => {
-    const routerPass = validateBridgeRouter(aggregatorId, fromChainId, bridgeId, tx);
-    let check;
-    try {
-        check = validateBridgeCalldata(aggregatorId, fromChainId, tx, expectation);
-    }
-    catch (error) {
-        check = { ok: false, aggregatorId, errors: asBridgeError(error, BRIDGE_ERRORS.INVALID_CALLDATA).errors };
-    }
-    const unverifiedFields = check.unverifiedFields ?? [
-        'sourceToken', 'sourceAmount', 'outputToken', 'minOutputAmount', 'receiver',
-        ...(expectation?.toChainId ? ['destinationChainId'] : []),
-    ];
-    const externalDestination = check.parsed && (aggregatorId === BRIDGE_ENUM.RELAY ||
-        (aggregatorId === BRIDGE_ENUM.SOCKET &&
-            ['receiveERC20', 'receiveNative', 'depositForBurn'].includes(check.parsed.protocolMethod ?? '')));
-    // Known local limits remain unverified, without repeating an expected gap as an error.
-    const reportableFields = unverifiedFields.filter((field) => {
-        if (!check.parsed)
-            return true;
-        if (field === 'outputToken')
-            return false;
-        if (field === 'minOutputAmount')
-            return check.parsed.minOutputAmount !== undefined;
-        return !(externalDestination && ['receiver', 'destinationChainId'].includes(field));
-    });
-    // Unclassified structure failures invalidate every field; known field failures stay separate.
-    const comparable = Boolean(expectation && check.parsed) && check.errors.every((error) => bindingErrors.some((item) => item.error_code === error.error_code) ||
-        Object.values(fieldErrors).some((group) => group.some((item) => item.error_code === error.error_code)));
-    const fieldPass = (field, required) => comparable &&
-        required.every((item) => !unverifiedFields.includes(item)) &&
-        !check.errors.some((error) => fieldErrors[field].some((item) => item.error_code === error.error_code));
-    const flags = {
-        // shortcut: field checks are observation-only until collected routes justify enforcement.
-        pass: routerPass, routerPass,
-        fromPass: fieldPass('fromPass', ['sourceToken', 'sourceAmount']),
-        toPass: fieldPass('toPass', ['outputToken', 'minOutputAmount', ...(expectation?.toChainId ? ['destinationChainId'] : [])]),
-        receiverPass: fieldPass('receiverPass', ['receiver']),
-    };
-    const context = {
-        ...check.parsed?.diagnostics, ...calldataDiagnostics(tx.data), aggregatorId,
-        chainId: fromChainId, toChainId: expectation?.toChainId, bridgeId, operation, method: check.method,
-        ...(check.parsed ? { hasDestinationCall: Boolean(check.parsed.hasDestinationCall || check.parsed.destinationCallData !== undefined) } : {}),
-        ...flags, lite: Boolean(options.lite), blocking: false,
+export const getQuote = async (aggregatorId, params, api) => {
+    assertSupported(aggregatorId, params.fromChainId);
+    const baseParams = {
+        aggregator_id: aggregatorId,
+        user_addr: params.userAddress,
+        from_chain_id: params.fromChainId,
+        from_token_id: params.fromTokenId,
+        from_token_raw_amount: params.fromTokenRawAmount,
+        to_chain_id: params.toChainId,
+        to_token_id: params.toTokenId,
+        fee_rate: params.feeRate,
+        slippage: requireSlippage(params.slippage),
     };
-    const errors = [
-        ...check.errors,
-        ...(reportableFields.length ? [{ ...BRIDGE_ERRORS.UNVERIFIED_BRIDGE_FIELDS, unverifiedFields: reportableFields }] : []),
-    ].map((error) => sanitizeBridgeError({ ...error, ...context }));
-    if (errors.length) {
-        reportBridgeError(options.onError, new InvalidBridgeCalldataError(aggregatorId, fromChainId, check.method, check.reason || errors[0].message, errors), context);
+    const quotes = api.getBridgeQuoteListV2
+        ? await api.getBridgeQuoteListV2(baseParams)
+        : await api.getBridgeQuoteV2?.(baseParams);
+    if (!quotes) {
+        throw new Error('Bridge API does not provide a quote list method');
     }
-    return { ...flags, unverifiedFields, errors };
-};
-export const validateBridgeTx = (aggregatorId, fromChainId, bridgeId, tx, expectation, options = {}) => checkBridgeTx(aggregatorId, fromChainId, bridgeId, tx, expectation, options);
-export const getQuote = async (aggregatorId, params, api) => {
-    try {
-        params = { ...params };
-        assertSupported(aggregatorId, params.fromChainId);
-        const baseParams = {
-            aggregator_id: aggregatorId,
-            user_addr: params.userAddress,
-            from_chain_id: params.fromChainId,
-            from_token_id: params.fromTokenId,
-            from_token_raw_amount: params.fromTokenRawAmount,
-            to_chain_id: params.toChainId,
-            to_token_id: params.toTokenId,
-            fee_rate: params.feeRate,
-            slippage: requireSlippage(params.slippage),
-        };
-        const quotes = api.getBridgeQuoteListV2
-            ? await api.getBridgeQuoteListV2(baseParams).catch((error) => { throw asBridgeError(error, BRIDGE_ERRORS.BACKEND_QUOTE_REQUEST_FAILED, { requestKind: 'backend_quote' }); })
-            : await api.getBridgeQuoteV2?.(baseParams).catch((error) => { throw asBridgeError(error, BRIDGE_ERRORS.BACKEND_QUOTE_REQUEST_FAILED, { requestKind: 'backend_quote' }); });
-        if (!quotes)
-            throw new BridgeError(BRIDGE_ERRORS.MISSING_QUOTE_API);
-        return quotes.filter((quote) => {
-            try {
-                validateBridgeQuote(aggregatorId, params.fromChainId, quote, params);
-                return true;
-            }
-            catch (error) {
-                if (error instanceof InvalidBridgeContractError) {
-                    reportBridgeError(params.onError, error, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, bridgeId: quote.bridge_id, operation: 'getQuote', ...(params.lite ? { lite: true, blocking: true } : {}) });
-                    return false;
-                }
-                throw error;
+    return quotes.filter((quote) => {
+        try {
+            validateBridgeQuote(aggregatorId, params.fromChainId, quote);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof InvalidBridgeContractError) {
+                return false;
             }
-        });
-    }
-    catch (error) {
-        throw asBridgeError(error, BRIDGE_ERRORS.UNKNOWN, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'getQuote', ...(params.lite ? { lite: true, blocking: true } : {}) });
-    }
+            throw error;
+        }
+    });
 };
 export const buildTx = async (aggregatorId, params, api) => {
-    try {
-        // Freeze signing intent before awaiting a backend response.
-        params = { ...params };
-        assertSupported(aggregatorId, params.fromChainId);
-        const quoteKey = stringifyQuoteKey(params.quoteKey);
-        const expectation = {
-            userAddress: params.userAddress,
-            fromTokenId: params.fromTokenId,
-            fromTokenRawAmount: params.fromTokenRawAmount,
-            toChainId: params.toChainId,
-            toTokenId: params.toTokenId,
-            toTokenRawAmount: params.toTokenRawAmount ?? quotedToAmount(quoteKey),
-            // The legacy quote+tx API requotes instead of reusing this selection.
-            quoteKey: typeof api.buildBridgeTx === 'function' ? quoteKey : undefined,
-            slippage: params.slippage,
-        };
-        const buildParams = {
-            aggregator_id: aggregatorId,
-            bridge_id: params.bridgeId,
-            user_addr: params.userAddress,
-            from_chain_id: params.fromChainId,
-            from_token_id: params.fromTokenId,
-            from_token_raw_amount: params.fromTokenRawAmount,
-            to_chain_id: params.toChainId,
-            to_token_id: params.toTokenId,
-            slippage: requireSlippage(params.slippage),
-        };
-        const tx = api.buildBridgeTx
-            ? await api.buildBridgeTx({
-                ...buildParams,
-                quote_key: quoteKey,
-            }).catch((error) => { throw asBridgeError(error, BRIDGE_ERRORS.BACKEND_BUILD_REQUEST_FAILED, { requestKind: 'backend_build' }); })
-            : (await api.getBridgeQuoteTxV2?.({
-                ...buildParams,
-            }).catch((error) => { throw asBridgeError(error, BRIDGE_ERRORS.BACKEND_BUILD_REQUEST_FAILED, { requestKind: 'backend_build' }); }))?.tx;
-        if (!tx) {
-            throw new BridgeError(BRIDGE_ERRORS.MISSING_BUILD_API);
-        }
-        checkBridgeTx(aggregatorId, params.fromChainId, params.bridgeId, tx, expectation, params, 'buildTx');
-        return tx;
-    }
-    catch (error) {
-        throw asBridgeError(error, BRIDGE_ERRORS.UNKNOWN, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'buildTx', bridgeId: params.bridgeId, ...(params.lite ? { lite: true, blocking: true } : {}) });
-    }
+    assertSupported(aggregatorId, params.fromChainId);
+    const buildParams = {
+        aggregator_id: aggregatorId,
+        bridge_id: params.bridgeId,
+        user_addr: params.userAddress,
+        from_chain_id: params.fromChainId,
+        from_token_id: params.fromTokenId,
+        from_token_raw_amount: params.fromTokenRawAmount,
+        to_chain_id: params.toChainId,
+        to_token_id: params.toTokenId,
+        slippage: requireSlippage(params.slippage),
+    };
+    const tx = api.buildBridgeTx
+        ? await api.buildBridgeTx({
+            ...buildParams,
+            quote_key: stringifyQuoteKey(params.quoteKey),
+        })
+        : (await api.getBridgeQuoteTxV2?.({
+            ...buildParams,
+        }))?.tx;
+    if (!tx) {
+        throw new Error('Bridge API does not provide a build tx method');
+    }
+    validateBridgeTx(aggregatorId, params.fromChainId, params.bridgeId, tx);
+    return tx;
 };
 export const getQuoteListWithTx = async (aggregatorId, params, api) => {
     const quotes = await getQuote(aggregatorId, params, api);
@@ -270,8 +141,6 @@ export const getQuoteListWithTx = async (aggregatorId, params, api) => {
                 ...params,
                 bridgeId: quote.bridge_id,
                 quoteKey: quote.quote_key,
-                toTokenRawAmount: quote.to_token_raw_amount_hex_str ??
-                    (Number.isSafeInteger(quote.to_token_raw_amount) ? String(quote.to_token_raw_amount) : undefined),
             }, api);
             return {
                 ...quote,
@@ -279,9 +148,7 @@ export const getQuoteListWithTx = async (aggregatorId, params, api) => {
             };
         }
         catch (error) {
-            if (error instanceof InvalidBridgeContractError ||
-                error instanceof InvalidBridgeCalldataError) {
-                reportBridgeError(params.onError, error, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, bridgeId: quote.bridge_id, operation: 'buildTx', ...(params.lite ? { lite: true, blocking: true } : {}) });
+            if (error instanceof InvalidBridgeContractError) {
                 return null;
             }
             throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rabby-wallet/rabby-bridge",
-  "version": "0.0.13-alpha.1",
+  "version": "0.0.13",
   "description": "Bridge quote helpers and contract allowlists for Rabby",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,13 +22,7 @@
   "scripts": {
     "prepublishOnly": "yarn build",
     "build": "rimraf dist && tsc",
-    "test": "yarn build && NODE_OPTIONS=--experimental-vm-modules jest --runInBand --watchman=false",
-    "test:bridge-calldata": "yarn build && NODE_OPTIONS=--experimental-vm-modules jest --runInBand --watchman=false tests/calldata",
-    "test:bridge-calldata:lifi": "yarn test:bridge-calldata --testNamePattern='\\[LiFi\\]'",
-    "test:bridge-calldata:socket": "yarn test:bridge-calldata --testNamePattern='\\[Socket\\]'",
-    "test:bridge-calldata:relay": "yarn test:bridge-calldata --testNamePattern='\\[Relay\\]'",
-    "test:bridge-calldata:across": "yarn test:bridge-calldata --testNamePattern='\\[Across\\]'",
-    "test:bridge-calldata:mayan": "yarn test:bridge-calldata --testNamePattern='\\[Mayan\\]'"
+    "test": "yarn build && NODE_OPTIONS=--experimental-vm-modules jest --runInBand --watchman=false"
   },
   "devDependencies": {
     "@debank/common": "^0.3.60",
@@ -38,9 +32,5 @@
     "rimraf": "^3.0.2",
     "typescript": "^5.8.3"
   },
-  "packageManager": "yarn@4.12.0",
-  "dependencies": {
-    "@ethersproject/hash": "5.8.0",
-    "@ethersproject/strings": "5.8.0"
-  }
+  "packageManager": "yarn@4.12.0"
 }

package/dist/calldata/abi.d.ts

@@ -1,29 +0,0 @@
-import type { ParsedBridgeCall } from './types.js';
-export type AbiParam = {
-    name: string;
-    kind: 'address' | 'uint' | 'bool' | 'bytes' | 'string' | 'array' | 'tuple';
-    size?: number;
-    length?: number;
-    item?: AbiParam;
-    components?: AbiParam[];
-};
-export type AbiValue = string | bigint | boolean | AbiValue[] | {
-    [key: string]: AbiValue;
-};
-export declare const decodeCall: (params: AbiParam[], calldata: string) => {
-    [key: string]: AbiValue;
-};
-export declare const decodeParameters: (params: AbiParam[], data: string) => {
-    [key: string]: AbiValue;
-};
-export declare const asRecord: (value: AbiValue) => {
-    [key: string]: AbiValue;
-};
-export declare const asArray: (value: AbiValue) => AbiValue[];
-export declare const asBigint: (value: AbiValue) => bigint;
-export declare const asString: (value: AbiValue) => string;
-export type CalldataMethod = {
-    name: string;
-    selector: string;
-    decode: (data: string, value: bigint) => ParsedBridgeCall;
-};

package/dist/calldata/abi.js

@@ -1,160 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../errors/index.js';
-import { toUtf8String, Utf8ErrorFuncs } from '@ethersproject/strings';
-import { bytesToHex, hexToBytes } from './hex.js';
-const isDynamic = (param) => {
-    if (param.kind === 'string') {
-        return true;
-    }
-    if (param.kind === 'bytes') {
-        return param.size === undefined;
-    }
-    if (param.kind === 'array') {
-        return param.length === undefined || isDynamic(param.item);
-    }
-    if (param.kind === 'tuple') {
-        return (param.components ?? []).some(isDynamic);
-    }
-    return false;
-};
-const staticWordCount = (param) => {
-    if (isDynamic(param)) {
-        return 1;
-    }
-    if (param.kind === 'tuple') {
-        return (param.components ?? []).reduce((sum, item) => sum + staticWordCount(item), 0);
-    }
-    if (param.kind === 'array') {
-        return (param.length ?? 0) * staticWordCount(param.item);
-    }
-    return 1;
-};
-const readWord = (buf, offset) => {
-    if (offset < 0 || offset + 32 > buf.length) {
-        throw new BridgeError(BRIDGE_ERRORS.ABI_WORD_OUT_OF_BOUNDS, { abiOffset: offset, abiBufferBytes: buf.length });
-    }
-    let value = 0n;
-    for (let index = 0; index < 32; index += 1) {
-        value = (value << 8n) + BigInt(buf[offset + index]);
-    }
-    return value;
-};
-const toAddress = (word) => {
-    if (word >= (1n << 160n))
-        throw new BridgeError(BRIDGE_ERRORS.INVALID_ABI_ADDRESS);
-    return `0x${word.toString(16).padStart(40, '0')}`;
-};
-const readByteLength = (buf, offset) => {
-    const length = readWord(buf, offset);
-    if (length > BigInt(buf.length)) {
-        throw new BridgeError(BRIDGE_ERRORS.ABI_BYTES_OUT_OF_BOUNDS, { abiOffset: offset, abiBufferBytes: buf.length });
-    }
-    return Number(length);
-};
-const readDynamicBytes = (buf, offset) => {
-    const length = readByteLength(buf, offset);
-    const start = offset + 32;
-    if (start + length > buf.length) {
-        throw new BridgeError(BRIDGE_ERRORS.ABI_BYTES_OUT_OF_BOUNDS, { abiOffset: offset, abiBufferBytes: buf.length });
-    }
-    return bytesToHex(buf.subarray(start, start + length));
-};
-const decodeSequence = (params, buf, base) => {
-    let cursor = base;
-    const locations = [];
-    for (const param of params) {
-        if (isDynamic(param)) {
-            const relative = readWord(buf, cursor);
-            if (relative > BigInt(buf.length)) {
-                throw new BridgeError(BRIDGE_ERRORS.ABI_OFFSET_OUT_OF_BOUNDS, { abiOffset: cursor, abiBufferBytes: buf.length });
-            }
-            locations.push(base + Number(relative));
-            cursor += 32;
-        }
-        else {
-            locations.push(cursor);
-            cursor += staticWordCount(param) * 32;
-        }
-    }
-    return params.map((param, index) => decodeAt(param, buf, locations[index]));
-};
-const decodeAt = (param, buf, offset) => {
-    switch (param.kind) {
-        case 'address':
-            return toAddress(readWord(buf, offset));
-        case 'uint':
-            return readWord(buf, offset);
-        case 'bool': {
-            const word = readWord(buf, offset);
-            if (word !== 0n && word !== 1n) {
-                throw new BridgeError(BRIDGE_ERRORS.INVALID_BOOL);
-            }
-            return word === 1n;
-        }
-        case 'bytes': {
-            if (param.size === undefined) {
-                return readDynamicBytes(buf, offset);
-            }
-            if (offset + 32 > buf.length) {
-                throw new BridgeError(BRIDGE_ERRORS.ABI_WORD_OUT_OF_BOUNDS, { abiOffset: offset, abiBufferBytes: buf.length });
-            }
-            return bytesToHex(buf.subarray(offset, offset + param.size));
-        }
-        case 'string':
-            return toUtf8String(readDynamicBytes(buf, offset), Utf8ErrorFuncs.replace).replace(/^\uFEFF/, '');
-        case 'tuple':
-            return decodeTuple(param.components ?? [], buf, offset);
-        case 'array': {
-            const item = param.item;
-            if (param.length === undefined) {
-                const length = readByteLength(buf, offset);
-                if (length > 2048) {
-                    throw new BridgeError(BRIDGE_ERRORS.ABI_ARRAY_TOO_LONG);
-                }
-                return decodeSequence(Array.from({ length }, () => item), buf, offset + 32);
-            }
-            return decodeSequence(Array.from({ length: param.length }, () => item), buf, offset);
-        }
-        default:
-            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_ABI_TYPE);
-    }
-};
-const decodeTuple = (components, buf, offset) => {
-    const values = decodeSequence(components, buf, offset);
-    return Object.fromEntries(components.map((component, index) => [component.name, values[index]]));
-};
-export const decodeCall = (params, calldata) => {
-    const bytes = hexToBytes(calldata);
-    if (bytes.length < 4) {
-        throw new BridgeError(BRIDGE_ERRORS.MISSING_SELECTOR);
-    }
-    const values = decodeSequence(params, bytes.subarray(4), 0);
-    return Object.fromEntries(params.map((param, index) => [param.name, values[index]]));
-};
-export const decodeParameters = (params, data) => {
-    const values = decodeSequence(params, hexToBytes(data), 0);
-    return Object.fromEntries(params.map((param, index) => [param.name, values[index]]));
-};
-export const asRecord = (value) => {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new BridgeError(BRIDGE_ERRORS.EXPECTED_TUPLE);
-    }
-    return value;
-};
-export const asArray = (value) => {
-    if (!Array.isArray(value)) {
-        throw new BridgeError(BRIDGE_ERRORS.EXPECTED_ARRAY);
-    }
-    return value;
-};
-export const asBigint = (value) => {
-    if (typeof value !== 'bigint') {
-        throw new BridgeError(BRIDGE_ERRORS.EXPECTED_UINT);
-    }
-    return value;
-};
-export const asString = (value) => {
-    if (typeof value !== 'string') {
-        throw new BridgeError(BRIDGE_ERRORS.EXPECTED_STRING);
-    }
-    return value;
-};

package/dist/calldata/across/deposit.d.ts

@@ -1,2 +0,0 @@
-import type { CalldataMethod } from '../abi.js';
-export declare const deposit: CalldataMethod;

package/dist/calldata/across/deposit.js

@@ -1,36 +0,0 @@
-import { applyAcrossMessage } from '../destination.js';
-import { asBigint, asString, decodeCall } from '../abi.js';
-import { accountFromBytes32 } from '../hex.js';
-const fields = [
-    { name: 'depositor', kind: 'bytes', size: 32 },
-    { name: 'recipient', kind: 'bytes', size: 32 },
-    { name: 'inputToken', kind: 'bytes', size: 32 },
-    { name: 'outputToken', kind: 'bytes', size: 32 },
-    { name: 'inputAmount', kind: 'uint' },
-    { name: 'outputAmount', kind: 'uint' },
-    { name: 'destinationChainId', kind: 'uint' },
-    { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
-    { name: 'quoteTimestamp', kind: 'uint' },
-    { name: 'fillDeadline', kind: 'uint' },
-    { name: 'exclusivityParameter', kind: 'uint' },
-    { name: 'message', kind: 'bytes' },
-];
-export const deposit = {
-    name: 'deposit',
-    selector: '0xad5425c6',
-    decode(data) {
-        const args = decodeCall(fields, data);
-        return applyAcrossMessage({
-            aggregatorId: 'across',
-            method: 'deposit',
-            kind: 'bridge',
-            depositor: accountFromBytes32(asString(args.depositor)),
-            sourceToken: accountFromBytes32(asString(args.inputToken)),
-            sourceAmount: asBigint(args.inputAmount),
-            destinationChainId: asBigint(args.destinationChainId),
-            receiver: accountFromBytes32(asString(args.recipient)),
-            outputToken: accountFromBytes32(asString(args.outputToken)),
-            minOutputAmount: asBigint(args.outputAmount),
-        }, asString(args.message));
-    },
-};

package/dist/calldata/across/depositNative.d.ts

@@ -1,2 +0,0 @@
-import type { CalldataMethod } from '../abi.js';
-export declare const depositNative: CalldataMethod;

package/dist/calldata/across/depositNative.js

@@ -1,45 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
-import { applyAcrossMessage } from '../destination.js';
-import { asBigint, asString, decodeCall } from '../abi.js';
-import { accountFromBytes32 } from '../hex.js';
-import { NATIVE_TOKEN } from '../protocols.js';
-const fields = [
-    { name: 'spokePool', kind: 'address' },
-    { name: 'depositor', kind: 'address' },
-    { name: 'recipient', kind: 'bytes', size: 32 },
-    { name: 'inputToken', kind: 'address' },
-    { name: 'inputAmount', kind: 'uint' },
-    { name: 'outputToken', kind: 'bytes', size: 32 },
-    { name: 'outputAmount', kind: 'uint' },
-    { name: 'destinationChainId', kind: 'uint' },
-    { name: 'exclusiveRelayer', kind: 'bytes', size: 32 },
-    { name: 'quoteTimestamp', kind: 'uint' },
-    { name: 'fillDeadline', kind: 'uint' },
-    { name: 'exclusivityParameter', kind: 'uint' },
-    { name: 'message', kind: 'bytes' },
-];
-export const depositNative = {
-    name: 'depositNative',
-    selector: '0x609ea081',
-    decode(data, value) {
-        const args = decodeCall(fields, data);
-        const inputAmount = asBigint(args.inputAmount);
-        if (inputAmount > 0n && value !== inputAmount)
-            throw new BridgeError(BRIDGE_ERRORS.ACROSS_NATIVE_VALUE_MISMATCH);
-        return applyAcrossMessage({
-            aggregatorId: 'across',
-            method: 'depositNative',
-            kind: 'bridge',
-            depositor: asString(args.depositor),
-            sourceToken: NATIVE_TOKEN,
-            sourceAmount: inputAmount > 0n ? inputAmount : value,
-            bridgeToken: asString(args.inputToken),
-            bridgeAmount: inputAmount > 0n ? inputAmount : value,
-            destinationChainId: asBigint(args.destinationChainId),
-            receiver: accountFromBytes32(asString(args.recipient)),
-            outputToken: accountFromBytes32(asString(args.outputToken)),
-            minOutputAmount: asBigint(args.outputAmount),
-            spokePool: asString(args.spokePool),
-        }, asString(args.message));
-    },
-};

package/dist/calldata/across/depositNow.d.ts

@@ -1,2 +0,0 @@
-import type { CalldataMethod } from '../abi.js';
-export declare const depositNow: CalldataMethod;