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

package/dist/quote.js

@@ -1,21 +1,14 @@
-import { BRIDGE_ERRORS, BridgeError, asBridgeError, reportBridgeError } from './errors/index.js';
-import { CALLDATA_AGGREGATORS, InvalidBridgeCalldataError, validateBridgeCalldata, } from './calldata/index.js';
-import { calldataDiagnostics } from './calldata/diagnostics.js';
-import { InvalidBridgeProviderError } from './providers/errors.js';
-import { SOCKET_PROVIDER_ROUTES } from './providers/socket.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';
     }
 }
@@ -27,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;
 };
@@ -50,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 = [
@@ -77,273 +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, legacy = false) => {
+export const validateBridgeTx = (aggregatorId, fromChainId, bridgeId, tx) => {
     if (!shouldValidateBridgeContracts(aggregatorId)) {
-        return undefined;
+        return true;
     }
     const expectedRouter = getBridgeRouter(aggregatorId, fromChainId);
-    if (legacy && !expectedRouter)
-        return;
+    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));
-    }
-};
-const checkBridgeTx = (aggregatorId, fromChainId, bridgeId, tx, expectation, options = {}, operation = 'verifyTx') => {
-    const context = { aggregatorId, chainId: fromChainId, toChainId: expectation?.toChainId, bridgeId, operation,
-        ...calldataDiagnostics(tx.data) };
-    // A configured-router mismatch was already blocking on main; never suppress it.
-    if (options.lite)
-        validateBridgeRouter(aggregatorId, fromChainId, bridgeId, tx, true);
-    try {
-        validateBridgeRouter(aggregatorId, fromChainId, bridgeId, tx);
-    }
-    catch (error) {
-        handleNewValidationError(error, options, context);
+        throw new InvalidBridgeContractError('router', aggregatorId, fromChainId, expectedRouter, tx.to, bridgeId);
     }
-    if (CALLDATA_AGGREGATORS.includes(aggregatorId) || options.lite) {
-        let check;
-        try {
-            check = validateBridgeCalldata(aggregatorId, fromChainId, tx, expectation);
-        }
-        catch (error) {
-            handleNewValidationError(error, options, context);
-            return undefined;
-        }
-        if (!check.ok) {
-            handleNewValidationError(new InvalidBridgeCalldataError(aggregatorId, fromChainId, check.method, check.reason || BRIDGE_ERRORS.INVALID_CALLDATA.message, check.errors.map((error) => ({ ...error, bridgeId }))), options, context);
-        }
-        return check;
-    }
-    return undefined;
-};
-export const validateBridgeTx = (aggregatorId, fromChainId, bridgeId, tx, expectation, options = {}) => {
-    checkBridgeTx(aggregatorId, fromChainId, bridgeId, tx, expectation, options);
     return true;
 };
 export const getQuote = async (aggregatorId, params, api) => {
-    try {
-        params = { ...params };
-        assertSupported(aggregatorId, params.fromChainId);
-        let assertContext;
+    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)
+        : await api.getBridgeQuoteV2?.(baseParams);
+    if (!quotes) {
+        throw new Error('Bridge API does not provide a quote list method');
+    }
+    return quotes.filter((quote) => {
         try {
-            assertContext = params.providerClient?.captureContext();
+            validateBridgeQuote(aggregatorId, params.fromChainId, quote);
+            return true;
         }
         catch (error) {
-            handleNewValidationError(error, params, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'getQuote' });
-        }
-        if (aggregatorId === BRIDGE_ENUM.RELAY && !params.lite) {
-            if (!params.providerClient)
-                throw new InvalidBridgeProviderError('relay', BRIDGE_ERRORS.DIRECT_PROVIDER_CLIENT_IS_REQUIRED);
-            const quotes = await params.providerClient.getQuotes('relay', params);
-            try {
-                assertContext?.();
-            }
-            catch (error) {
-                handleNewValidationError(error, params, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'getQuote' });
+            if (error instanceof InvalidBridgeContractError) {
+                return false;
             }
-            return quotes;
-        }
-        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 [backendQuotes, providerQuotes] = await Promise.all([
-            api.getBridgeQuoteListV2
-                ? api.getBridgeQuoteListV2(baseParams).catch((error) => { throw asBridgeError(error, BRIDGE_ERRORS.BACKEND_QUOTE_REQUEST_FAILED, { requestKind: 'backend_quote' }); })
-                : api.getBridgeQuoteV2?.(baseParams).catch((error) => { throw asBridgeError(error, BRIDGE_ERRORS.BACKEND_QUOTE_REQUEST_FAILED, { requestKind: 'backend_quote' }); }),
-            aggregatorId === BRIDGE_ENUM.SOCKET && params.providerClient && !params.lite
-                ? params.providerClient.getQuotes('socket', params).catch((error) => {
-                    if (error instanceof InvalidBridgeProviderError) {
-                        reportBridgeError(params.onError, error, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'getQuote' });
-                        return [];
-                    }
-                    throw error;
-                })
-                : Promise.resolve([]),
-        ]);
-        try {
-            assertContext?.();
-        }
-        catch (error) {
-            handleNewValidationError(error, params, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'getQuote' });
-        }
-        if (!backendQuotes) {
-            throw new BridgeError(BRIDGE_ERRORS.MISSING_QUOTE_API);
+            throw error;
         }
-        const quotes = [
-            ...backendQuotes.filter((quote) => !(aggregatorId === BRIDGE_ENUM.SOCKET && params.providerClient && !params.lite &&
-                SOCKET_PROVIDER_ROUTES.includes(quote.bridge_id))),
-            ...providerQuotes,
-        ];
-        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;
-            }
-        });
-    }
-    catch (error) {
-        throw asBridgeError(error, BRIDGE_ERRORS.UNKNOWN, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'getQuote', ...(params.lite ? { lite: true, blocking: true } : {}) });
-    }
+    });
 };
 export const buildTx = async (aggregatorId, params, api) => {
-    try {
-        // Freeze signing intent before awaiting a backend response.
-        params = { ...params };
-        assertSupported(aggregatorId, params.fromChainId);
-        let assertContext;
-        try {
-            assertContext = params.providerClient?.captureContext();
-        }
-        catch (error) {
-            handleNewValidationError(error, params, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'buildTx' });
-        }
-        if (!params.lite && (aggregatorId === BRIDGE_ENUM.RELAY ||
-            (aggregatorId === BRIDGE_ENUM.SOCKET && SOCKET_PROVIDER_ROUTES.includes(params.bridgeId)))) {
-            if (!params.providerClient)
-                throw new InvalidBridgeProviderError(aggregatorId, BRIDGE_ERRORS.DIRECT_PROVIDER_CLIENT_IS_REQUIRED);
-            const tx = await params.providerClient.buildTx(aggregatorId, params);
-            try {
-                assertContext?.();
-            }
-            catch (error) {
-                handleNewValidationError(error, params, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'buildTx' });
-            }
-            return tx;
-        }
-        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),
-            }).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);
-        }
-        try {
-            assertContext?.();
-        }
-        catch (error) {
-            handleNewValidationError(error, params, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'buildTx' });
-        }
-        const expectation = {
-            userAddress: params.userAddress,
-            fromTokenId: params.fromTokenId,
-            fromTokenRawAmount: params.fromTokenRawAmount,
-            toChainId: params.toChainId,
-            toTokenId: params.toTokenId,
-            toTokenRawAmount: params.toTokenRawAmount ?? quotedToAmount(params.quoteKey),
-            slippage: params.slippage,
-        };
-        const check = checkBridgeTx(aggregatorId, params.fromChainId, params.bridgeId, tx, expectation, params, 'buildTx');
-        // A backend may mislabel bridge_id. Decide from calldata as well, so renaming
-        // an RFQ/CCTP/LayerSwap route cannot bypass the provider requirement.
-        const parsed = check?.parsed;
-        if (params.lite && (aggregatorId === BRIDGE_ENUM.RELAY ||
-            (aggregatorId === BRIDGE_ENUM.SOCKET && SOCKET_PROVIDER_ROUTES.includes(params.bridgeId)))) {
-            try {
-                if (!params.providerClient)
-                    throw new InvalidBridgeProviderError(aggregatorId, BRIDGE_ERRORS.DIRECT_PROVIDER_CLIENT_IS_REQUIRED);
-                params.providerClient.verifyTx(aggregatorId, params, tx);
-            }
-            catch (error) {
-                handleNewValidationError(error, params, { aggregatorId, chainId: params.fromChainId,
-                    toChainId: params.toChainId, bridgeId: params.bridgeId, operation: 'buildTx' });
-            }
-            return tx;
-        }
-        try {
-            if (aggregatorId === BRIDGE_ENUM.LIFI && parsed?.method.endsWith('ViaLayerSwap')) {
-                if (!params.providerClient)
-                    throw new InvalidBridgeProviderError('layerswap', BRIDGE_ERRORS.DIRECT_PROVIDER_CLIENT_IS_REQUIRED);
-                const verification = params.providerClient.verifyLayerSwapTx({
-                    ...params, toTokenRawAmount: expectation.toTokenRawAmount,
-                }, params.lite ? { ...tx } : tx);
-                if (params.lite) {
-                    void verification.then(() => assertContext?.()).catch((error) => {
-                        handleNewValidationError(error, params, { aggregatorId, chainId: params.fromChainId,
-                            toChainId: params.toChainId, bridgeId: params.bridgeId, operation: 'buildTx' });
-                    });
-                    return tx;
-                }
-                await verification;
-                try {
-                    assertContext?.();
-                }
-                catch (error) {
-                    handleNewValidationError(error, params, { aggregatorId, chainId: params.fromChainId, toChainId: params.toChainId, operation: 'buildTx' });
-                }
-                return tx;
-            }
-            if (aggregatorId === BRIDGE_ENUM.SOCKET && parsed?.unresolvedFields?.length &&
-                ['receiveERC20', 'depositForBurn'].includes(parsed.protocolMethod ?? '')) {
-                throw new InvalidBridgeProviderError(aggregatorId, BRIDGE_ERRORS.PROVIDER_DESTINATION_UNBOUND);
-            }
-            // shortcut: chain-state output checks are deferred until the follow-up RPC PR.
-            const unverifiedFields = check?.unverifiedFields?.filter((field) => !(field === 'outputToken' && parsed?.outputToken === undefined && parsed?.outputTokenReference) &&
-                !(field === 'minOutputAmount' && parsed?.minOutputAmount === undefined && parsed?.outputAmountReference));
-            if (unverifiedFields?.length) {
-                throw new InvalidBridgeCalldataError(aggregatorId, params.fromChainId, check?.method, `unverified bridge fields: ${unverifiedFields.join(',')}`, [{ ...BRIDGE_ERRORS.UNVERIFIED_BRIDGE_FIELDS, bridgeId: params.bridgeId, unverifiedFields }]);
-            }
-        }
-        catch (error) {
-            handleNewValidationError(error, params, { aggregatorId, chainId: params.fromChainId,
-                toChainId: params.toChainId, bridgeId: params.bridgeId, operation: '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);
@@ -353,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,
@@ -362,10 +148,7 @@ export const getQuoteListWithTx = async (aggregatorId, params, api) => {
             };
         }
         catch (error) {
-            if (error instanceof InvalidBridgeContractError ||
-                error instanceof InvalidBridgeCalldataError ||
-                error instanceof InvalidBridgeProviderError) {
-                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.0",
+  "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;