@1delta/trade-sdk 0.1.9 → 0.1.10

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"}

package/dist/composedTrades/general/composeBridgeTrade.js

@@ -0,0 +1,106 @@
+import { convertRawAmount, DeltaCallType, LendingCall, nativeOnChain, } from '@1delta/lib-utils';
+import { CurrencyHandler, getSafeChainId, minimumAmountOutFromTrade, splitSlippage, TradeType, } from '@1delta/lib-utils';
+import { createSwapAndBridgeCalldata, validateContracts } from '../utils';
+import { fetchBestTrade, increaseAmountBySlippage, } from '../utils/multichainUtils';
+export async function composeBridgeTrade(bridge, input, adapter, controller) {
+    if (!input.fromCurrency || !input.toCurrency)
+        return undefined;
+    if (input.tradeType === TradeType.EXACT_OUTPUT)
+        throw new Error('Exact-out not supported for composed bridge trades');
+    const isDummy = !input.caller || !input.receiver;
+    const fromChainId = getSafeChainId(input.fromCurrency.chainId);
+    const toChainId = getSafeChainId(input.toCurrency.chainId);
+    const { forwarder, composer } = validateContracts(fromChainId);
+    // 1. Route
+    const route = await adapter.getRoute(fromChainId, toChainId, input);
+    if (!route)
+        return undefined;
+    // 2. Bridge currencies
+    const { fromBridgeCurrency, toBridgeCurrency, inputIsBridgeAsset, outputIsBridgeAsset, } = adapter.getBridgeCurrencies(route, input);
+    // 3. Slippage split
+    const [swapSlippage, bridgeSlippage] = splitSlippage(input.slippage, inputIsBridgeAsset, outputIsBridgeAsset);
+    // 4. Optional source swap
+    let sourceSwapTrade;
+    if (!inputIsBridgeAsset) {
+        const swapInput = {
+            chainId: fromChainId,
+            tradeType: TradeType.EXACT_INPUT,
+            fromCurrency: input.fromCurrency,
+            toCurrency: fromBridgeCurrency,
+            slippage: swapSlippage,
+            swapAmount: input.swapAmount,
+            txOrigin: input.caller,
+            caller: forwarder,
+            receiver: forwarder,
+            disableComposer: true,
+        };
+        sourceSwapTrade = await fetchBestTrade(swapInput, controller);
+    }
+    // 5. Extend amount
+    const extendedAmount = sourceSwapTrade
+        ? minimumAmountOutFromTrade(sourceSwapTrade, sourceSwapTrade.slippage).amount.toString()
+        : input.swapAmount;
+    // 6. Bridge trade
+    const bridgeInput = adapter.buildBridgeInput({
+        input,
+        route,
+        extendedAmount,
+        bridgeSlippage,
+        isDummy,
+        fromBridgeCurrency,
+        toBridgeCurrency,
+        forwarder,
+        composer,
+    });
+    const { trade, gasTrade, receiver } = await adapter.fetchBridgeTrade(bridge, bridgeInput, controller);
+    if (!trade)
+        return undefined;
+    // 7. Compose trades
+    const trades = [];
+    if (sourceSwapTrade)
+        trades.push(sourceSwapTrade);
+    if (gasTrade)
+        trades.push(gasTrade);
+    trades.push(trade);
+    // 8. Assemble
+    const assemble = async () => {
+        if (isDummy)
+            return undefined;
+        const fundsToPull = [];
+        const isWithdrawOrBorrow = input.preCalls?.some((c) => c.callType === DeltaCallType.LENDING &&
+            (c.lendingAction === LendingCall.DeltaCallLendingAction.WITHDRAW ||
+                c.lendingAction === LendingCall.DeltaCallLendingAction.BORROW)) ?? false;
+        if (!isWithdrawOrBorrow) {
+            fundsToPull.push({
+                address: input.fromCurrency.address,
+                amount: BigInt(input.swapAmount),
+            });
+        }
+        if (!gasTrade && trade.gasAmount) {
+            fundsToPull.push({
+                address: nativeOnChain(fromChainId).address,
+                amount: trade.gasAmount,
+            });
+        }
+        const { calldata, value, to } = await createSwapAndBridgeCalldata(trades, input.caller, receiver ?? input.receiver, true, fundsToPull, false, true, input.preCalls);
+        return { EVM: { to, calldata, value: value.toString() } };
+    };
+    // 9. Output normalization
+    const outputAmount = sourceSwapTrade
+        ? increaseAmountBySlippage(trade.outputAmount.amount, Number(swapSlippage))
+        : trade.outputAmount.amount;
+    return {
+        ...trade,
+        inputAmount: CurrencyHandler.fromRawAmount(input.fromCurrency, input.swapAmount),
+        inputAmountRealized: convertRawAmount(input.swapAmount, input.fromCurrency.decimals),
+        outputAmount: CurrencyHandler.fromRawAmount(trade.outputAmount.currency, outputAmount),
+        outputAmountRealized: convertRawAmount(outputAmount, trade.outputAmount.currency.decimals),
+        stringified: trades.map((t) => t.stringified).join('-'),
+        target: composer,
+        approvalTarget: composer,
+        slippage: input.slippage,
+        assemble,
+        refresh: (o) => composeBridgeTrade(bridge, { ...input, slippage: o?.slippage ?? input.slippage }, adapter, controller),
+        gasAmount: gasTrade ? undefined : trade.gasAmount,
+    };
+}

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

@@ -0,0 +1,3 @@
+export * from './composableBridgeAdapter';
+export * from './composeBridgeTrade';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/composedTrades/general/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAA;AACzC,cAAc,sBAAsB,CAAA"}

package/dist/composedTrades/general/index.js

@@ -0,0 +1,2 @@
+export * from './composableBridgeAdapter';
+export * from './composeBridgeTrade';