feat: add import position to order planner

sdk/.env.template

@@ -13,4 +13,15 @@ ONE_INCH_ALLOWED_SWAP_PROTOCOLS='UNISWAP_V3,PMM1,PMM2,PMM3,PMM4,UNISWAP_V2,SUSHI
 # ChainIDs where 1Inch swaps are allowed (comma separated)
 ONE_INCH_SWAP_CHAIN_IDS='1'
 
+# 1Inch API spot URL
+ONE_INCH_API_SPOT_URL=''
+
+# 1Inch API spot version, like v1.0
+ONE_INCH_API_SPOT_VERSION='v1.0'
+
+# 1Inch API spot key
+ONE_INCH_API_SPOT_KEY=''
+
+# SDK Logging
 SDK_LOGGING_ENABLED=
+

sdk/configuration-provider/src/implementation/ConfigurationProvider.ts

@@ -3,6 +3,7 @@ import { IConfigurationProvider } from '../interfaces/IConfigurationProvider'
 import { ConfigItem } from '../types/ConfigItem'
 import { ConfigKey } from '../types/ConfigKey'
 
+// NOTICE: remember to add new config keys to the SDKs .env.template file as well
 const CONFIG_KEYS: ConfigKey[] = [
   'ONE_INCH_API_VERSION',
   'ONE_INCH_API_KEY',

sdk/order-planner-common/src/implementation/OrderPlanner.ts

@@ -1,33 +1,23 @@
-import { Order, type IPositionsManager } from '@summerfi/sdk-common/orders'
+import { Order, type IPositionsManager, TransactionInfo } from '@summerfi/sdk-common/orders'
 import { ISimulation, SimulationType, steps } from '@summerfi/sdk-common/simulation'
 import { Deployment } from '@summerfi/deployment-utils'
 import { Address, Maybe } from '@summerfi/sdk-common/common'
 import { HexData } from '@summerfi/sdk-common/common/aliases'
-import { ISwapManager } from '@summerfi/swap-common/interfaces'
-import { IUser } from '@summerfi/sdk-common/user'
 import {
   ActionBuilder,
   ActionBuildersMap,
   ActionCall,
-  IProtocolPluginsRegistry,
   IStepBuilderContext,
   StepBuilderContext,
 } from '@summerfi/protocol-plugins-common'
-import { IOrderPlanner } from '../interfaces/IOrderPlanner'
+import { IOrderPlanner, OrderPlannerParams } from '../interfaces/IOrderPlanner'
 import { encodeStrategy } from '../utils/EncodeStrategy'
 
 export class OrderPlanner implements IOrderPlanner {
+  // TODO: receive it as parameter in the constructor
   private readonly ExecutorContractName = 'OperationExecutor'
 
-  async buildOrder(params: {
-    user: IUser
-    positionsManager: IPositionsManager
-    simulation: ISimulation<SimulationType>
-    actionBuildersMap: ActionBuildersMap
-    deployment: Deployment
-    swapManager: ISwapManager
-    protocolsRegistry: IProtocolPluginsRegistry
-  }): Promise<Maybe<Order>> {
+  async buildOrder(params: OrderPlannerParams): Promise<Maybe<Order>> {
     const {
       user,
       positionsManager,
@@ -43,7 +33,7 @@ export class OrderPlanner implements IOrderPlanner {
     context.startSubContext()
 
     for (const step of simulation.steps) {
-      const stepBuilder = this.getActionBuilder(actionBuildersMap, step)
+      const stepBuilder = this._getActionBuilder(actionBuildersMap, step)
       if (!stepBuilder) {
         throw new Error(`No step builder found for step type ${step.type}`)
       }
@@ -65,10 +55,18 @@ export class OrderPlanner implements IOrderPlanner {
       throw new Error('Mismatched nested calls levels, probably a missing endSubContext call')
     }
 
-    return this._generateOrder(simulation, callsBatch, positionsManager, deployment)
+    const preRequisiteTransactions = context.transactions
+
+    return this._generateOrder({
+      simulation,
+      preRequisiteTransactions,
+      simulationCalls: callsBatch,
+      positionsManager,
+      deployment,
+    })
   }
 
-  private getActionBuilder<T extends steps.Steps>(
+  private _getActionBuilder<T extends steps.Steps>(
     actionBuildersMap: ActionBuildersMap,
     step: T,
   ): Maybe<ActionBuilder<T>> {
@@ -79,37 +77,39 @@ export class OrderPlanner implements IOrderPlanner {
     return `${simulation.simulationType}${simulation.sourcePosition?.pool.protocol.name}${simulation.targetPosition?.pool.protocol.name}`
   }
 
-  private _generateOrder(
-    simulation: ISimulation<SimulationType>,
-    simulationCalls: ActionCall[],
-    positionsManager: IPositionsManager,
-    deployment: Deployment,
-  ): Order {
+  private _generateOrder(params: {
+    simulation: ISimulation<SimulationType>
+    preRequisiteTransactions: TransactionInfo[]
+    simulationCalls: ActionCall[]
+    positionsManager: IPositionsManager
+    deployment: Deployment
+  }): Order {
+    const { simulation, preRequisiteTransactions, simulationCalls, positionsManager, deployment } =
+      params
+
     const executorInfo = deployment.contracts[this.ExecutorContractName]
     if (!executorInfo) {
       throw new Error(`Executor contract ${this.ExecutorContractName} not found in deployment`)
     }
     const executorAddress = Address.createFromEthereum({ value: executorInfo.address as HexData })
     const strategyName = this._getStrategyName(simulation)
 
-    const calldata = encodeStrategy({
+    const strategyExecutorTransaction = encodeStrategy({
       strategyName: strategyName,
       strategyExecutor: executorAddress,
+      positionsManager: positionsManager,
       actions: simulationCalls,
     })
 
+    const transactions = [...preRequisiteTransactions]
+
+    if (strategyExecutorTransaction) {
+      transactions.push(strategyExecutorTransaction)
+    }
+
     return {
-      simulation: simulation,
-      transactions: [
-        {
-          transaction: {
-            target: positionsManager.address,
-            calldata: calldata,
-            value: '0',
-          },
-          description: 'Strategy execution',
-        },
-      ],
+      simulation,
+      transactions,
     }
   }
 }

sdk/order-planner-common/src/interfaces/IOrderPlanner.ts

@@ -6,14 +6,15 @@ import { Maybe } from '@summerfi/sdk-common/common'
 import { IUser } from '@summerfi/sdk-common/user'
 import { ActionBuildersMap, IProtocolPluginsRegistry } from '@summerfi/protocol-plugins-common'
 
+export type OrderPlannerParams = {
+  user: IUser
+  positionsManager: IPositionsManager
+  simulation: ISimulation<SimulationType>
+  actionBuildersMap: ActionBuildersMap
+  deployment: Deployment
+  swapManager: ISwapManager
+  protocolsRegistry: IProtocolPluginsRegistry
+}
 export interface IOrderPlanner {
-  buildOrder<T extends SimulationType>(params: {
-    user: IUser
-    positionsManager: IPositionsManager
-    simulation: ISimulation<T>
-    actionBuildersMap: ActionBuildersMap
-    deployment: Deployment
-    swapManager: ISwapManager
-    protocolsRegistry: IProtocolPluginsRegistry
-  }): Promise<Maybe<Order>>
+  buildOrder(params: OrderPlannerParams): Promise<Maybe<Order>>
 }

sdk/order-planner-common/src/utils/EncodeStrategy.ts

@@ -1,5 +1,6 @@
 import { ActionCall } from '@summerfi/protocol-plugins-common'
-import { Address, HexData } from '@summerfi/sdk-common/common'
+import { Address, HexData, Maybe } from '@summerfi/sdk-common/common'
+import { IPositionsManager, TransactionInfo } from '@summerfi/sdk-common/orders'
 import { encodeFunctionData, parseAbi } from 'viem'
 
 type SkippableActionCall = ActionCall & {
@@ -42,14 +43,28 @@ export function encodeForPositionsManager(params: { target: Address; data: HexDa
 export function encodeStrategy(params: {
   strategyName: string
   strategyExecutor: Address
+  positionsManager: IPositionsManager
   actions: ActionCall[]
-}): HexData {
+}): Maybe<TransactionInfo> {
   const { strategyName, strategyExecutor, actions } = params
 
+  if (actions.length == 0) {
+    return undefined
+  }
+
   const executorData = encodeForExecutor({ strategyName, actions })
 
-  return encodeForPositionsManager({
+  const calldata = encodeForPositionsManager({
     target: strategyExecutor,
     data: executorData,
   })
+
+  return {
+    transaction: {
+      target: params.positionsManager.address,
+      calldata: calldata,
+      value: '0',
+    },
+    description: 'Strategy execution',
+  }
 }

sdk/order-planner-common/src/utils/GenerateStrategyName.ts

@@ -0,0 +1,5 @@
+import { ISimulation, SimulationType } from '@summerfi/sdk-common/simulation'
+
+export function generateStrategyName(simulation: ISimulation<SimulationType>): string {
+  return `${simulation.simulationType}${simulation.sourcePosition?.pool.protocol.name}${simulation.targetPosition?.pool.protocol.name}`
+}

sdk/order-planner-common/tests/EncodeStrategy.spec.ts

@@ -8,6 +8,7 @@ import {
   decodeStrategyExecutorCalldata,
 } from '@summerfi/testing-utils'
 import assert from 'assert'
+import { IPositionsManager } from '@summerfi/sdk-common/orders'
 
 class DerivedAction extends BaseAction {
   public readonly config = {
@@ -51,14 +52,23 @@ describe.only('Encode Strategy', () => {
   })
 
   it('should encode calls for operation executor', () => {
-    const calldata = encodeStrategy({
+    const positionsManager: IPositionsManager = {
+      address: Address.createFromEthereum({
+        value: '0x5e81A7515f956aB642eb698821a449fe8fE7498B',
+      }),
+    }
+
+    const transactionInfo = encodeStrategy({
       strategyName: 'SomeStrategyName',
       strategyExecutor: strategyExecutorAddress,
+      positionsManager: positionsManager,
       actions: [actionCall, otherActionCall],
     })
 
+    assert(transactionInfo, 'Cannot encode strategy')
+
     const positionsManagerParams = decodePositionsManagerCalldata({
-      calldata: calldata,
+      calldata: transactionInfo.transaction.calldata,
     })
 
     assert(positionsManagerParams, 'Cannot decode Positions Manager calldata')

sdk/order-planner-service/scripts/encodeMakerGive.ts

@@ -1,4 +1,5 @@
-import { encodeMakerGiveThroughProxyActions } from '../src/utils/MakerGive'
+import { encodeMakerGiveThroughProxyActions } from '@summerfi/protocol-plugins/plugins/maker'
+
 import yargs from 'yargs/yargs'
 import { Hex } from 'viem'
 
@@ -37,7 +38,12 @@ async function main() {
   console.log(`CDP ID: ${cdpId}`)
   console.log(`To: ${to}\n`)
 
-  const result = encodeMakerGiveThroughProxyActions({ makerProxyActions, cdpManager, cdpId, to })
+  const result = encodeMakerGiveThroughProxyActions({
+    makerProxyActionsAddress: makerProxyActions,
+    cdpManagerAddress: cdpManager,
+    cdpId,
+    giveToAddress: to,
+  })
 
   console.log(`[Full transaction Calldata]`)
   console.log(`${result.transactionCalldata}\n`)

sdk/order-planner-service/src/config/Config.ts

@@ -3,6 +3,7 @@ import { ActionBuildersMap } from '@summerfi/protocol-plugins-common'
 import {
   DepositBorrowActionBuilder,
   FlashloanActionBuilder,
+  ImportPositionActionBuilder,
   PaybackWithdrawActionBuilder,
   PositionCreatedActionBuilder,
   PullTokenActionBuilder,
@@ -20,4 +21,5 @@ export const ActionBuildersConfig: ActionBuildersMap = {
   [SimulationSteps.PaybackWithdraw]: PaybackWithdrawActionBuilder,
   [SimulationSteps.ReturnFunds]: ReturnFundsActionBuilder,
   [SimulationSteps.NewPositionEvent]: PositionCreatedActionBuilder,
+  [SimulationSteps.Import]: ImportPositionActionBuilder,
 }

sdk/order-planner-service/tests/service/OrderPlannerService.spec.ts

@@ -70,7 +70,9 @@ describe('Order Planner Service', () => {
         provider: undefined as unknown as PublicClient,
         tokenService: undefined as unknown as ITokenService,
         priceService: undefined as unknown as IPriceService,
+        deployments: deploymentsIndex,
       },
+      deploymentConfigTag: 'standard',
     })
 
     orderPlannerService = new OrderPlannerService({

sdk/order-planner-service/tests/utils/RefinanceSimulation/RefinanceSimulation.ts

@@ -65,15 +65,15 @@ export function getRefinanceSimulation(params: {
           amount: sourcePosition.debtAmount,
         },
         outputs: undefined,
-      } as steps.RepayFlashloan,
+      } as steps.RepayFlashloanStep,
       {
         name: 'ReturnFunds',
         type: SimulationSteps.ReturnFunds,
         inputs: {
           token: sourcePosition.debtAmount.token,
         },
         outputs: undefined,
-      } as steps.ReturnFunds,
+      } as steps.ReturnFundsStep,
     ],
   }
 }

sdk/order-planner-service/tsconfig.json

@@ -5,6 +5,11 @@
     "outDir": "dist",
     "baseUrl": "."
   },
-  "include": ["src/**/*.ts", "tests/**/*.ts", "scripts/**/*.ts"],
+  "include": [
+    "src/**/*.ts",
+    "tests/**/*.ts",
+    "scripts/**/*.ts",
+    "../protocol-plugins/src/plugins/maker/utils/MakerGive.ts"
+  ],
   "exclude": ["node_modules"]
 }

sdk/protocol-manager-service/tests/ProtocolManager.spec.ts

@@ -15,6 +15,7 @@ import {
   PriceService,
   ProtocolPluginsRegistry,
 } from '@summerfi/protocol-plugins/implementation'
+import { DeploymentIndex } from '@summerfi/deployment-utils'
 
 describe('Protocol Manager', () => {
   let ctx: IProtocolManagerContext
@@ -31,6 +32,7 @@ describe('Protocol Manager', () => {
     pluginsRegistry = new ProtocolPluginsRegistry({
       plugins: mockPlugins,
       context: ctx,
+      deploymentConfigTag: 'standard',
     })
     protocolManager = new ProtocolManager({ pluginsRegistry })
   })
@@ -71,6 +73,7 @@ describe('Protocol Manager', () => {
     const pluginsRegistry = new ProtocolPluginsRegistry({
       plugins: mockPlugins,
       context: ctx,
+      deploymentConfigTag: 'standard',
     })
 
     protocolManager = new ProtocolManager({ pluginsRegistry })
@@ -140,5 +143,6 @@ async function createProtocolManagerContext(): Promise<IProtocolManagerContext>
     provider,
     tokenService: new TokenService(),
     priceService: new PriceService(provider),
+    deployments: {} as DeploymentIndex,
   }
 }

sdk/protocol-manager-service/tsconfig.json

@@ -5,7 +5,8 @@
     "outDir": "dist",
     "baseUrl": ".",
     "paths": {
-      "@summerfi/protocol-plugins/*": ["node_modules/@summerfi/protocol-plugins/src/*"]
+      "@summerfi/protocol-plugins/*": ["node_modules/@summerfi/protocol-plugins/src/*"],
+      "@summerfi/deployment-utils": ["../../packages/deployment-utils/src/index.ts"]
     }
   },
   "include": ["src/**/*.ts", "tests/**/*.ts"],

sdk/protocol-manager-service/tsconfig.test.json

@@ -11,7 +11,8 @@
       "@summerfi/order-planner-common/*": ["node_modules/@summerfi/order-planner-common/src/*"],
       "@summerfi/protocol-plugins-common": [
         "node_modules/@summerfi/protocol-plugins-common/src/index.ts"
-      ]
+      ],
+      "@summerfi/deployment-utils": ["../../packages/deployment-utils/src/index.ts"]
     }
   },
   "include": ["src/**/*.ts"],