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

package/dist/providers/relay.js

@@ -0,0 +1,237 @@
+import { BRIDGE_ERRORS, BridgeError } from '../errors/index.js';
+import { _TypedDataEncoder } from '@ethersproject/hash';
+import { getBridgeRouter } from '../list.js';
+import { evmChainId } from '../calldata/chains.js';
+import { decodeBridgeCalldataResult } from '../calldata/index.js';
+import { asBigint, asString, decodeCall } from '../calldata/abi.js';
+import { relayFundingRouter } from '../calldata/relay/nestedDeposit.js';
+import { address, array, bytes, chain, object, text, tokenAddress, transaction, uint } from './data.js';
+// Relay settlement-sdk 0.0.152 ORDER_EIP712_TYPES. EVM addresses are 20-byte
+// dynamic bytes, not bytes32. Unknown order versions/VMs fail closed.
+// Deadlines remain part of the order hash; they are not checked against the clock.
+const ORDER_TYPES = {
+    Order: [
+        { name: 'version', type: 'string' }, { name: 'solverChainId', type: 'string' },
+        { name: 'solver', type: 'address' }, { name: 'salt', type: 'uint256' },
+        { name: 'inputs', type: 'Input[]' }, { name: 'output', type: 'Output' }, { name: 'fees', type: 'Fee[]' },
+    ],
+    Input: [{ name: 'payment', type: 'InputPayment' }, { name: 'refunds', type: 'InputRefund[]' }],
+    InputPayment: [
+        { name: 'chainId', type: 'string' }, { name: 'currency', type: 'bytes' },
+        { name: 'amount', type: 'uint256' }, { name: 'weight', type: 'uint256' },
+    ],
+    InputRefund: [
+        { name: 'chainId', type: 'string' }, { name: 'recipient', type: 'bytes' }, { name: 'currency', type: 'bytes' },
+        { name: 'minimumAmount', type: 'uint256' }, { name: 'deadline', type: 'uint32' }, { name: 'extraData', type: 'bytes' },
+    ],
+    Output: [
+        { name: 'chainId', type: 'string' }, { name: 'payments', type: 'OutputPayment[]' },
+        { name: 'deadline', type: 'uint32' }, { name: 'calls', type: 'bytes[]' }, { name: 'extraData', type: 'bytes' },
+    ],
+    OutputPayment: [
+        { name: 'recipient', type: 'bytes' }, { name: 'currency', type: 'bytes' },
+        { name: 'minimumAmount', type: 'uint256' }, { name: 'expectedAmount', type: 'uint256' },
+    ],
+    Fee: [
+        { name: 'recipientChainId', type: 'string' }, { name: 'recipient', type: 'bytes' },
+        { name: 'currencyChainId', type: 'string' }, { name: 'currency', type: 'bytes' }, { name: 'amount', type: 'uint256' },
+    ],
+};
+// Pin protocol identifiers independently of the service's mutable /chains response.
+const RELAY_EVM_CHAIN_IDS = {
+    ethereum: 1n, optimism: 10n, cronos: 25n, bnb: 56n, gnosis: 100n, unichain: 130n,
+    polygon: 137n, monad: 143n, sonic: 146n, manta: 169n, xlayer: 196n, boba: 288n,
+    zksync: 324n, shape: 360n, worldchain: 480n, flow: 747n, stable: 988n, hyperevm: 999n,
+    metis: 1088n, soneium: 1868n, ronin: 2020n, abstract: 2741n, morph: 2818n,
+    tempo: 4217n, megaeth: 4326n, robinhood: 4663n, mantle: 5000n, somnia: 5031n,
+    arc: 5042n, base: 8453n, plasma: 9745n, apechain: 33139n, mode: 34443n,
+    mythos: 42018n, arbitrum: 42161n, celo: 42220n, avalanche: 43114n, zircuit: 48900n,
+    ink: 57073n, linea: 59144n, bob: 60808n, berachain: 80094n, doma: 97477n,
+    plume: 98866n, scroll: 534352n, gensyn: 685689n, katana: 747474n,
+    ethereal: 5064014n, zora: 7777777n,
+};
+export const relayChains = (value) => {
+    const result = [];
+    for (const raw of array(object(value).chains)) {
+        const c = object(raw);
+        if (c.vmType !== 'evm' || !c.protocol)
+            continue;
+        const v2 = object(c.protocol).v2;
+        if (!v2)
+            continue;
+        const protocol = object(v2);
+        const entry = { evmId: uint(c.id), protocolId: text(protocol.chainId), depository: address(protocol.depository) };
+        if (!Object.prototype.hasOwnProperty.call(RELAY_EVM_CHAIN_IDS, entry.protocolId))
+            continue;
+        if (RELAY_EVM_CHAIN_IDS[entry.protocolId] !== entry.evmId)
+            throw new BridgeError(BRIDGE_ERRORS.RELAY_PROTOCOL_CHAIN_MISMATCH);
+        if (result.some((other) => other.evmId === entry.evmId || other.protocolId === entry.protocolId))
+            throw new BridgeError(BRIDGE_ERRORS.AMBIGUOUS_RELAY_CHAIN);
+        result.push(entry);
+    }
+    return result;
+};
+export const relayOrder = (raw, metadata) => {
+    const o = object(raw);
+    if (o.version !== 'v1')
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_ORDER_VERSION);
+    const evm = (id) => {
+        const protocolId = text(id);
+        if (!metadata.some((c) => c.protocolId === protocolId))
+            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_VM);
+        return protocolId;
+    };
+    const output = object(o.output);
+    return {
+        version: o.version,
+        solverChainId: evm(o.solverChainId), solver: address(o.solver), salt: uint(o.salt).toString(),
+        inputs: array(o.inputs).map((rawInput) => {
+            const input = object(rawInput), payment = object(input.payment);
+            return {
+                payment: { chainId: evm(payment.chainId), currency: address(payment.currency), amount: uint(payment.amount).toString(), weight: uint(payment.weight).toString() },
+                refunds: array(input.refunds).map((rawRefund) => {
+                    const r = object(rawRefund);
+                    return { chainId: evm(r.chainId), recipient: address(r.recipient), currency: address(r.currency),
+                        minimumAmount: uint(r.minimumAmount).toString(), deadline: uint(r.deadline, 32).toString(), extraData: bytes(r.extraData) };
+                }),
+            };
+        }),
+        output: {
+            chainId: evm(output.chainId), deadline: uint(output.deadline, 32).toString(), extraData: bytes(output.extraData),
+            calls: array(output.calls).map((call) => bytes(call)),
+            payments: array(output.payments).map((rawPayment) => {
+                const p = object(rawPayment);
+                return { recipient: address(p.recipient), currency: address(p.currency),
+                    minimumAmount: uint(p.minimumAmount).toString(), expectedAmount: uint(p.expectedAmount).toString() };
+            }),
+        },
+        fees: array(o.fees).map((rawFee) => {
+            const f = object(rawFee);
+            return { recipientChainId: evm(f.recipientChainId), recipient: address(f.recipient),
+                currencyChainId: evm(f.currencyChainId), currency: address(f.currency), amount: uint(f.amount).toString() };
+        }),
+    };
+};
+const relayOrderMetadata = () => Object.entries(RELAY_EVM_CHAIN_IDS).map(([protocolId, evmId]) => ({
+    protocolId, evmId, depository: '0x0000000000000000000000000000000000000000',
+}));
+/** Verify the order and its funding before exposing its committed destination fields. */
+export const verifyRelayOrder = (orderData, parsed, fromChainId, userAddress, target) => {
+    let order;
+    try {
+        order = relayOrder(orderData, relayOrderMetadata());
+    }
+    catch {
+        return [BRIDGE_ERRORS.RELAY_ORDER_HASH_MISMATCH];
+    }
+    const hash = _TypedDataEncoder.hashStruct('Order', ORDER_TYPES, order).toLowerCase();
+    const user = userAddress.toLowerCase();
+    const errors = [];
+    if (hash !== parsed.orderId?.toLowerCase())
+        errors.push(BRIDGE_ERRORS.RELAY_ORDER_HASH_MISMATCH);
+    if (order.output.payments.length === 0 || order.output.payments.some((payment) => payment.recipient !== user)) {
+        errors.push(BRIDGE_ERRORS.RECEIVER_MISMATCH);
+    }
+    if (order.inputs.some((input) => input.refunds.some((refund) => refund.recipient !== user))) {
+        errors.push(BRIDGE_ERRORS.RELAY_REFUND_RECIPIENT_MISMATCH);
+    }
+    if (order.output.payments.length !== 1 || order.output.calls.length !== 0) {
+        errors.push(BRIDGE_ERRORS.UNSUPPORTED_RELAY_ORDER_SHAPE);
+    }
+    const direct = ['depositNative', 'depositErc20'].includes(parsed.method);
+    const token = direct ? parsed.sourceToken : parsed.bridgeToken;
+    const amount = direct ? parsed.sourceAmount : parsed.bridgeAmount;
+    const fundingRouter = relayFundingRouter(parsed.method, target.toLowerCase());
+    if (!token || amount === undefined || amount <= 0n ||
+        (direct && target.toLowerCase() !== getBridgeRouter('relay', fromChainId)) || (!direct &&
+        (!fundingRouter || (parsed.bridgeReceiver !== undefined && parsed.bridgeReceiver !== fundingRouter)))) {
+        errors.push(BRIDGE_ERRORS.UNVERIFIED_RELAY_FUNDING);
+    }
+    else if (order.inputs.length !== 1 ||
+        (evmChainId(fromChainId) !== undefined &&
+            RELAY_EVM_CHAIN_IDS[order.inputs[0].payment.chainId] !== evmChainId(fromChainId)) ||
+        order.inputs[0].payment.currency !== token || BigInt(order.inputs[0].payment.amount) !== amount) {
+        errors.push(BRIDGE_ERRORS.RELAY_SOURCE_PAYMENT_MISMATCH);
+    }
+    if (errors.length === 0) {
+        const output = order.output.payments[0];
+        Object.assign(parsed, {
+            destinationChainId: RELAY_EVM_CHAIN_IDS[order.output.chainId],
+            outputToken: output.currency, minOutputAmount: BigInt(output.minimumAmount), receiver: output.recipient,
+        });
+    }
+    return errors;
+};
+export const readRelayQuote = (raw, params, metadata) => {
+    const q = object(raw);
+    const protocol = object(object(q.protocol).v2);
+    const order = relayOrder(protocol.orderData, metadata);
+    const orderId = _TypedDataEncoder.hashStruct('Order', ORDER_TYPES, order).toLowerCase();
+    if (orderId !== bytes(protocol.orderId, 32))
+        throw new BridgeError(BRIDGE_ERRORS.RELAY_ORDER_HASH_MISMATCH);
+    if (order.inputs.length !== 1 || order.output.payments.length !== 1 || order.output.calls.length !== 0)
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_ORDER_SHAPE);
+    const source = metadata.find((c) => c.evmId === chain(params.fromChainId));
+    const destination = metadata.find((c) => c.evmId === chain(params.toChainId));
+    if (!source || !destination || order.inputs[0].payment.chainId !== source.protocolId || order.output.chainId !== destination.protocolId)
+        throw new BridgeError(BRIDGE_ERRORS.RELAY_ORDER_CHAIN_MISMATCH);
+    if (source.depository !== getBridgeRouter('relay', params.fromChainId)?.toLowerCase()) {
+        throw new BridgeError(BRIDGE_ERRORS.RELAY_CANONICAL_DEPOSITORY_MISMATCH);
+    }
+    for (const refund of order.inputs[0].refunds) {
+        if (refund.recipient !== address(params.userAddress))
+            throw new BridgeError(BRIDGE_ERRORS.RELAY_REFUND_RECIPIENT_MISMATCH);
+    }
+    const steps = array(q.steps).map(object);
+    const deposits = steps.filter((step) => step.id === 'deposit');
+    if (deposits.length !== 1 || deposits[0].kind !== 'transaction' || deposits[0].depositAddress)
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_DEPOSIT);
+    const items = array(deposits[0].items);
+    if (items.length !== 1)
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_DEPOSIT_COUNT);
+    const tx = transaction(object(items[0]).data, params);
+    const decodedResult = decodeBridgeCalldataResult('relay', tx);
+    if (!decodedResult.ok)
+        throw new BridgeError(BRIDGE_ERRORS.INVALID_CALLDATA, {}, decodedResult.errors);
+    const decoded = decodedResult.parsed;
+    if (!decoded || !['depositNative', 'depositErc20'].includes(decoded.method))
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_DEPOSIT_METHOD);
+    const payment = order.inputs[0].payment;
+    const paymentDetails = object(protocol.paymentDetails);
+    if (tx.to.toLowerCase() !== source.depository || address(paymentDetails.depository) !== source.depository ||
+        paymentDetails.chainId !== source.protocolId || address(paymentDetails.currency) !== payment.currency ||
+        uint(paymentDetails.amount) !== uint(payment.amount) ||
+        decoded.orderId !== orderId || decoded.depositor !== address(params.userAddress) ||
+        decoded.sourceToken !== payment.currency || decoded.sourceAmount !== uint(payment.amount))
+        throw new BridgeError(BRIDGE_ERRORS.RELAY_SOURCE_PAYMENT_MISMATCH);
+    if (payment.currency !== tokenAddress(params.fromTokenId, params.fromChainId) ||
+        uint(tx.value) !== (payment.currency === '0x0000000000000000000000000000000000000000' ? uint(payment.amount) : 0n))
+        throw new BridgeError(BRIDGE_ERRORS.RELAY_SOURCE_VALUE_MISMATCH);
+    // Approval steps are never executed from the response. Verify their semantics,
+    // then expose only the spender so the host can build its own approval.
+    const approvals = steps.filter((step) => step.id === 'approve');
+    if (approvals.length > 1)
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_APPROVAL_COUNT);
+    for (const step of steps) {
+        if (!['approve', 'deposit'].includes(text(step.id)))
+            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_STEP);
+    }
+    for (const step of approvals) {
+        const approvalsItems = array(step.items);
+        if (step.kind !== 'transaction' || approvalsItems.length !== 1)
+            throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_RELAY_APPROVAL);
+        const approval = transaction(object(approvalsItems[0]).data, params);
+        if (!approval.data.startsWith('0x095ea7b3') || approval.to !== payment.currency || uint(approval.value) !== 0n)
+            throw new BridgeError(BRIDGE_ERRORS.RELAY_APPROVAL_MISMATCH);
+        const args = decodeCall([{ name: 'spender', kind: 'address' }, { name: 'amount', kind: 'uint' }], approval.data);
+        if (asString(args.spender) !== source.depository || asBigint(args.amount) !== uint(payment.amount))
+            throw new BridgeError(BRIDGE_ERRORS.RELAY_APPROVAL_MISMATCH);
+    }
+    const output = order.output.payments[0];
+    return {
+        tx, orderId, requestId: bytes(deposits[0].requestId, 32), expectedAmount: uint(output.expectedAmount),
+        approveAddress: payment.currency === '0x0000000000000000000000000000000000000000' ? '' : source.depository,
+        parsed: { ...decoded, destinationChainId: destination.evmId, outputToken: output.currency,
+            minOutputAmount: uint(output.minimumAmount), receiver: output.recipient, unresolvedFields: [] },
+    };
+};

package/dist/providers/socket.d.ts

@@ -0,0 +1,5 @@
+import type { BridgeQuoteListParams } from '../quote.js';
+import type { ProviderQuoteData } from './relay.js';
+export declare const SOCKET_PROVIDER_ROUTES: readonly string[];
+export declare const socketBridgeId: (value: unknown) => string;
+export declare const readSocketQuote: (raw: unknown, rawRoute: unknown, params: BridgeQuoteListParams) => ProviderQuoteData;

package/dist/providers/socket.js

@@ -0,0 +1,58 @@
+import { sourceAmountMatches } from '../calldata/expect.js';
+import { BRIDGE_ERRORS, BridgeError } from '../errors/index.js';
+import { decodeBridgeCalldataResult } from '../calldata/index.js';
+import { SOCKET_CCTP_MINT_RECIPIENT } from '../calldata/socket/addresses.js';
+import { address, bytes, chain, object, text, tokenAddress, transaction, uint } from './data.js';
+export const SOCKET_PROVIDER_ROUTES = Object.freeze(['rfq-vault-executor', 'cctp-v2', 'cctp-v2-slow']);
+export const socketBridgeId = (value) => text(value).trim().toLowerCase().replace(/ /g, '-').replace(/^circle-cctp/, 'cctp');
+export const readSocketQuote = (raw, rawRoute, params) => {
+    const result = object(raw), route = object(rawRoute);
+    const details = object(object(route.routeDetails).bridgeDetails);
+    const bridgeId = socketBridgeId(object(details.protocol).name);
+    if (!SOCKET_PROVIDER_ROUTES.includes(bridgeId) || route.userOp !== 'tx')
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOCKET_SERVICE_ROUTE);
+    const input = object(result.input), inputToken = object(input.token);
+    const output = object(route.output), outputToken = object(output.token);
+    if (uint(result.originChainId) !== chain(params.fromChainId) || uint(result.destinationChainId) !== chain(params.toChainId) ||
+        uint(inputToken.chainId) !== chain(params.fromChainId) || uint(outputToken.chainId) !== chain(params.toChainId) ||
+        address(result.userAddress) !== address(params.userAddress) || address(result.receiverAddress) !== address(params.userAddress) ||
+        tokenAddress(text(inputToken.address), params.fromChainId) !== tokenAddress(params.fromTokenId, params.fromChainId) ||
+        !sourceAmountMatches(uint(input.amount), uint(params.fromTokenRawAmount)))
+        throw new BridgeError(BRIDGE_ERRORS.SOCKET_QUOTE_INPUT_MISMATCH);
+    const txData = object(route.txData);
+    if (txData.kind !== 'evm_tx')
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOCKET_TRANSACTION);
+    const tx = transaction(txData.object, params);
+    const decodedResult = decodeBridgeCalldataResult('socket', tx);
+    if (!decodedResult.ok)
+        throw new BridgeError(BRIDGE_ERRORS.INVALID_CALLDATA, {}, decodedResult.errors);
+    const parsed = decodedResult.parsed;
+    const quoteId = bytes(route.quoteId, 32);
+    if (!parsed || parsed.quoteId !== quoteId || parsed.depositor !== address(params.userAddress) ||
+        parsed.sourceAmount !== uint(input.amount))
+        throw new BridgeError(BRIDGE_ERRORS.SOCKET_SOURCE_QUOTE_MISMATCH);
+    if (bridgeId === 'rfq-vault-executor') {
+        if (parsed.protocolMethod !== 'receiveERC20' || parsed.orderId !== quoteId)
+            throw new BridgeError(BRIDGE_ERRORS.SOCKET_RFQ_ORDER_MISMATCH);
+    }
+    else if (parsed.protocolMethod !== 'depositForBurn' || parsed.bridgeReceiver !== SOCKET_CCTP_MINT_RECIPIENT) {
+        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_SOCKET_CCTP_RECEIVER);
+    }
+    const destinationToken = tokenAddress(text(outputToken.address), params.toChainId);
+    if (parsed.outputToken && tokenAddress(parsed.outputToken, params.toChainId) !== destinationToken)
+        throw new BridgeError(BRIDGE_ERRORS.SOCKET_BRIDGE_OUTPUT_MISMATCH);
+    if (parsed.destinationChainId !== undefined && parsed.destinationChainId !== chain(params.toChainId))
+        throw new BridgeError(BRIDGE_ERRORS.SOCKET_BRIDGE_CHAIN_MISMATCH);
+    const approval = route.approval ? object(route.approval) : undefined;
+    const native = tokenAddress(params.fromTokenId, params.fromChainId) === '0x0000000000000000000000000000000000000000';
+    if (!native && (!approval || address(approval.tokenAddress) !== tokenAddress(params.fromTokenId, params.fromChainId) ||
+        address(approval.userAddress) !== address(params.userAddress) || uint(approval.amount) !== uint(input.amount)))
+        throw new BridgeError(BRIDGE_ERRORS.SOCKET_APPROVAL_MISMATCH);
+    return {
+        tx, orderId: quoteId, requestId: quoteId,
+        approveAddress: native ? '' : address(approval.spenderAddress),
+        expectedAmount: uint(output.amount),
+        parsed: { ...parsed, destinationChainId: chain(params.toChainId), outputToken: destinationToken,
+            minOutputAmount: uint(output.minAmountOut), receiver: address(result.receiverAddress), unresolvedFields: [] },
+    };
+};

package/dist/quote.d.ts

@@ -1,6 +1,29 @@
+import type { BridgeErrorReporter } from './errors/index.js';
+import { BridgeError } from './errors/index.js';
 import type { OpenApiService } from '@rabby-wallet/rabby-api';
+import type { BridgeCallExpectation } from './calldata/expect.js';
+import type { BridgeCheck } from './calldata/types.js';
 import type { BridgeAggregatorId } from './consts.js';
-export interface BridgeQuoteListParams {
+export interface BridgeValidationOptions {
+    /** Receives filtered quote failures and calldata failures. */
+    onError?: BridgeErrorReporter;
+    /**
+     * Test-only. Production callers must leave this unset: a missing Relay
+     * orderData then fails validation.
+     */
+    allowMissingRelayOrder?: boolean;
+}
+export type BridgeValidationResult = {
+    /** Whether the transaction passes all required checks. */
+    pass: boolean;
+    routerPass: boolean;
+    fromPass: boolean;
+    toPass: boolean;
+    receiverPass: boolean;
+    unverifiedFields: string[];
+    errors: BridgeCheck['errors'];
+};
+export interface BridgeQuoteListParams extends BridgeValidationOptions {
     userAddress: string;
     fromChainId: string;
     fromTokenId: string;
@@ -13,12 +36,16 @@ export interface BridgeQuoteListParams {
 export interface BridgeBuildTxParams extends BridgeQuoteListParams {
     bridgeId: string;
     quoteKey?: string | Record<string, unknown>;
+    /** Quoted output in raw units, before applying slippage. */
+    toTokenRawAmount?: string;
+    /** Relay `protocol.v2.orderData` from the build that produced this transaction. */
+    orderData?: unknown;
 }
 export type BridgeApi = Pick<OpenApiService, 'getBridgeQuoteListV2' | 'getBridgeQuoteV2' | 'buildBridgeTx' | 'getBridgeQuoteTxV2'>;
 export type BridgeQuote = Awaited<ReturnType<BridgeApi['getBridgeQuoteTxV2']>>;
 export type BridgeTx = Awaited<ReturnType<BridgeApi['buildBridgeTx']>> | NonNullable<BridgeQuote['tx']>;
 export type BridgeQuoteListItem = Awaited<ReturnType<BridgeApi['getBridgeQuoteV2']>>[number];
-export declare class InvalidBridgeContractError extends Error {
+export declare class InvalidBridgeContractError extends BridgeError {
     readonly kind: 'spender' | 'router';
     readonly aggregatorId: BridgeAggregatorId;
     readonly chainId: string;
@@ -28,7 +55,7 @@ export declare class InvalidBridgeContractError extends Error {
     constructor(kind: 'spender' | 'router', aggregatorId: BridgeAggregatorId, chainId: string, expected: string, received: string, bridgeId?: string | undefined);
 }
 export declare const validateBridgeQuote: (aggregatorId: BridgeAggregatorId, fromChainId: string, quote: BridgeQuoteListItem) => boolean;
-export declare const validateBridgeTx: (aggregatorId: BridgeAggregatorId, fromChainId: string, bridgeId: string, tx: BridgeTx) => boolean;
+export declare const validateBridgeTx: (aggregatorId: BridgeAggregatorId, fromChainId: string, bridgeId: string, tx: BridgeTx, expectation?: BridgeCallExpectation, options?: BridgeValidationOptions) => BridgeValidationResult;
 export declare const getQuote: (aggregatorId: string, params: BridgeQuoteListParams, api: BridgeApi) => Promise<BridgeQuoteListItem[]>;
 export declare const buildTx: (aggregatorId: string, params: BridgeBuildTxParams, api: BridgeApi) => Promise<BridgeTx>;
 export declare const getQuoteListWithTx: (aggregatorId: string, params: BridgeQuoteListParams, api: BridgeApi) => Promise<Array<BridgeQuoteListItem & {