@1delta/trade-sdk 0.1.8 → 0.1.10

package/dist/aggregator/fetchAggregatorTrade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fetchAggregatorTrade.d.ts","sourceRoot":"","sources":["../../src/aggregator/fetchAggregatorTrade.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,kBAAkB,EAIlB,YAAY,EACZ,aAAa,EAEd,MAAM,mBAAmB,CAAA;AAe1B,eAAO,MAAM,oBAAoB,GAC/B,YAAY,MAAM,EAClB,OAAO,kBAAkB,GAAG,aAAa,EACzC,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAelC,CAAA"}
+{"version":3,"file":"fetchAggregatorTrade.d.ts","sourceRoot":"","sources":["../../src/aggregator/fetchAggregatorTrade.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,kBAAkB,EAIlB,YAAY,EACZ,aAAa,EAEd,MAAM,mBAAmB,CAAA;AAe1B,eAAO,MAAM,oBAAoB,GAC/B,YAAY,MAAM,EAClB,OAAO,kBAAkB,GAAG,aAAa,EACzC,aAAa,eAAe,KAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAelC,CAAA"}

package/dist/aggregator/fetchAggregatorTrade.js

@@ -1,5 +1,6 @@
 import { fetchAggregatorTrade as fetchAggregatorTradeWithoutConfigs, TradeAggregator, } from '@1delta/aggregators';
 import { getSwapAggregators } from '@1delta/bridge-configs';
+import { getAllConfigs } from '@1delta/bridge-core';
 import { ChainType, ChainUtils, TradeType, } from '@1delta/lib-utils';
 import { fetchBridgeTrade } from '../bridge/fetchBridgeTrade';
 import { createSwapAndBridgeCalldata, requireDeltaContracts, } from '../composedTrades/utils';
@@ -76,7 +77,8 @@ const fetchSwapTrade = async (aggregator, input, controller) => {
     return fetchExactInSwapTrade(aggregator, input, controller);
 };
 const fetchExactInSwapTrade = async (aggregator, input, controller) => {
-    if (getSwapAggregators().includes(aggregator)) {
+    if (getSwapAggregators().includes(aggregator) ||
+        getAllConfigs().some((config) => config.name === aggregator)) {
         return await fetchBridgeTrade(aggregator, { ...input, order: 'CHEAPEST' }, controller);
     }
     else {

package/dist/composedTrades/across/acrossAdapter.d.ts

@@ -0,0 +1,5 @@
+import { AcrossBaseInput, ComposedBridgeAdapter } from '../../types';
+import { AcrossRouteResponse } from './acrossRoutes';
+import { AcrossWithSwapInput } from './acrossWithSwap';
+export declare const AcrossAdapter: ComposedBridgeAdapter<AcrossBaseInput, AcrossWithSwapInput, AcrossRouteResponse>;
+//# sourceMappingURL=acrossAdapter.d.ts.map

package/dist/composedTrades/across/acrossAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acrossAdapter.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossAdapter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACpE,OAAO,EACL,mBAAmB,EAGpB,MAAM,gBAAgB,CAAA;AACvB,OAAiC,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAIhF,eAAO,MAAM,aAAa,EAAE,qBAAqB,CAC/C,eAAe,EACf,mBAAmB,EACnB,mBAAmB,CAgEpB,CAAA"}

package/dist/composedTrades/across/acrossAdapter.js

@@ -0,0 +1,44 @@
+import { Bridge } from '@1delta/bridge-configs';
+import { CurrencyHandler, nativeOnChain } from '@1delta/lib-utils';
+import { getCurrencyGetter } from '../../registry';
+import { fetchAcrossRoutes, selectAcrossRoute, } from './acrossRoutes';
+import fetchAcrossTradeWithSwap from './acrossWithSwap';
+const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001';
+export const AcrossAdapter = {
+    async getRoute(fromChainId, toChainId, input) {
+        if (!input.fromCurrency || !input.toCurrency)
+            return undefined;
+        const routes = await fetchAcrossRoutes(fromChainId, toChainId);
+        return selectAcrossRoute(routes, input.fromCurrency, input.toCurrency);
+    },
+    getBridgeCurrencies(route, input) {
+        const getCurrency = getCurrencyGetter();
+        const fromAcrossCurrency = getCurrency(route.originChainId.toString(), route.originToken);
+        const toAcrossCurrency = getCurrency(route.destinationChainId.toString(), route.destinationToken);
+        return {
+            fromBridgeCurrency: fromAcrossCurrency,
+            toBridgeCurrency: toAcrossCurrency,
+            inputIsBridgeAsset: CurrencyHandler.equal(CurrencyHandler.wrapped(input.fromCurrency), fromAcrossCurrency),
+            outputIsBridgeAsset: CurrencyHandler.equal(CurrencyHandler.wrapped(input.toCurrency), toAcrossCurrency),
+        };
+    },
+    buildBridgeInput({ input, extendedAmount, bridgeSlippage, isDummy, fromBridgeCurrency, toBridgeCurrency, route, }) {
+        const fromCurrency = route.isNative
+            ? nativeOnChain(route.originChainId.toString())
+            : fromBridgeCurrency;
+        return {
+            ...input,
+            swapAmount: extendedAmount,
+            slippage: bridgeSlippage,
+            fromCurrency,
+            bridgeToCurrency: toBridgeCurrency,
+            caller: isDummy ? DUMMY_ADDRESS : input.caller,
+            receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
+        };
+    },
+    async fetchBridgeTrade(bridge, input, controller) {
+        if (bridge !== Bridge.ACROSS)
+            throw new Error(`AcrossAdapter only supports Across bridge`);
+        return await fetchAcrossTradeWithSwap(input, controller);
+    },
+};

package/dist/composedTrades/across/acrossRoutes.d.ts

@@ -1,5 +1,5 @@
 import { RawCurrency } from '@1delta/lib-utils';
-interface AcrossRouteResponse {
+export interface AcrossRouteResponse {
     originChainId: number;
     originToken: string;
     destinationChainId: number;
@@ -13,5 +13,4 @@ export declare const fetchAcrossRoutes: (fromChainId: string, toChainId: string)
  * Enhanced route selection with clearer priority logic
  */
 export declare const selectAcrossRoute: (routes: AcrossRouteResponse[], fromCurrency: RawCurrency, toCurrency: RawCurrency) => AcrossRouteResponse | undefined;
-export {};
 //# sourceMappingURL=acrossRoutes.d.ts.map

package/dist/composedTrades/across/acrossRoutes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"acrossRoutes.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossRoutes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEhE,UAAU,mBAAmB;IAC3B,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,gBAAgB,EAAE,MAAM,CAAA;IACxB,iBAAiB,EAAE,MAAM,CAAA;IACzB,sBAAsB,EAAE,MAAM,CAAA;IAC9B,QAAQ,EAAE,OAAO,CAAA;CAClB;AAKD,eAAO,MAAM,iBAAiB,GAC5B,aAAa,MAAM,EACnB,WAAW,MAAM,KAChB,OAAO,CAAC,mBAAmB,EAAE,CAK/B,CAAA;AA4DD;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,mBAAmB,EAAE,EAC7B,cAAc,WAAW,EACzB,YAAY,WAAW,KACtB,mBAAmB,GAAG,SAyBxB,CAAA"}
+{"version":3,"file":"acrossRoutes.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/across/acrossRoutes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEhE,MAAM,WAAW,mBAAmB;IAClC,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;IACnB,kBAAkB,EAAE,MAAM,CAAA;IAC1B,gBAAgB,EAAE,MAAM,CAAA;IACxB,iBAAiB,EAAE,MAAM,CAAA;IACzB,sBAAsB,EAAE,MAAM,CAAA;IAC9B,QAAQ,EAAE,OAAO,CAAA;CAClB;AAKD,eAAO,MAAM,iBAAiB,GAC5B,aAAa,MAAM,EACnB,WAAW,MAAM,KAChB,OAAO,CAAC,mBAAmB,EAAE,CAK/B,CAAA;AA4DD;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,mBAAmB,EAAE,EAC7B,cAAc,WAAW,EACzB,YAAY,WAAW,KACtB,mBAAmB,GAAG,SAyBxB,CAAA"}

package/dist/composedTrades/across/acrossWithSwap.integration.spec.d.ts

@@ -1 +1,2 @@
+export {};
 //# sourceMappingURL=acrossWithSwap.integration.spec.d.ts.map

package/dist/composedTrades/across/acrossWithSwap.integration.spec.js

@@ -1,116 +1,122 @@
-"use strict";
-// import { ChainId, Percent, TradeType } from '@1delta/base-sdk'
-// import { beforeEach, describe, expect, it, vi } from 'vitest'
-// import { USDC_ON } from '@/lib/constants/addresses'
-// import { getAcrossMulticallHandler } from '@/lib/constants/addresses/multicall/across'
-// import { CurrencyHandler } from '@/lib/services/currencyUtils'
-// import { nativeOnChain } from '@/lib/services/tokens'
-// import { RawCurrency } from '@/lib/types'
-// import fetchAcrossTradeWithSwap, { AcrossWithSwapInput } from './acrossWithSwap'
-// describe('fetchAcrossTradeWithSwap', () => {
-//   beforeEach(() => {
-//     vi.clearAllMocks()
-//   })
-//   const ACCOUNT = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045'
-//   const WBTC_OP: RawCurrency = {
-//     chainId: ChainId.OP_MAINNET,
-//     address: '0x68f180fcCe6836688e9084f035309E29Bf0A2095',
-//     decimals: 8,
-//     symbol: 'WBTC',
-//     name: 'Wrapped BTC',
-//   }
-//   it('Bridge Native', async () => {
-//     // Receive Native only if receiver address is EOA
-//     const fromCurrency = nativeOnChain(ChainId.ARBITRUM_ONE)
-//     const toCurrency = nativeOnChain(ChainId.OP_MAINNET)
-//     const bridgeToCurrency = CurrencyHandler.wrapped(toCurrency)
-//     const input: AcrossWithSwapInput = {
-//       tradeType: TradeType.EXACT_INPUT,
-//       fromCurrency,
-//       bridgeToCurrency,
-//       toCurrency,
-//       slippage: 1,
-//       swapAmount: '1000000000000000000',
-//       caller: ACCOUNT,
-//       receiver: ACCOUNT,
-//       order: 'FASTEST',
-//     }
-//     const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input)
-//     console.log('result', result, receiver)
-//     expect(result).toBeDefined()
-//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
-//     expect(result?.outputAmount.currency).toEqual(toCurrency)
-//     expect(receiver).toEqual(ACCOUNT)
-//     expect(result?.crossChainParams?.message).toBeUndefined()
-//   })
-//   it('Bridge Native -> WETH', async () => {
-//     // Receive Wrapped Native only if receiver address is contract
-//     const fromCurrency = nativeOnChain(ChainId.ARBITRUM_ONE)
-//     const toCurrency = CurrencyHandler.wrapped(
-//       nativeOnChain(ChainId.OP_MAINNET)
-//     )
-//     const input: AcrossWithSwapInput = {
-//       tradeType: TradeType.EXACT_INPUT,
-//       fromCurrency,
-//       bridgeToCurrency: toCurrency,
-//       toCurrency,
-//       slippage: 1,
-//       swapAmount: '1000000000000000000',
-//       caller: ACCOUNT,
-//       receiver: ACCOUNT,
-//       order: 'FASTEST',
-//     }
-//     const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input)
-//     console.log('result', result, receiver)
-//     expect(result).toBeDefined()
-//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
-//     expect(result?.outputAmount.currency).toEqual(toCurrency)
-//     expect(receiver).toEqual(getAcrossMulticallHandler(ChainId.OP_MAINNET))
-//     expect(result?.crossChainParams?.message).toBeDefined()
-//   })
-//   it('Bridge USDC', async () => {
-//     const fromCurrency = USDC_ON(ChainId.ARBITRUM_ONE)
-//     const toCurrency = USDC_ON(ChainId.OP_MAINNET)
-//     const input: AcrossWithSwapInput = {
-//       tradeType: TradeType.EXACT_INPUT,
-//       fromCurrency,
-//       bridgeToCurrency: toCurrency,
-//       toCurrency,
-//       slippage: 1,
-//       swapAmount: '1000000',
-//       caller: ACCOUNT,
-//       receiver: ACCOUNT,
-//       order: 'FASTEST',
-//     }
-//     const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input)
-//     console.log('result', result, receiver)
-//     expect(result).toBeDefined()
-//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
-//     expect(result?.outputAmount.currency).toEqual(toCurrency)
-//     expect(receiver).toEqual(ACCOUNT)
-//     expect(result?.crossChainParams?.message).toBeUndefined()
-//   })
-//   it('Bridge + Swap', async () => {
-//     const fromCurrency = USDC_ON(ChainId.ARBITRUM_ONE)
-//     const bridgeToCurrency = USDC_ON(ChainId.OP_MAINNET)
-//     const toCurrency = WBTC_OP
-//     const input: AcrossWithSwapInput = {
-//       tradeType: TradeType.EXACT_INPUT,
-//       fromCurrency,
-//       bridgeToCurrency,
-//       toCurrency,
-//       slippage: 1,
-//       swapAmount: '1000000',
-//       caller: ACCOUNT,
-//       receiver: ACCOUNT,
-//       order: 'FASTEST',
-//     }
-//     const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input)
-//     console.log('result', result, receiver)
-//     expect(result).toBeDefined()
-//     expect(result?.inputAmount.currency).toEqual(fromCurrency)
-//     expect(result?.outputAmount.currency).toEqual(toCurrency)
-//     expect(receiver).toEqual(getAcrossMulticallHandler(ChainId.OP_MAINNET))
-//     expect(result?.crossChainParams?.message).toBeDefined()
-//   })
-// }, 20000)
+import { CurrencyHandler, getAcrossMulticallHandler, nativeOnChain, SupportedChainId, TradeType, } from '@1delta/lib-utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import fetchAcrossTradeWithSwap from './acrossWithSwap';
+describe('fetchAcrossTradeWithSwap', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    const ACCOUNT = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
+    const WBTC_OP = {
+        chainId: SupportedChainId.OP_MAINNET,
+        address: '0x68f180fcCe6836688e9084f035309E29Bf0A2095',
+        decimals: 8,
+        symbol: 'WBTC',
+        name: 'Wrapped BTC',
+    };
+    const USDC_OP = {
+        chainId: SupportedChainId.OP_MAINNET,
+        address: '0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85',
+        decimals: 6,
+        symbol: 'USDC',
+        name: 'USDC Stablecoin',
+    };
+    const USDC_ARB = {
+        chainId: SupportedChainId.ARBITRUM_NOVA,
+        address: '0xaf88d065e77c8cC2239327C5EDb3A432268e5831',
+        decimals: 6,
+        symbol: 'USDC',
+        name: 'USDC Stablecoin',
+    };
+    it('Bridge Native', async () => {
+        // Receive Native only if receiver address is EOA
+        const fromCurrency = nativeOnChain(SupportedChainId.ARBITRUM_ONE);
+        const toCurrency = USDC_OP;
+        const bridgeToCurrency = CurrencyHandler.wrapped(toCurrency);
+        const input = {
+            tradeType: TradeType.EXACT_INPUT,
+            fromCurrency,
+            bridgeToCurrency,
+            toCurrency,
+            slippage: 1,
+            swapAmount: '1000000000000000000',
+            caller: ACCOUNT,
+            receiver: ACCOUNT,
+            order: 'FASTEST',
+        };
+        const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input);
+        console.log('result', result, receiver);
+        expect(result).toBeDefined();
+        expect(result?.inputAmount.currency).toEqual(fromCurrency);
+        expect(result?.outputAmount.currency).toEqual(toCurrency);
+        expect(receiver).toEqual(ACCOUNT);
+        expect(result?.crossChainParams?.message).toBeUndefined();
+    });
+    it('Bridge Native -> WETH', async () => {
+        // Receive Wrapped Native only if receiver address is contract
+        const fromCurrency = nativeOnChain(SupportedChainId.ARBITRUM_ONE);
+        const toCurrency = CurrencyHandler.wrapped(nativeOnChain(SupportedChainId.OP_MAINNET));
+        const input = {
+            tradeType: TradeType.EXACT_INPUT,
+            fromCurrency,
+            bridgeToCurrency: toCurrency,
+            toCurrency,
+            slippage: 1,
+            swapAmount: '1000000000000000000',
+            caller: ACCOUNT,
+            receiver: ACCOUNT,
+            order: 'FASTEST',
+        };
+        const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input);
+        console.log('result', result, receiver);
+        expect(result).toBeDefined();
+        expect(result?.inputAmount.currency).toEqual(fromCurrency);
+        expect(result?.outputAmount.currency).toEqual(toCurrency);
+        expect(receiver).toEqual(getAcrossMulticallHandler(SupportedChainId.OP_MAINNET));
+        expect(result?.crossChainParams?.message).toBeDefined();
+    });
+    it('Bridge USDC', async () => {
+        const fromCurrency = USDC_ARB;
+        const toCurrency = USDC_OP;
+        const input = {
+            tradeType: TradeType.EXACT_INPUT,
+            fromCurrency,
+            bridgeToCurrency: toCurrency,
+            toCurrency,
+            slippage: 1,
+            swapAmount: '1000000',
+            caller: ACCOUNT,
+            receiver: ACCOUNT,
+            order: 'FASTEST',
+        };
+        const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input);
+        console.log('result', result, receiver);
+        expect(result).toBeDefined();
+        expect(result?.inputAmount.currency).toEqual(fromCurrency);
+        expect(result?.outputAmount.currency).toEqual(toCurrency);
+        expect(receiver).toEqual(ACCOUNT);
+        expect(result?.crossChainParams?.message).toBeUndefined();
+    });
+    it('Bridge + Swap', async () => {
+        const fromCurrency = USDC_ARB;
+        const bridgeToCurrency = USDC_OP;
+        const toCurrency = WBTC_OP;
+        const input = {
+            tradeType: TradeType.EXACT_INPUT,
+            fromCurrency,
+            bridgeToCurrency,
+            toCurrency,
+            slippage: 1,
+            swapAmount: '1000000',
+            caller: ACCOUNT,
+            receiver: ACCOUNT,
+            order: 'FASTEST',
+        };
+        const { trade: result, receiver } = await fetchAcrossTradeWithSwap(input);
+        console.log('result', result, receiver);
+        expect(result).toBeDefined();
+        expect(result?.inputAmount.currency).toEqual(fromCurrency);
+        expect(result?.outputAmount.currency).toEqual(toCurrency);
+        expect(receiver).toEqual(getAcrossMulticallHandler(SupportedChainId.OP_MAINNET));
+        expect(result?.crossChainParams?.message).toBeDefined();
+    });
+}, 20000);

package/dist/composedTrades/axelar/axelarAdapter.d.ts

@@ -0,0 +1,5 @@
+import { AxelarBaseInput, ComposedBridgeAdapter } from '../../types';
+import { AxelarRoute } from './axelarRoutes';
+import { AxelarWithSwapInput } from './axelarWithSwap';
+export declare const AxelarAdapter: ComposedBridgeAdapter<AxelarBaseInput, AxelarWithSwapInput, AxelarRoute>;
+//# sourceMappingURL=axelarAdapter.d.ts.map

package/dist/composedTrades/axelar/axelarAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axelarAdapter.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/axelarAdapter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAE5C,OAAiC,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAIhF,eAAO,MAAM,aAAa,EAAE,qBAAqB,CAC/C,eAAe,EACf,mBAAmB,EACnB,WAAW,CA0DZ,CAAA"}

package/dist/composedTrades/axelar/axelarAdapter.js

@@ -0,0 +1,38 @@
+import { Bridge } from '@1delta/bridge-configs';
+import { CurrencyHandler } from '@1delta/lib-utils';
+import { getCurrencyGetter } from '../../registry';
+import { fetchAxelarRoute } from './axelarRoutes';
+import fetchAxelarTradeWithSwap from './axelarWithSwap';
+const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001';
+export const AxelarAdapter = {
+    async getRoute(fromChainId, toChainId) {
+        return fetchAxelarRoute(fromChainId, toChainId);
+    },
+    getBridgeCurrencies(route, input) {
+        const getCurrency = getCurrencyGetter();
+        const fromBridgeCurrency = getCurrency(input.fromCurrency?.chainId, route.fromBridgeToken);
+        const toBridgeCurrency = getCurrency(input.toCurrency?.chainId, route.toBridgeToken);
+        return {
+            fromBridgeCurrency,
+            toBridgeCurrency,
+            inputIsBridgeAsset: CurrencyHandler.equal(CurrencyHandler.wrapped(input.fromCurrency), fromBridgeCurrency),
+            outputIsBridgeAsset: CurrencyHandler.equal(CurrencyHandler.wrapped(input.toCurrency), toBridgeCurrency),
+        };
+    },
+    buildBridgeInput({ input, extendedAmount, bridgeSlippage, isDummy, fromBridgeCurrency, toBridgeCurrency, forwarder, }) {
+        return {
+            ...input,
+            slippage: bridgeSlippage,
+            swapAmount: extendedAmount,
+            fromCurrency: fromBridgeCurrency,
+            bridgeToCurrency: toBridgeCurrency,
+            caller: forwarder,
+            receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
+        };
+    },
+    async fetchBridgeTrade(bridge, input, controller) {
+        if (bridge !== Bridge.AXELAR)
+            throw new Error(`AxelarAdapter only supports Axelar bridge`);
+        return fetchAxelarTradeWithSwap(input, controller);
+    },
+};

package/dist/composedTrades/axelar/axelarRoutes.d.ts

@@ -1,7 +1,6 @@
-interface AxelarRoute {
+export interface AxelarRoute {
     fromBridgeToken: string;
     toBridgeToken: string;
 }
 export declare function fetchAxelarRoute(fromChainId: string, toChainId: string): Promise<AxelarRoute | undefined>;
-export {};
 //# sourceMappingURL=axelarRoutes.d.ts.map

package/dist/composedTrades/axelar/axelarRoutes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"axelarRoutes.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/axelarRoutes.ts"],"names":[],"mappings":"AAcA,UAAU,WAAW;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAWlC"}
+{"version":3,"file":"axelarRoutes.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/axelar/axelarRoutes.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,WAAW;IAC1B,eAAe,EAAE,MAAM,CAAA;IACvB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAWlC"}

package/dist/composedTrades/gaszip/gaszipAdapter.d.ts

@@ -0,0 +1,9 @@
+import { RawCurrency } from '@1delta/lib-utils';
+import { BaseBridgeInput, ComposedBridgeAdapter, ComposedBridgeInput } from '../../types';
+interface Route {
+    fromBridgeCurrency: RawCurrency;
+    toBridgeCurrency: RawCurrency;
+}
+export declare const GaszipAdapter: ComposedBridgeAdapter<ComposedBridgeInput, BaseBridgeInput, Route>;
+export {};
+//# sourceMappingURL=gaszipAdapter.d.ts.map

package/dist/composedTrades/gaszip/gaszipAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaszipAdapter.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/gaszip/gaszipAdapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAkC,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAG/E,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,aAAa,CAAA;AAIpB,UAAU,KAAK;IACb,kBAAkB,EAAE,WAAW,CAAA;IAC/B,gBAAgB,EAAE,WAAW,CAAA;CAC9B;AAED,eAAO,MAAM,aAAa,EAAE,qBAAqB,CAC/C,mBAAmB,EACnB,eAAe,EACf,KAAK,CA2DN,CAAA"}

package/dist/composedTrades/gaszip/gaszipAdapter.js

@@ -0,0 +1,46 @@
+import { Bridge } from '@1delta/bridge-configs';
+import { CurrencyHandler, nativeOnChain } from '@1delta/lib-utils';
+import { fetchBridgeTrade } from '../../bridge';
+const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001';
+export const GaszipAdapter = {
+    async getRoute(fromChainId, toChainId, input) {
+        const fromBridgeCurrency = nativeOnChain(fromChainId);
+        const toBridgeCurrency = nativeOnChain(toChainId);
+        if (!CurrencyHandler.isNative(input.toCurrency)) {
+            throw new Error('Gaszip only supports native output');
+        }
+        return {
+            fromBridgeCurrency,
+            toBridgeCurrency,
+        };
+    },
+    getBridgeCurrencies(route, input) {
+        const { fromBridgeCurrency, toBridgeCurrency } = route;
+        return {
+            fromBridgeCurrency,
+            toBridgeCurrency,
+            inputIsBridgeAsset: CurrencyHandler.equal(input.fromCurrency, route.fromBridgeCurrency),
+            outputIsBridgeAsset: true,
+        };
+    },
+    buildBridgeInput({ input, extendedAmount, bridgeSlippage, isDummy, fromBridgeCurrency, toBridgeCurrency, }) {
+        return {
+            tradeType: input.tradeType,
+            swapAmount: extendedAmount,
+            slippage: bridgeSlippage,
+            fromCurrency: fromBridgeCurrency,
+            toCurrency: toBridgeCurrency,
+            caller: isDummy ? DUMMY_ADDRESS : input.caller,
+            receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
+            order: 'CHEAPEST',
+        };
+    },
+    async fetchBridgeTrade(bridge, input, controller) {
+        if (bridge !== Bridge.GASZIP)
+            throw new Error(`GaszipAdapter only supports Gaszip bridge`);
+        const trade = await fetchBridgeTrade(bridge, input, controller);
+        return {
+            trade,
+        };
+    },
+};

package/dist/composedTrades/general/composableBridgeAdapter.d.ts

@@ -0,0 +1,9 @@
+import { RawCurrency } from '@1delta/lib-utils';
+import { BaseBridgeInput, ComposedBridgeAdapter, ComposedBridgeInput } from '../../types';
+interface Route {
+    fromBridgeCurrency: RawCurrency;
+    toBridgeCurrency: RawCurrency;
+}
+export declare const ComposableBridgeAdapter: ComposedBridgeAdapter<ComposedBridgeInput, BaseBridgeInput, Route>;
+export {};
+//# sourceMappingURL=composableBridgeAdapter.d.ts.map

package/dist/composedTrades/general/composableBridgeAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composableBridgeAdapter.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/general/composableBridgeAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAGhE,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,aAAa,CAAA;AAIpB,UAAU,KAAK;IACb,kBAAkB,EAAE,WAAW,CAAA;IAC/B,gBAAgB,EAAE,WAAW,CAAA;CAC9B;AAED,eAAO,MAAM,uBAAuB,EAAE,qBAAqB,CACzD,mBAAmB,EACnB,eAAe,EACf,KAAK,CA8CN,CAAA"}

package/dist/composedTrades/general/composableBridgeAdapter.js

@@ -0,0 +1,39 @@
+import { CurrencyHandler } from '@1delta/lib-utils';
+import { fetchBridgeTrade } from '../../bridge';
+const DUMMY_ADDRESS = '0x0000000000000000000000000000000000000001';
+export const ComposableBridgeAdapter = {
+    async getRoute(_fromChainId, _toChainId, input) {
+        if (!input.fromCurrency || !input.toCurrency)
+            return undefined;
+        const fromBridgeCurrency = input.fromCurrency;
+        const toBridgeCurrency = input.toCurrency;
+        return {
+            fromBridgeCurrency,
+            toBridgeCurrency,
+        };
+    },
+    getBridgeCurrencies(route, input) {
+        const { fromBridgeCurrency, toBridgeCurrency } = route;
+        return {
+            fromBridgeCurrency,
+            toBridgeCurrency,
+            inputIsBridgeAsset: CurrencyHandler.equal(input.fromCurrency, route.fromBridgeCurrency),
+            outputIsBridgeAsset: CurrencyHandler.equal(input.toCurrency, route.toBridgeCurrency),
+        };
+    },
+    buildBridgeInput({ input, extendedAmount, bridgeSlippage, isDummy }) {
+        return {
+            ...input,
+            swapAmount: extendedAmount,
+            slippage: bridgeSlippage,
+            caller: isDummy ? DUMMY_ADDRESS : input.caller,
+            receiver: isDummy ? DUMMY_ADDRESS : input.receiver,
+        };
+    },
+    async fetchBridgeTrade(bridge, input, controller) {
+        const trade = await fetchBridgeTrade(bridge, input, controller);
+        return {
+            trade,
+        };
+    },
+};

package/dist/composedTrades/general/composeBridgeTrade.d.ts

@@ -0,0 +1,5 @@
+import { Bridge } from '@1delta/bridge-configs';
+import { GenericTrade } from '@1delta/lib-utils';
+import { ComposedBridgeAdapter, ComposedBridgeInput } from '../../types';
+export declare function composeBridgeTrade<Input extends ComposedBridgeInput, BridgeInput, Route>(bridge: Bridge, input: Input, adapter: ComposedBridgeAdapter<Input, BridgeInput, Route>, controller?: AbortController): Promise<GenericTrade | undefined>;
+//# sourceMappingURL=composeBridgeTrade.d.ts.map

package/dist/composedTrades/general/composeBridgeTrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeBridgeTrade.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/general/composeBridgeTrade.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAO/C,OAAO,EAGL,YAAY,EAKb,MAAM,mBAAmB,CAAA;AAE1B,OAAO,EAEL,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,aAAa,CAAA;AAOpB,wBAAsB,kBAAkB,CACtC,KAAK,SAAS,mBAAmB,EACjC,WAAW,EACX,KAAK,EAEL,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,qBAAqB,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,EACzD,UAAU,CAAC,EAAE,eAAe,GAC3B,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAqKnC"}