Fix issue with more than one output tokens

Author: knownout

src/__specs__/cross-chain.simulation.spec.ts

@@ -31,7 +31,7 @@ describe("Single chain simulation", async () => {
   const createRequest = async (tokensOut: BasicToken[], percents: number[]) => {
     const request: ExchangeRequest = {
       exactInput: true,
-      amountIn: new Amount(1, 18, true),
+      amountIn: new Amount(0.1, 18, true),
       amountsOut: Array(tokensOut.length).fill(amountOutInitial),
       amountOutReadablePercentages: percents,
       tokenIn: bnbBNB,

src/__specs__/utils/sdk-test-config.ts

@@ -119,6 +119,11 @@ const sdkConfig: SdkConfig = {
   backend: {
     url: "https://api.safeblock.cc"
   },
+  contractAddresses: {
+    entryPoint: {
+      default: "0x27d6b06f29802a19c6c1216D540758f32ebD8dE6"
+    }
+  },
   extensions: env => [
     new TokensListExtension(env.sdk, env.eventBus, tokensListExtensionConfig),
     new PriceStorageExtension(env.sdk, env.eventBus, {

src/sdk/bridge-aggregation/aggregate-bridges.ts

@@ -16,7 +16,7 @@ interface BridgingDetails {
   sdkConfig: SdkConfig
 }
 
-export default async function aggregateBridges(sdk: SdkCore, options: BridgingDetails): Promise<AggregationResponse | SdkException> {
+export default async function aggregateBridges(sdk: SdkCore, sdkConfig: SdkConfig, options: BridgingDetails): Promise<AggregationResponse | SdkException> {
   const fromNetworkUSDC = contractAddresses.usdcParams(options.request.tokenIn.network)
 
   const amountLD = !Address.equal(options.request.tokenIn.address, fromNetworkUSDC.address) ? "0" : Amount
@@ -31,7 +31,7 @@ export default async function aggregateBridges(sdk: SdkCore, options: BridgingDe
 
   options.sdkConfig.debugLogListener?.("BridgeAggregation: Sending request to bridge aggregator...")
 
-  const aggregationResult = await aggregate(sdk, {
+  const aggregationResult = await aggregate(sdk, sdkConfig, {
     destinationAddress: (options.request.destinationAddress ?? options.senderAddress),
     userAddress: options.senderAddress,
     inputAmountRaw: Amount.select(options.sourceChainRoute?.amountsOut?.[0], options.sourceNetworkSendAmount)!.toString(),
@@ -100,12 +100,12 @@ export default async function aggregateBridges(sdk: SdkCore, options: BridgingDe
   }
 }
 
-async function aggregate(sdk: SdkCore, options: AggregationModuleRequestParams) {
+async function aggregate(sdk: SdkCore, sdkConfig: SdkConfig, options: AggregationModuleRequestParams) {
   const [stargate] = await Promise.all([
     //acrossAggregationModule(sdk, options).catch((e: any) => {
     //  return new SdkException(e?.message || "Failed to process across bridge", SdkExceptionCode.InternalError)
     //}),
-    stargateAggregationModule(sdk, options).catch((e: any) => {
+    stargateAggregationModule(sdk, sdkConfig, options).catch((e: any) => {
       return new SdkException(e?.message || "Failed to process stargate bridge", SdkExceptionCode.InternalError)
     })
   ])

src/sdk/bridge-aggregation/modules/cross-curve.ts

@@ -3,8 +3,6 @@ import SdkException, { SdkExceptionCode } from "~/sdk/sdk-exception"
 import { AggregationModuleRequestParams } from "~/types"
 
 export default async function crossCurveAggregationModule(sdk: SdkCore, params: AggregationModuleRequestParams) {
-  console.log(sdk, params)
-
   return new SdkException("Not implemented", SdkExceptionCode.InternalError)
 
   /*

src/sdk/bridge-aggregation/modules/stargate.ts

@@ -4,20 +4,18 @@ import { AbiCoder } from "ethers"
 import { BridgeFaucet__factory, TransferFaucet__factory } from "~/abis/types"
 import { contractAddresses, stargateNetworksMapping } from "~/config"
 import { PriceStorageExtension } from "~/extensions"
-import SdkCore from "~/sdk/sdk-core"
+import SdkCore, { SdkConfig } from "~/sdk/sdk-core"
 import SdkException, { SdkExceptionCode } from "~/sdk/sdk-exception"
 import { AggregationModuleRequestParams, AggregationModuleResponse } from "~/types"
 import messageQuoter from "~/utils/message-quoter"
 
 export default async function stargateAggregationModule(
   sdk: SdkCore,
+  sdkConfig: SdkConfig,
   params: AggregationModuleRequestParams
 ): Promise<SdkException | AggregationModuleResponse> {
   const priceStorage = sdk.extension(PriceStorageExtension)
 
-  if (params.outputTokens.length !== 1)
-    return new SdkException("Invalid number of output tokens", SdkExceptionCode.InvalidRequest)
-
   const bridgeIface = BridgeFaucet__factory.createInterface()
 
   const dstNet = Array.from(networksList).find(n => n.chainId.toString() === params.destinationChainId.toString())
@@ -54,22 +52,31 @@ export default async function stargateAggregationModule(
 
   const transferFacetIface = TransferFaucet__factory.createInterface()
 
-  let extraData: string
-
-  if (params.outputTokens[0].address.equalTo(Address.zeroAddress)) {
-    extraData = AbiCoder.defaultAbiCoder().encode(["bytes[]"], [
-      transferFacetIface.encodeFunctionData("unwrapNativeAndTransferTo", [params.receiverAddress])
-    ])
+  const dataToEncode: string[] = []
+
+  if (params.outputTokens.some(a => a.address.equalTo(Address.zeroAddress))) {
+    dataToEncode.push(transferFacetIface.encodeFunctionData("unwrapNativeAndTransferTo", [params.receiverAddress]))
+    if (params.outputTokens.length > 1) {
+      dataToEncode.push(
+        transferFacetIface.encodeFunctionData("transferToken", [
+          params.receiverAddress,
+          params.outputTokens.map(t => t.address.toString())
+            .filter(a => !Address.equal(a, Address.zeroAddress))
+        ])
+      )
+    }
   }
   else {
-    extraData = AbiCoder.defaultAbiCoder().encode(["bytes[]"], [
+    dataToEncode.push(
       transferFacetIface.encodeFunctionData("transferToken", [
         params.receiverAddress,
         params.outputTokens.map(t => t.address.toString())
       ])
-    ])
+    )
   }
 
+  const extraData = AbiCoder.defaultAbiCoder().encode(["bytes[]"], [dataToEncode])
+
   const callData = bridgeIface.encodeFunctionData("sendStargate", [
     contractAddresses.stargateUSDCPool(srcNet),
     stargateNetworksMapping(dstNet),
@@ -101,12 +108,16 @@ export default async function stargateAggregationModule(
   const totalInputUSD = inputAmountUSD.plus(inputNativeAmountUSD)
   const priceImpact = new BigNumber(100).minus(outputAmountUSD.dividedBy(totalInputUSD).multipliedBy(100)).dp(5).toNumber()
 
+
   const extraNative = await messageQuoter(
     srcNet,
+    sdkConfig,
     stargateNetworksMapping(dstNet),
     extraData
   )
 
+  if (extraNative instanceof SdkException) return extraNative
+
   return {
     callData,
     valueToSend: Amount.from(new BigNumber(valueToSend.toString()).plus(extraNative.toString()).toString(), 18, false),

src/sdk/evm-converter/evm-cross-chain-extension.ts

@@ -266,7 +266,7 @@ export default class EvmCrossChainExtension {
       sourceChainRoute ? sourceChainRoute.tokensOut.map(t => t.address.toString()) : [fromNetworkUSDC.address.toString()]
     ]))
 
-    const aggregationResult = await aggregateBridges(this.parent.sdkInstance, {
+    const aggregationResult = await aggregateBridges(this.parent.sdkInstance, this.sdkConfig, {
       senderAddress: from,
       request,
       destinationChainRoute,

src/sdk/index.ts

@@ -2,9 +2,9 @@ import { Address } from "@safeblock/blockchain-utils"
 import BigNumber from "bignumber.js"
 import { ethers, JsonRpcSigner } from "ethers"
 import SdkCore, { type SdkConfig } from "~/sdk/sdk-core"
+import SdkException, { SdkExceptionCode } from "~/sdk/sdk-exception"
 import { ExtractConfigExtensionsType } from "~/sdk/sdk-extension"
 import { ExchangeRequest, ExecutorCallData } from "~/types"
-import SdkException, { SdkExceptionCode } from "~/sdk/sdk-exception"
 
 
 type GenericBlacklist<I extends string, S extends string> = Array<{ [key: string]: any } & { [key in I]: string } & { [key in S]: boolean }>
@@ -87,7 +87,10 @@ export default class SafeBlock<Configuration extends SdkConfig = SdkConfig> exte
 
     if (content instanceof SdkException) return content
 
-    this.sdkConfig.debugLogListener?.(`Quota: Built: ${ JSON.stringify(content.executorCallData.map(c => ({ data: c.callData, value: c.value?.toString() }))) }`)
+    this.sdkConfig.debugLogListener?.(`Quota: Built: ${ JSON.stringify(content.executorCallData.map(c => ({
+      data: c.callData,
+      value: c.value?.toString()
+    }))) }`)
 
     return content
   }

src/utils/message-quoter.ts

@@ -2,14 +2,15 @@ import { ethersProvider } from "@safeblock/blockchain-utils"
 import { Network } from "ethers"
 import { LayerZero__factory } from "~/abis/types"
 import { contractAddresses } from "~/config"
+import { SdkConfig } from "~/sdk"
 import SdkException, { SdkExceptionCode } from "~/sdk/sdk-exception"
 
-export default async function messageQuoter(network: Network, lzId: number, data: string) {
+export default async function messageQuoter(network: Network, sdkConfig: SdkConfig, lzId: number, data: string) {
   const provider = ethersProvider(network)
 
   if (!provider) return new SdkException(`Provider not found for network ${ network.name }`, SdkExceptionCode.InternalError)
 
-  const lzContract = LayerZero__factory.connect(contractAddresses.entryPoint(network))
+  const lzContract = LayerZero__factory.connect(contractAddresses.entryPoint(network, sdkConfig), provider)
 
   const message = await lzContract.quoteMessage(lzId, data)
     .catch(() => null)