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

package/dist/calldata/lifi/params.js

@@ -1,347 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
-import { innerCallDiagnostics } from '../diagnostics.js';
-import { asArray, asBigint, asRecord, asString, } from '../abi.js';
-import { accountFromBytes32 } from '../hex.js';
-import { readMayanProtocol } from '../mayan/readProtocol.js';
-import { LAYERZERO_CHAINS, subtractFees } from '../protocols.js';
-import { readLifiDestination } from './destination.js';
-import { swapDataParam } from './swapData.js';
-export { applyFirstSwap, swapDataArrayParam, swapDataParam } from './swapData.js';
-export const bridgeDataParam = {
-    name: 'bridgeData',
-    kind: 'tuple',
-    components: [
-        { name: 'transactionId', kind: 'bytes', size: 32 },
-        { name: 'bridge', kind: 'string' },
-        { name: 'integrator', kind: 'string' },
-        { name: 'referrer', kind: 'address' },
-        { name: 'sendingAssetId', kind: 'address' },
-        { name: 'receiver', kind: 'address' },
-        { name: 'minAmount', kind: 'uint' },
-        { name: 'destinationChainId', kind: 'uint' },
-        { name: 'hasSourceSwaps', kind: 'bool' },
-        { name: 'hasDestinationCall', kind: 'bool' },
-    ],
-};
-export const acrossDataParam = {
-    name: 'acrossData',
-    kind: 'tuple',
-    components: [
-        { name: 'receiverAddress', kind: 'bytes', size: 32 },
-        { name: 'refundAddress', kind: 'bytes', size: 32 },
-        { name: 'sendingAssetId', kind: 'bytes', size: 32 },
-        { name: 'receivingAssetId', kind: 'bytes', size: 32 },
-        { name: 'outputAmount', kind: 'uint' },
-        { name: 'outputAmountMultiplier', 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 stargateDataParam = {
-    name: 'stargateData',
-    kind: 'tuple',
-    components: [
-        { name: 'assetId', kind: 'uint' },
-        {
-            name: 'sendParams',
-            kind: 'tuple',
-            components: [
-                { name: 'dstEid', kind: 'uint' },
-                { name: 'to', kind: 'bytes', size: 32 },
-                { name: 'amountLD', kind: 'uint' },
-                { name: 'minAmountLD', kind: 'uint' },
-                { name: 'extraOptions', kind: 'bytes' },
-                { name: 'composeMsg', kind: 'bytes' },
-                { name: 'oftCmd', kind: 'bytes' },
-            ],
-        },
-        {
-            name: 'fee',
-            kind: 'tuple',
-            components: [
-                { name: 'nativeFee', kind: 'uint' },
-                { name: 'lzTokenFee', kind: 'uint' },
-            ],
-        },
-        { name: 'refundAddress', kind: 'address' },
-    ],
-};
-export const relayDepositoryDataParam = {
-    name: 'relayDepositoryData',
-    kind: 'tuple',
-    components: [
-        { name: 'orderId', kind: 'bytes', size: 32 },
-        { name: 'depositorAddress', kind: 'address' },
-    ],
-};
-export const mayanDataParam = {
-    name: 'mayanData',
-    kind: 'tuple',
-    components: [
-        { name: 'nonEVMReceiver', kind: 'bytes', size: 32 },
-        { name: 'mayanProtocol', kind: 'address' },
-        { name: 'protocolData', kind: 'bytes' },
-        { name: 'swapProtocol', kind: 'address' },
-        { name: 'swapData', kind: 'bytes' },
-        { name: 'middleToken', kind: 'address' },
-        { name: 'minMiddleAmount', kind: 'uint' },
-        { name: 'refundRecipient', kind: 'address' },
-        { name: 'mayanAmountIn', kind: 'uint' },
-    ],
-};
-export const gasZipDataParam = {
-    name: 'gasZipData',
-    kind: 'tuple',
-    components: [
-        { name: 'receiverAddress', kind: 'bytes', size: 32 },
-        { name: 'destinationChains', kind: 'uint' },
-    ],
-};
-export const squidDataParam = {
-    name: 'squidData',
-    kind: 'tuple',
-    components: [
-        { name: 'routeType', kind: 'uint' },
-        { name: 'destinationChain', kind: 'string' },
-        { name: 'destinationAddress', kind: 'string' },
-        { name: 'bridgedTokenSymbol', kind: 'string' },
-        { name: 'depositAssetId', kind: 'address' },
-        {
-            name: 'sourceCalls',
-            kind: 'array',
-            item: {
-                name: 'call',
-                kind: 'tuple',
-                components: [
-                    { name: 'callType', kind: 'uint' },
-                    { name: 'target', kind: 'address' },
-                    { name: 'value', kind: 'uint' },
-                    { name: 'callData', kind: 'bytes' },
-                    { name: 'payload', kind: 'bytes' },
-                ],
-            },
-        },
-        { name: 'payload', kind: 'bytes' },
-        { name: 'fee', kind: 'uint' },
-        { name: 'enableExpress', kind: 'bool' },
-    ],
-};
-export const acrossPackedParam = {
-    name: 'parameters',
-    kind: 'tuple',
-    components: [
-        { name: 'transactionId', kind: 'bytes', size: 8 },
-        { name: 'receiver', kind: 'bytes', size: 32 },
-        { name: 'depositor', kind: 'bytes', size: 32 },
-        { name: 'destinationChainId', kind: 'uint' },
-        { name: 'receivingAssetId', kind: 'bytes', size: 32 },
-        { name: 'outputAmount', 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 applyBridgeData = (method, raw) => {
-    const data = asRecord(raw);
-    return {
-        aggregatorId: 'lifi',
-        method,
-        kind: 'bridge',
-        sourceToken: asString(data.sendingAssetId),
-        sourceAmount: asBigint(data.minAmount),
-        bridgeToken: asString(data.sendingAssetId),
-        bridgeAmount: asBigint(data.minAmount),
-        destinationChainId: asBigint(data.destinationChainId),
-        receiver: asString(data.receiver),
-        bridgeReceiver: asString(data.receiver),
-        referrer: asString(data.referrer),
-    };
-};
-export const applyAcrossData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.receiver = accountFromBytes32(asString(data.receiverAddress));
-    parsed.outputToken = accountFromBytes32(asString(data.receivingAssetId));
-    parsed.minOutputAmount = asBigint(data.outputAmount);
-};
-export const applyStargateData = (parsed, raw) => {
-    const send = asRecord(asRecord(raw).sendParams);
-    parsed.receiver = accountFromBytes32(asString(send.to));
-    parsed.minOutputAmount = asBigint(send.minAmountLD);
-};
-export const applyRelayDepositoryData = (parsed, raw) => {
-    parsed.orderId = asString(asRecord(raw).orderId);
-};
-export const applyMayanData = (parsed, raw) => {
-    const data = asRecord(raw);
-    const receiver = accountFromBytes32(asString(data.nonEVMReceiver));
-    if (!/^0x0*$/.test(receiver)) {
-        parsed.receiver = receiver;
-    }
-    parsed.innerTarget = asString(data.mayanProtocol);
-    parsed.diagnostics = innerCallDiagnostics(asString(data.protocolData), 'protocol');
-    const protocol = readMayanProtocol(asString(data.protocolData), asBigint(data.minMiddleAmount) > 0n ? asBigint(data.minMiddleAmount) : parsed.bridgeAmount);
-    if (!protocol)
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_MAYAN_PROTOCOL_CALLDATA, parsed.diagnostics);
-    const { sourceToken, sourceAmount, aggregatorId, method, kind, ...destination } = protocol;
-    Object.assign(parsed, destination);
-};
-export const applyGasZipData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.receiver = accountFromBytes32(asString(data.receiverAddress));
-    parsed.destinationChainRef = asBigint(data.destinationChains).toString();
-};
-export const applySquidData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.destinationChainRef = asString(data.destinationChain);
-    parsed.receiver = asString(data.destinationAddress);
-    parsed.sourceToken = asString(data.depositAssetId);
-};
-export const polymerDataParam = {
-    name: 'polymerData',
-    kind: 'tuple',
-    components: [
-        { name: 'polymerTokenFee', kind: 'uint' },
-        { name: 'maxCCTPFee', kind: 'uint' },
-        { name: 'nonEVMReceiver', kind: 'bytes', size: 32 },
-        { name: 'solanaReceiverATA', kind: 'bytes', size: 32 },
-        { name: 'minFinalityThreshold', kind: 'uint' },
-        { name: 'refundRecipient', kind: 'address' },
-        { name: 'hookData', kind: 'bytes' },
-    ],
-};
-export const lifiIntentDataParam = {
-    name: 'lifiIntentData',
-    kind: 'tuple',
-    components: [
-        { name: 'dstCallReceiver', kind: 'bytes', size: 32 },
-        { name: 'recipient', kind: 'bytes', size: 32 },
-        { name: 'depositAndRefundAddress', kind: 'address' },
-        { name: 'nonce', kind: 'uint' },
-        { name: 'expires', kind: 'uint' },
-        { name: 'fillDeadline', kind: 'uint' },
-        { name: 'inputOracle', kind: 'address' },
-        { name: 'outputOracle', kind: 'bytes', size: 32 },
-        { name: 'outputSettler', kind: 'bytes', size: 32 },
-        { name: 'outputToken', kind: 'bytes', size: 32 },
-        { name: 'outputAmountMultiplier', kind: 'uint' },
-        { name: 'dstCallSwapData', kind: 'array', item: swapDataParam },
-        { name: 'outputContext', kind: 'bytes' },
-    ],
-};
-export const layerSwapDataParam = {
-    name: 'layerSwapData',
-    kind: 'tuple',
-    components: [
-        { name: 'requestId', kind: 'bytes', size: 32 },
-        { name: 'depositoryReceiver', kind: 'address' },
-        { name: 'refundRecipient', kind: 'address' },
-        { name: 'nonEVMReceiver', kind: 'bytes', size: 32 },
-        { name: 'signature', kind: 'bytes' },
-        { name: 'deadline', kind: 'uint' },
-    ],
-};
-export const applyPolymerData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.outputTokenReference = { protocol: 'cctp', destinationChainId: parsed.destinationChainId };
-    parsed.minOutputAmount = subtractFees(parsed.bridgeAmount ?? 0n, asBigint(data.polymerTokenFee), asBigint(data.maxCCTPFee));
-    if (asString(data.hookData) !== '0x') {
-        parsed.destinationCallData = asString(data.hookData);
-        delete parsed.receiver;
-        delete parsed.outputTokenReference;
-        delete parsed.minOutputAmount;
-    }
-};
-export const applyLifiIntentData = (parsed, raw) => {
-    const data = asRecord(raw);
-    parsed.receiver = accountFromBytes32(asString(data.recipient));
-    parsed.outputToken = accountFromBytes32(asString(data.outputToken));
-    parsed.minOutputAmount = (parsed.bridgeAmount ?? 0n) * asBigint(data.outputAmountMultiplier) / 10n ** 18n;
-    if (asArray(data.dstCallSwapData).length) {
-        const destination = readLifiDestination(parsed, data);
-        parsed.hasDestinationCall = true;
-        parsed.bridgeReceiver = accountFromBytes32(asString(data.dstCallReceiver));
-        parsed.bridgeOutputToken = parsed.outputToken;
-        parsed.bridgeOutputAmount = parsed.minOutputAmount;
-        delete parsed.receiver;
-        delete parsed.outputToken;
-        delete parsed.minOutputAmount;
-        // Unknown deployments and arbitrary calls remain unverified.
-        if (destination)
-            Object.assign(parsed, destination);
-    }
-    parsed.orderId = asBigint(data.nonce).toString(16).padStart(64, '0');
-    parsed.orderId = `0x${parsed.orderId}`;
-};
-export const celerCircleDataParam = {
-    name: 'celerCircleData',
-    kind: 'tuple',
-    components: [
-        { name: 'maxFee', kind: 'uint' },
-        { name: 'minFinalityThreshold', kind: 'uint' },
-    ],
-};
-const paxosRouteParam = {
-    name: 'route',
-    kind: 'tuple',
-    components: [
-        { name: 'destEID', kind: 'uint' },
-        { name: 'offerAsset', kind: 'address' },
-        { name: 'wantAsset', kind: 'address' },
-    ],
-};
-export const paxosDataParam = {
-    name: 'paxosData',
-    kind: 'tuple',
-    components: [
-        {
-            name: 'quote',
-            kind: 'tuple',
-            components: [
-                paxosRouteParam,
-                { name: 'offerAmount', kind: 'uint' },
-                { name: 'receiver', kind: 'address' },
-                { name: 'protocolFee', kind: 'uint' },
-                { name: 'integratorFee', kind: 'uint' },
-                { name: 'integratorFeeReceiver', kind: 'address' },
-                { name: 'distributorCode', kind: 'bytes', size: 32 },
-                { name: 'deadline', kind: 'uint' },
-                { name: 'salt', kind: 'bytes', size: 32 },
-            ],
-        },
-        { name: 'signature', kind: 'bytes' },
-        { name: 'nativeFee', kind: 'uint' },
-        { name: 'refundRecipient', kind: 'address' },
-    ],
-};
-export const applyPaxosData = (parsed, raw) => {
-    const quote = asRecord(asRecord(raw).quote);
-    const route = asRecord(quote.route);
-    parsed.destinationChainRef = `layerzero:${asBigint(route.destEID)}`;
-    parsed.destinationChainId = LAYERZERO_CHAINS[asBigint(route.destEID).toString()];
-    parsed.outputToken = asString(route.wantAsset);
-    const offerAmount = asBigint(quote.offerAmount);
-    parsed.minOutputAmount = subtractFees(offerAmount, asBigint(quote.protocolFee), asBigint(quote.integratorFee));
-    const receiver = asString(quote.receiver);
-    parsed.receiver = receiver;
-};
-export const applyLayerSwapData = (parsed, raw) => {
-    const data = asRecord(raw);
-    if (asString(data.refundRecipient) !== parsed.receiver)
-        throw new BridgeError(BRIDGE_ERRORS.LAYERSWAP_REFUND_RECIPIENT_MISMATCH);
-    if (!/^0x0*$/.test(asString(data.nonEVMReceiver)))
-        throw new BridgeError(BRIDGE_ERRORS.UNSUPPORTED_LAYERSWAP_NON_EVM_RECEIVER);
-    parsed.orderId = asString(data.requestId);
-    // The LayerSwap signature binds bridgeData.receiver to this request ID.
-};
-export const applyCelerCircleData = (parsed, raw) => {
-    parsed.outputTokenReference = { protocol: 'cctp', destinationChainId: parsed.destinationChainId };
-    parsed.outputAmountReference = {
-        kind: 'fees', amount: parsed.bridgeAmount ?? 0n,
-        token: parsed.outputTokenReference, maxFee: asBigint(asRecord(raw).maxFee),
-    };
-};

package/dist/calldata/lifi/paxos/index.d.ts

@@ -1,4 +0,0 @@
-import type { CalldataMethod } from '../../abi.js';
-export declare const methods: CalldataMethod[];
-export declare const compare: (parsed: import("../../types.js").ParsedBridgeCall) => import("../../expect.js").CompareMask;
-export declare const check: (parsed: import("../../types.js").ParsedBridgeCall) => import("../../../index.js").BridgeErrorDefinition | undefined;

package/dist/calldata/lifi/paxos/index.js

@@ -1,10 +0,0 @@
-import { knownCompare } from '../../expect.js';
-import { bridgeShape } from '../shape.js';
-import { lifiBridgeMethod } from '../method.js';
-import { applyPaxosData, paxosDataParam } from '../params.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaPaxosTransit', '0x5080ffe2', [paxosDataParam], false, (parsed, args) => applyPaxosData(parsed, args.paxosData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaPaxosTransit', '0x637f1d04', [paxosDataParam], true, (parsed, args) => applyPaxosData(parsed, args.paxosData)),
-];
-export const compare = knownCompare;
-export const check = bridgeShape;

package/dist/calldata/lifi/polymer/index.d.ts

@@ -1,4 +0,0 @@
-import type { CalldataMethod } from '../../abi.js';
-export declare const methods: CalldataMethod[];
-export declare const compare: (parsed: import("../../types.js").ParsedBridgeCall) => import("../../expect.js").CompareMask;
-export declare const check: (parsed: import("../../types.js").ParsedBridgeCall) => import("../../../index.js").BridgeErrorDefinition | undefined;

package/dist/calldata/lifi/polymer/index.js

@@ -1,10 +0,0 @@
-import { knownCompare } from '../../expect.js';
-import { bridgeShape } from '../shape.js';
-import { lifiBridgeMethod } from '../method.js';
-import { applyPolymerData, polymerDataParam } from '../params.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaPolymerCCTP', '0xf434d6ca', [polymerDataParam], false, (parsed, args) => applyPolymerData(parsed, args.polymerData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaPolymerCCTP', '0x17917a4e', [polymerDataParam], true, (parsed, args) => applyPolymerData(parsed, args.polymerData)),
-];
-export const compare = knownCompare;
-export const check = bridgeShape;

package/dist/calldata/lifi/relay/index.d.ts

@@ -1,6 +0,0 @@
-import type { CalldataMethod } from '../../abi.js';
-import type { CompareMask } from '../../expect.js';
-import type { ParsedBridgeCall } from '../../types.js';
-export declare const methods: CalldataMethod[];
-export declare const compare: (parsed: ParsedBridgeCall) => CompareMask;
-export declare const check: (parsed: ParsedBridgeCall) => import("../../../index.js").BridgeErrorDefinition | undefined;

package/dist/calldata/lifi/relay/index.js

@@ -1,15 +0,0 @@
-import { bridgeShape } from '../shape.js';
-import { applyRelayDepositoryData, relayDepositoryDataParam } from '../params.js';
-import { lifiBridgeMethod } from '../method.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaRelayDepository', '0x092e8fa4', [relayDepositoryDataParam], false, (parsed, args) => applyRelayDepositoryData(parsed, args.relayDepositoryData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaRelayDepository', '0xa3443faa', [relayDepositoryDataParam], true, (parsed, args) => applyRelayDepositoryData(parsed, args.relayDepositoryData)),
-];
-export const compare = (parsed) => ({
-    fromToken: parsed.sourceToken !== undefined,
-    fromAmount: parsed.sourceAmount !== undefined,
-    toToken: false,
-    toAmount: false,
-    receiver: true,
-});
-export const check = bridgeShape;

package/dist/calldata/lifi/shape.d.ts

@@ -1,4 +0,0 @@
-import type { BridgeErrorDefinition } from '../../errors/index.js';
-import type { ParsedBridgeCall } from '../types.js';
-export declare const bridgeShape: (parsed: ParsedBridgeCall) => BridgeErrorDefinition | undefined;
-export declare const swapShape: (parsed: ParsedBridgeCall) => BridgeErrorDefinition | undefined;

package/dist/calldata/lifi/shape.js

@@ -1,31 +0,0 @@
-import { BRIDGE_ERRORS } from '../../errors/index.js';
-import { isZeroWord } from '../hex.js';
-export const bridgeShape = (parsed) => {
-    if (isZeroWord(parsed.receiver ?? parsed.bridgeReceiver)) {
-        return BRIDGE_ERRORS.MISSING_RECEIVER;
-    }
-    const hasDestination = (parsed.destinationChainId !== undefined && parsed.destinationChainId > 0n) ||
-        Boolean(parsed.destinationChainRef);
-    if (!hasDestination) {
-        return BRIDGE_ERRORS.MISSING_DESTINATION_CHAIN;
-    }
-    if (parsed.method.startsWith('swapAnd') && (parsed.sourceAmount ?? 0n) <= 0n) {
-        return BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT;
-    }
-    if (parsed.sourceToken === undefined) {
-        return BRIDGE_ERRORS.MISSING_SOURCE_TOKEN;
-    }
-    return undefined;
-};
-export const swapShape = (parsed) => {
-    if (!parsed.receiver || isZeroWord(parsed.receiver)) {
-        return BRIDGE_ERRORS.MISSING_RECEIVER;
-    }
-    if (parsed.minOutputAmount === undefined) {
-        return BRIDGE_ERRORS.MISSING_MIN_OUTPUT;
-    }
-    if ((parsed.sourceAmount ?? 0n) <= 0n) {
-        return BRIDGE_ERRORS.MISSING_SOURCE_AMOUNT;
-    }
-    return undefined;
-};

package/dist/calldata/lifi/squid/index.d.ts

@@ -1,6 +0,0 @@
-import type { CalldataMethod } from '../../abi.js';
-import type { CompareMask } from '../../expect.js';
-import type { ParsedBridgeCall } from '../../types.js';
-export declare const methods: CalldataMethod[];
-export declare const compare: (parsed: ParsedBridgeCall) => CompareMask;
-export declare const check: (parsed: ParsedBridgeCall) => import("../../../index.js").BridgeErrorDefinition | undefined;

package/dist/calldata/lifi/squid/index.js

@@ -1,15 +0,0 @@
-import { bridgeShape } from '../shape.js';
-import { applySquidData, squidDataParam } from '../params.js';
-import { lifiBridgeMethod } from '../method.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaSquid', '0x3f313808', [squidDataParam], false, (parsed, args) => applySquidData(parsed, args.squidData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaSquid', '0xa8f66666', [squidDataParam], true, (parsed, args) => applySquidData(parsed, args.squidData)),
-];
-export const compare = (parsed) => ({
-    fromToken: parsed.sourceToken !== undefined,
-    fromAmount: parsed.sourceAmount !== undefined,
-    toToken: false,
-    toAmount: false,
-    receiver: true,
-});
-export const check = bridgeShape;

package/dist/calldata/lifi/stargate/index.d.ts

@@ -1,5 +0,0 @@
-import type { CalldataMethod } from '../../abi.js';
-import type { CompareMask } from '../../expect.js';
-export declare const methods: CalldataMethod[];
-export declare const compare: () => CompareMask;
-export declare const check: (parsed: import("../../types.js").ParsedBridgeCall) => import("../../../index.js").BridgeErrorDefinition | undefined;

package/dist/calldata/lifi/stargate/index.js

@@ -1,15 +0,0 @@
-import { bridgeShape } from '../shape.js';
-import { applyStargateData, stargateDataParam } from '../params.js';
-import { lifiBridgeMethod } from '../method.js';
-export const methods = [
-    lifiBridgeMethod('startBridgeTokensViaStargate', '0x14d53077', [stargateDataParam], false, (parsed, args) => applyStargateData(parsed, args.stargateData)),
-    lifiBridgeMethod('swapAndStartBridgeTokensViaStargate', '0xa6010a66', [stargateDataParam], true, (parsed, args) => applyStargateData(parsed, args.stargateData)),
-];
-export const compare = () => ({
-    fromToken: true,
-    fromAmount: true,
-    toToken: false,
-    toAmount: true,
-    receiver: true,
-});
-export const check = bridgeShape;

package/dist/calldata/lifi/swap/index.d.ts

@@ -1,5 +0,0 @@
-import type { CalldataMethod } from '../../abi.js';
-import type { CompareMask } from '../../expect.js';
-export declare const methods: CalldataMethod[];
-export declare const compare: () => CompareMask;
-export declare const check: (parsed: import("../../types.js").ParsedBridgeCall) => import("../../../index.js").BridgeErrorDefinition | undefined;

package/dist/calldata/lifi/swap/index.js

@@ -1,18 +0,0 @@
-import { swapShape } from '../shape.js';
-import { lifiSwapMethod } from './swapMethod.js';
-export const methods = [
-    lifiSwapMethod('swapTokensSingleV3ERC20ToERC20', '0x4666fc80', false),
-    lifiSwapMethod('swapTokensSingleV3ERC20ToNative', '0x733214a3', false),
-    lifiSwapMethod('swapTokensSingleV3NativeToERC20', '0xaf7060fd', false),
-    lifiSwapMethod('swapTokensMultipleV3ERC20ToERC20', '0x5fd9ae2e', true),
-    lifiSwapMethod('swapTokensMultipleV3ERC20ToNative', '0x2c57e884', true),
-    lifiSwapMethod('swapTokensMultipleV3NativeToERC20', '0x736eac0b', true),
-];
-export const compare = () => ({
-    fromToken: true,
-    fromAmount: true,
-    toToken: true,
-    toAmount: true,
-    receiver: true,
-});
-export const check = swapShape;

package/dist/calldata/lifi/swap/swapMethod.d.ts

@@ -1,2 +0,0 @@
-import type { CalldataMethod } from '../../abi.js';
-export declare const lifiSwapMethod: (name: string, selector: string, multiple: boolean) => CalldataMethod;

package/dist/calldata/lifi/swap/swapMethod.js

@@ -1,40 +0,0 @@
-import { asArray, asBigint, asRecord, asString, decodeCall } from '../../abi.js';
-import { applyFirstSwap, swapDataArrayParam, swapDataParam } from '../swapData.js';
-const header = [
-    { name: 'transactionId', kind: 'bytes', size: 32 },
-    { name: 'integrator', kind: 'string' },
-    { name: 'referrer', kind: 'string' },
-    { name: 'receiver', kind: 'address' },
-    { name: 'minAmountOut', kind: 'uint' },
-];
-export const lifiSwapMethod = (name, selector, multiple) => ({
-    name,
-    selector,
-    decode(data, value) {
-        const args = decodeCall([...header, multiple ? swapDataArrayParam : swapDataParam], data);
-        const parsed = {
-            aggregatorId: 'lifi',
-            method: name,
-            kind: 'swap',
-            receiver: asString(args.receiver),
-            referrer: asString(args.referrer),
-            minOutputAmount: asBigint(args.minAmountOut),
-        };
-        if (multiple) {
-            applyFirstSwap(parsed, args.swapData);
-            const swaps = asArray(args.swapData).map(asRecord);
-            if (swaps.length)
-                parsed.outputToken = asString(swaps[swaps.length - 1].receivingAssetId);
-        }
-        else {
-            const swap = asRecord(args.swapData);
-            parsed.sourceToken = asString(swap.sendingAssetId);
-            parsed.sourceAmount = asBigint(swap.fromAmount);
-            parsed.outputToken = asString(swap.receivingAssetId);
-        }
-        if ((parsed.sourceAmount ?? 0n) === 0n && value > 0n) {
-            parsed.sourceAmount = value;
-        }
-        return parsed;
-    },
-});

package/dist/calldata/lifi/swapData.d.ts

@@ -1,5 +0,0 @@
-import { type AbiParam, type AbiValue } from '../abi.js';
-import type { ParsedBridgeCall } from '../types.js';
-export declare const swapDataArrayParam: AbiParam;
-export declare const swapDataParam: AbiParam;
-export declare const applyFirstSwap: (parsed: ParsedBridgeCall, raw: AbiValue) => void;

package/dist/calldata/lifi/swapData.js

@@ -1,33 +0,0 @@
-import { BRIDGE_ERRORS, BridgeError } from '../../errors/index.js';
-import { asArray, asBigint, asRecord, asString } from '../abi.js';
-const swapComponents = [
-    { name: 'callTo', kind: 'address' },
-    { name: 'approveTo', kind: 'address' },
-    { name: 'sendingAssetId', kind: 'address' },
-    { name: 'receivingAssetId', kind: 'address' },
-    { name: 'fromAmount', kind: 'uint' },
-    { name: 'callData', kind: 'bytes' },
-    { name: 'requiresDeposit', kind: 'bool' },
-];
-export const swapDataArrayParam = {
-    name: 'swapData', kind: 'array',
-    item: { name: 'swap', kind: 'tuple', components: swapComponents },
-};
-export const swapDataParam = {
-    name: 'swapData', kind: 'tuple', components: swapComponents,
-};
-export const applyFirstSwap = (parsed, raw) => {
-    const swaps = asArray(raw);
-    const deposits = swaps.map(asRecord).filter((swap) => swap.requiresDeposit === true);
-    const first = deposits[0] ?? swaps[0];
-    if (!first)
-        return;
-    const swap = asRecord(first);
-    parsed.sourceToken = asString(swap.sendingAssetId);
-    if (deposits.some((deposit) => asString(deposit.sendingAssetId) !== parsed.sourceToken)) {
-        throw new BridgeError(BRIDGE_ERRORS.MULTIPLE_SOURCE_ASSETS_ARE_NOT_SUPPORTED);
-    }
-    parsed.sourceAmount = deposits.length
-        ? deposits.reduce((sum, deposit) => sum + asBigint(deposit.fromAmount), 0n)
-        : asBigint(swap.fromAmount);
-};

package/dist/calldata/match.d.ts

@@ -1,3 +0,0 @@
-import type { CalldataMethod } from './abi.js';
-import type { DecodeHit } from './types.js';
-export declare const matchMethod: (methods: CalldataMethod[], data: string, value: bigint) => DecodeHit;

package/dist/calldata/match.js

@@ -1,21 +0,0 @@
-import { BRIDGE_ERRORS, asBridgeError, bridgeFailure } from '../errors/index.js';
-import { readSelector } from './hex.js';
-import { resolveParsed } from './resolve.js';
-import { calldataDiagnostics } from './diagnostics.js';
-export const matchMethod = (methods, data, value) => {
-    const selector = readSelector(data);
-    const diagnostics = calldataDiagnostics(data);
-    if (!selector)
-        return bridgeFailure([{ ...(data && data !== '0x' ? BRIDGE_ERRORS.INVALID_SELECTOR : BRIDGE_ERRORS.MISSING_CALLDATA), ...diagnostics }]);
-    for (const method of methods) {
-        if (method.selector !== selector)
-            continue;
-        try {
-            return { ok: true, parsed: resolveParsed(method.decode(data, value)) };
-        }
-        catch (error) {
-            return { ...bridgeFailure(asBridgeError(error, BRIDGE_ERRORS.CALLDATA_DECODE_FAILED, { method: method.name, ...diagnostics }).errors), method: method.name };
-        }
-    }
-    return bridgeFailure([{ ...BRIDGE_ERRORS.UNSUPPORTED_METHOD, ...diagnostics }]);
-};

package/dist/calldata/mayan/destination.d.ts

@@ -1,2 +0,0 @@
-import type { ParsedBridgeCall } from '../types.js';
-export declare const mayanDestination: (system: "cctp" | "wormhole", id: bigint, token?: string, normalizedAmount?: bigint) => Partial<ParsedBridgeCall>;

package/dist/calldata/mayan/destination.js

@@ -1,13 +0,0 @@
-import { CCTP_CHAINS, WORMHOLE_CHAINS } from '../protocols.js';
-export const mayanDestination = (system, id, token, normalizedAmount) => {
-    const destinationChainId = (system === 'cctp' ? CCTP_CHAINS : WORMHOLE_CHAINS)[id.toString()];
-    const destinationChainRef = `${system}:${id}`;
-    return {
-        destinationChainId, destinationChainRef,
-        outputToken: token,
-        outputAmountReference: token !== undefined && normalizedAmount !== undefined ? {
-            kind: 'normalized', amount: normalizedAmount, decimals: 8,
-            token: { protocol: 'token', token, destinationChainId, destinationChainRef },
-        } : undefined,
-    };
-};

package/dist/calldata/mayan/fastMctpBridge.d.ts

@@ -1,3 +0,0 @@
-import type { ParsedBridgeCall } from '../types.js';
-export declare const FAST_MCTP_BRIDGE = "0xf58b6de8";
-export declare const decodeFastMctpBridge: (data: string, amountFloor?: bigint) => Partial<ParsedBridgeCall>;