import FungibleToken from 0xf233dcee88fe0abe import FlowToken from 0x1654653399040a61 import SwapInterfaces from 0xb78ef7afa52ff906 import SwapConfig from 0xb78ef7afa52ff906 import SwapError from 0xb78ef7afa52ff906 import LogEntry from 0xe876e00638d54e75 transaction( tokenKeyFlatSplitPath: [String], tokenAddressFlatSplitPath: [Address], tokenNameFlatSplitPath: [String], poolAddressesToPairs: [[[Address]]], poolKeysToPairs: [[[String]]], poolOutRatiosToPairs: [[[UFix64]]], amountOutSplit: [UFix64], amountInMax: UFix64, deadline: UFix64, tokenInVaultPath: StoragePath, tokenOutVaultPath: StoragePath, tokenOutReceiverPath: PublicPath, tokenOutBalancePath: PublicPath, ) { prepare(userAccount: auth(Storage, Capabilities) &Account) { assert(deadline >= getCurrentBlock().timestamp, message: SwapError.ErrorEncode( msg: "EXPIRED", err: SwapError.ErrorCode.EXPIRED ) ) let len = tokenKeyFlatSplitPath.length let swapInKey = tokenKeyFlatSplitPath[0] let swapOutKey = tokenKeyFlatSplitPath[len-1] let swapOutTokenName = tokenNameFlatSplitPath[len-1] let swapOutTokenAddress = tokenAddressFlatSplitPath[len-1] var tokenInAmountTotal = 0.0 var tokenOutAmountTotal = 0.0 let splitAmountInWithPoolSource: {String: UFix64} = {} var tokenOutReceiverRef = userAccount.storage.borrow<&{FungibleToken.Vault}>(from: tokenOutVaultPath) if tokenOutReceiverRef == nil { let outTokenAddrStr = swapOutTokenAddress.toString() let outTokenAddrStr0xTrimmed = outTokenAddrStr.slice(from: 2, upTo: outTokenAddrStr.length) /// e.g.: "A.1654653399040a61.FlowToken.Vault" let outTokenVaultRuntimeType = CompositeType("A.".concat(outTokenAddrStr0xTrimmed).concat(".").concat(swapOutTokenName).concat(".Vault")) ?? panic("outToken get runtime type fail") userAccount.storage.save(<-getAccount(swapOutTokenAddress).contracts.borrow<&{FungibleToken}>(name: swapOutTokenName)!.createEmptyVault(vaultType: outTokenVaultRuntimeType), to: tokenOutVaultPath) userAccount.capabilities.publish( userAccount.capabilities.storage.issue<&{FungibleToken.Receiver}>(tokenOutVaultPath), at: tokenOutReceiverPath ) userAccount.capabilities.publish( userAccount.capabilities.storage.issue<&{FungibleToken.Balance}>(tokenOutVaultPath), at: tokenOutBalancePath ) tokenOutReceiverRef = userAccount.storage.borrow<&{FungibleToken.Vault}>(from: tokenOutVaultPath) } var pathIndex = 0 var i = 0 var path: [String] = [] var pathTokenAddress: [Address] = [] var pathTokenName: [String] = [] while(i < len) { var curTokenKey = tokenKeyFlatSplitPath[i] path.append(curTokenKey) pathTokenAddress.append(tokenAddressFlatSplitPath[i]) pathTokenName.append(tokenNameFlatSplitPath[i]) if (curTokenKey == swapOutKey) { let pathOutAmount = amountOutSplit[pathIndex] tokenOutAmountTotal = tokenOutAmountTotal + pathOutAmount let pathLength = path.length // cal amount in var curOutAmount = pathOutAmount; var curOutLeftAmount = pathOutAmount; let poolsInOnPath: [[UFix64]] = []; let poolsOutOnPath: [[UFix64]] = []; var pathStep = pathLength - 2 while(pathStep >= 0) { poolsInOnPath.append([]) poolsOutOnPath.append([]) pathStep = pathStep - 1 } pathStep = pathLength - 2 while(pathStep >= 0) { let tokenInKey = path[pathStep] let tokenOutKey = path[pathStep+1] var pairInAmount = 0.0 var poolIndex = 0 let poolLength = poolAddressesToPairs[pathIndex][pathStep].length while(poolIndex < poolLength) { let poolOutRatio = poolOutRatiosToPairs[pathIndex][pathStep][poolIndex] let poolKey = poolKeysToPairs[pathIndex][pathStep][poolIndex] let poolAddress = poolAddressesToPairs[pathIndex][pathStep][poolIndex] var poolOutAmount = curOutAmount * poolOutRatio if (poolIndex == poolLength - 1) { poolOutAmount = curOutLeftAmount } curOutLeftAmount = curOutLeftAmount - poolOutAmount poolsOutOnPath[pathStep].append(poolOutAmount) var poolInAmount = 0.0 let one = 10000.0 // amount in switch poolKey { case "increment-v1": let pool = getAccount(poolAddress).capabilities.borrow<&{SwapInterfaces.PairPublic}>(SwapConfig.PairPublicPath)! poolInAmount = pool.getAmountIn(amountOut: poolOutAmount, tokenOutKey: tokenOutKey) case "increment-stable": let pool = getAccount(poolAddress).capabilities.borrow<&{SwapInterfaces.PairPublic}>(SwapConfig.PairPublicPath)! poolInAmount = pool.getAmountIn(amountOut: poolOutAmount, tokenOutKey: tokenOutKey) default: assert(false, message: "invalid pool type") } poolsInOnPath[pathStep].append(poolInAmount) pairInAmount = pairInAmount + poolInAmount poolIndex = poolIndex + 1 } curOutAmount = pairInAmount curOutLeftAmount = pairInAmount pathStep = pathStep - 1 } // swap in path pathStep = 0 var pathInAmount = 0.0 for poolIn in poolsInOnPath[0] { pathInAmount = pathInAmount + poolIn } tokenInAmountTotal = tokenInAmountTotal + pathInAmount var pairInVault <- userAccount.storage.borrow(from: tokenInVaultPath)!.withdraw(amount: pathInAmount) while(pathStep < pathLength-1) { let tokenInKey = path[pathStep] let tokenOutKey = path[pathStep+1] let tokenInAddress: Address = pathTokenAddress[pathStep] let tokenOutAddress: Address = pathTokenAddress[pathStep+1] let tokenInName: String = pathTokenName[pathStep] let tokenOutName: String = pathTokenName[pathStep+1] var poolIndex = 0; let poolLength = poolAddressesToPairs[pathIndex][pathStep].length let outTokenAddrStr = tokenOutAddress.toString() let outTokenAddrStr0xTrimmed = outTokenAddrStr.slice(from: 2, upTo: outTokenAddrStr.length) /// e.g.: "A.1654653399040a61.FlowToken.Vault" let outTokenVaultRuntimeType = CompositeType("A.".concat(outTokenAddrStr0xTrimmed).concat(".").concat(tokenOutName).concat(".Vault")) ?? panic("outToken get runtime type fail") var poolOutVault <- getAccount(tokenOutAddress).contracts.borrow<&{FungibleToken}>(name: tokenOutName)!.createEmptyVault(vaultType: outTokenVaultRuntimeType) // swap in pool while(poolIndex < poolLength) { let poolAddress = poolAddressesToPairs[pathIndex][pathStep][poolIndex] let poolKey = poolKeysToPairs[pathIndex][pathStep][poolIndex] var poolInAmount = poolsInOnPath[pathStep][poolIndex] if (poolIndex == poolLength-1) { poolInAmount = pairInVault.balance } if (pathStep == 0) { if splitAmountInWithPoolSource.containsKey(poolKey) { splitAmountInWithPoolSource[poolKey] = splitAmountInWithPoolSource[poolKey]! + poolInAmount } else { splitAmountInWithPoolSource[poolKey] = poolInAmount } } var poolOutAmount = poolsOutOnPath[pathStep][poolIndex] let prePoolOutBalance = poolOutVault.balance switch poolKey { case "increment-v1": let pool = getAccount(poolAddress).capabilities.borrow<&{SwapInterfaces.PairPublic}>(SwapConfig.PairPublicPath)! poolOutVault.deposit(from: <-pool.swap(vaultIn: <- pairInVault.withdraw(amount: poolInAmount), exactAmountOut: poolOutAmount)) case "increment-stable": let pool = getAccount(poolAddress).capabilities.borrow<&{SwapInterfaces.PairPublic}>(SwapConfig.PairPublicPath)! poolOutVault.deposit(from: <-pool.swap(vaultIn: <- pairInVault.withdraw(amount: poolInAmount), exactAmountOut: poolOutAmount)) default: assert(false, message: "invalid pool type") } LogEntry.LogPoolSwapInAggregator( tokenInKey: tokenInKey, tokenOutKey: tokenOutKey, tokenInAmount: poolInAmount, tokenOutAmount: poolOutVault.balance - prePoolOutBalance, poolAddress: poolAddress, poolSource: poolKey ) poolIndex = poolIndex + 1 } pairInVault <-> poolOutVault destroy poolOutVault pathStep = pathStep + 1 } tokenOutReceiverRef!.deposit(from: <- pairInVault) path = [] pathTokenAddress = [] pathTokenName = [] pathIndex = pathIndex + 1 } i = i + 1 } LogEntry.LogAggregateSwap( userAddr: userAccount.address, tokenInKey: swapInKey, tokenOutKey: swapOutKey, tokenInAmount: tokenInAmountTotal, tokenOutAmount: tokenOutAmountTotal, amountInSplitByPoolSource: splitAmountInWithPoolSource, isExactAForB: false ) assert(tokenInAmountTotal <= amountInMax, message: SwapError.ErrorEncode( msg: "SLIPPAGE_OFFSET_TOO_LARGE max in ".concat(amountInMax.toString()).concat(" got ").concat(tokenInAmountTotal.toString()), err: SwapError.ErrorCode.SLIPPAGE_OFFSET_TOO_LARGE ) ) } }

Transaction