@strkfarm/sdk 1.1.70 → 2.0.0-dev.1

package/src/strategies/universal-adapters/baseAdapter.ts

@@ -1,9 +1,9 @@
 import { Call, hash, num, shortString } from "starknet";
 import { SIMPLE_SANITIZER, toBigInt } from "./adapter-utils";
 import { ContractAddr, Web3Number } from "@/dataTypes";
-import { IConfig, TokenInfo } from "@/interfaces";
+import { IConfig, IProtocol, TokenInfo } from "@/interfaces";
 import { PricerBase } from "@/modules/pricerBase";
-import { LeafData } from "@/utils";
+import { LeafData, logger, StandardMerkleTree } from "@/utils";
 import { CacheClass } from "@/utils/cacheClass";
 
 export interface ManageCall {
@@ -15,10 +15,19 @@ export interface ManageCall {
   }
 }
 
-export type GenerateCallFn<T> = (params: T) => ManageCall;
-export type AdapterLeafType<T> = {leaf: LeafData, callConstructor: GenerateCallFn<T>}
-// export type GenerateCallFn<T> = (params: T) => ManageCall[];
-// export type AdapterLeafType<T> = {leaves: LeafData[], callConstructor: GenerateCallFn<T>}
+
+export interface DepositParams {
+  amount: Web3Number;
+}
+
+export interface WithdrawParams {
+  amount: Web3Number;
+}
+
+// export type GenerateCallFn<T> = (params: T) => ManageCall;
+// export type AdapterLeafType<T> = {leaf: LeafData, callConstructor: GenerateCallFn<T>}
+export type GenerateCallFn<T> = (params: T) => Promise<ManageCall[]>;
+export type AdapterLeafType<T> = {leaves: LeafData[], callConstructor: GenerateCallFn<T>}
 export type LeafAdapterFn<T> = () => AdapterLeafType<T>;
 
 export enum APYType {
@@ -43,68 +52,73 @@ export interface BaseAdapterConfig {
 
 export type PositionAPY = { apy: number, type: APYType };
 export type PositionInfo = {
+  tokenInfo: TokenInfo,
   amount: Web3Number,
   usdValue: number,
-  remarks?: string,
-  apy: PositionAPY
+  remarks: string,
+  apy: PositionAPY,
+  protocol: IProtocol
 };
 
-// export abstract class BaseAdapter<T1, T2> extends CacheClass {
-  export abstract class BaseAdapter extends CacheClass {
-
-  // readonly config: BaseAdapterConfig;
+export type PositionAmount = {
+  amount: Web3Number,
+  remarks: string,
+}
 
-  // constructor(config: BaseAdapterConfig) {
-  //   super();
-  //   this.config = config;
-  // }
+export abstract class BaseAdapter<DepositParams, WithdrawParams> extends CacheClass {
+  readonly name: string;
+  readonly config: BaseAdapterConfig;
+  readonly protocol: IProtocol;
 
-  constructor() {
+  constructor(config: BaseAdapterConfig, name: string, protocol: IProtocol) {
     super();
+    this.config = config;
+    this.name = name;
+    this.protocol = protocol;
+  }
+
+  /**
+   * Loop through all supported positions and return amount, usd value, remarks and apy for each
+   */
+  async getPositions(): Promise<PositionInfo[]> {
+    const results: PositionInfo[] = [];
+    for (const supported of this.config.supportedPositions) {
+      const amount = await this.getPosition(supported);
+      const usdValue = await this.getUSDValue(supported.asset, amount.amount);
+      const apy = await this.getAPY(supported);
+      results.push({ tokenInfo: supported.asset, amount: amount.amount, usdValue, apy, protocol: this.protocol, remarks: amount.remarks });
+    }
+    return results;
   }
 
-  // /**
-  //  * Loop through all supported positions and return amount, usd value, remarks and apy for each
-  //  */
-  // async getPositions(): Promise<PositionInfo[]> {
-  //   const results: PositionInfo[] = [];
-  //   for (const supported of this.config.supportedPositions) {
-  //     const amount = await this.getPosition(supported);
-  //     const usdValue = await this.getUSDValue(supported.asset, amount);
-  //     const apy = await this.getAPY(supported);
-  //     results.push({ amount, usdValue, apy });
-  //   }
-  //   return results;
-  // }
-
-  // /**
-  //  * Implemented by child adapters to compute APY for a given supported position
-  //  */
-  // protected abstract getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
-
-  // /**
-  //  * Implemented by child adapters to fetch amount for a given supported position
-  //  */
-  // protected abstract getPosition(supportedPosition: SupportedPosition): Promise<Web3Number>;
-
-  // /**
-  //  * Implemented by child adapters to calculate maximum deposit positions
-  //  * @param amount Optional amount in baseToken to deposit
-  //  */
-  // protected abstract maxDeposit(amount?: Web3Number): Promise<PositionInfo[]>;
-
-  // /**
-  //  * Implemented by child adapters to calculate maximum withdraw positions
-  //  */
-  // protected abstract maxWithdraw(): Promise<PositionInfo[]>;
-
-  // /**
-  //  * Uses pricer to convert an amount of an asset to USD value
-  //  */
-  // protected async getUSDValue(asset: TokenInfo, amount: Web3Number): Promise<number> {
-  //   const priceInfo = await this.config.pricer.getPrice(asset.symbol);
-  //   return amount.toNumber() * priceInfo.price;
-  // }
+  /**
+   * Implemented by child adapters to compute APY for a given supported position
+   */
+  protected abstract getAPY(supportedPosition: SupportedPosition): Promise<PositionAPY>;
+
+  /**
+   * Implemented by child adapters to fetch amount for a given supported position
+   */
+  protected abstract getPosition(supportedPosition: SupportedPosition): Promise<PositionAmount>;
+
+  /**
+   * Implemented by child adapters to calculate maximum deposit positions
+   * @param amount Optional amount in baseToken to deposit
+   */
+  abstract maxDeposit(amount?: Web3Number): Promise<PositionInfo>;
+
+  /**
+   * Implemented by child adapters to calculate maximum withdraw positions
+   */
+  abstract maxWithdraw(): Promise<PositionInfo>;
+
+  /**
+   * Uses pricer to convert an amount of an asset to USD value
+   */
+  protected async getUSDValue(asset: TokenInfo, amount: Web3Number): Promise<number> {
+    const priceInfo = await this.config.pricer.getPrice(asset.symbol);
+    return amount.toNumber() * priceInfo.price;
+  }
 
   
   protected constructSimpleLeafData(params: {
@@ -127,97 +141,111 @@ export type PositionInfo = {
     };
   }
 
-  // /**
-  //  * Implementor must provide target/method/packedArguments/sanitizer for deposit leaf construction
-  //  */
-  // protected abstract _getDepositLeaf(): {
-  //   target: ContractAddr,
-  //   method: string,
-  //   packedArguments: bigint[],
-  //   sanitizer: ContractAddr,
-  //   id: string
-  // }[];
-
-  // /**
-  //  * Implementor must provide target/method/packedArguments/sanitizer for withdraw leaf construction
-  //  */
-  // protected abstract _getWithdrawLeaf(): {
-  //   target: ContractAddr,
-  //   method: string,
-  //   packedArguments: bigint[],
-  //   sanitizer: ContractAddr,
-  //   id: string
-  // }[];
-
-  // /**
-  //  * Returns deposit leaf adapter using configured proof id
-  //  */
-  // getDepositLeaf(): AdapterLeafType<T1> {
-  //   const leafConfigs = this._getDepositLeaf();
-  //   const leaves = leafConfigs.map(config => {
-  //     const { target, method, packedArguments, sanitizer, id } = config;
-  //     const leaf = this.constructSimpleLeafData({
-  //       id: id,
-  //       target,
-  //       method,
-  //       packedArguments
-  //     }, sanitizer);
-  //     return leaf;
-  //   });
-  //   return { leaves, callConstructor: this.getDepositCall.bind(this) as unknown as GenerateCallFn<T1> };
-  // }
-
-  // /**
-  //  * Returns withdraw leaf adapter using configured proof id
-  //  */
-  // getWithdrawLeaf(): AdapterLeafType<T2> {
-  //   const leafConfigs = this._getWithdrawLeaf();
-  //   const leaves = leafConfigs.map(config => {
-  //     const { target, method, packedArguments, sanitizer, id } = config;
-  //     const leaf = this.constructSimpleLeafData({
-  //       id: id,
-  //       target,
-  //       method,
-  //       packedArguments
-  //     }, sanitizer ?? SIMPLE_SANITIZER);
-  //     return leaf;
-  //   });
-  //   return { leaves, callConstructor: this.getWithdrawCall.bind(this) as unknown as GenerateCallFn<T2> };
-  // }
-
-  // /**
-  //  * Default deposit callConstructor: expects params as calldata (bigint[])
-  //  */
-  // protected getDepositCall<T1 = bigint[]>(params: T1): ManageCall[] {
-  //   const leafConfigs = this._getDepositLeaf();
-  //   return leafConfigs.map(config => {
-  //     const { target, method, sanitizer } = config;
-  //     return {
-  //       sanitizer: sanitizer ?? SIMPLE_SANITIZER,
-  //       call: {
-  //         contractAddress: target,
-  //         selector: hash.getSelectorFromName(method),
-  //         calldata: params as unknown as bigint[]
-  //       }
-  //     };
-  //   });
-  // }
-
-  // /**
-  //  * Default withdraw callConstructor: expects params as calldata (bigint[])
-  //  */
-  // protected getWithdrawCall<T2 = bigint[]>(params: T2): ManageCall[] {
-  //   const leafConfigs = this._getWithdrawLeaf();
-  //   return leafConfigs.map(config => {
-  //     const { target, method, sanitizer } = config;
-  //     return {
-  //       sanitizer: sanitizer ?? SIMPLE_SANITIZER,
-  //       call: {
-  //         contractAddress: target,
-  //         selector: hash.getSelectorFromName(method),
-  //         calldata: params as unknown as bigint[]
-  //       }
-  //     };
-  //   });
-  // }
-}
+  /**
+   * Implementor must provide target/method/packedArguments/sanitizer for deposit leaf construction
+   */
+  protected abstract _getDepositLeaf(): {
+    target: ContractAddr,
+    method: string,
+    packedArguments: bigint[],
+    sanitizer: ContractAddr,
+    id: string
+  }[];
+
+  /**
+   * Implementor must provide target/method/packedArguments/sanitizer for withdraw leaf construction
+   */
+  protected abstract _getWithdrawLeaf(): {
+    target: ContractAddr,
+    method: string,
+    packedArguments: bigint[],
+    sanitizer: ContractAddr,
+    id: string
+  }[];
+
+  /**
+   * Returns deposit leaf adapter using configured proof id
+   */
+  getDepositLeaf(): AdapterLeafType<DepositParams> {
+    const leafConfigs = this._getDepositLeaf();
+    const leaves = leafConfigs.map(config => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      const leaf = this.constructSimpleLeafData({
+        id: id,
+        target,
+        method,
+        packedArguments
+      }, sanitizer);
+      return leaf;
+    });
+    return { leaves, callConstructor: this.getDepositCall.bind(this) as unknown as GenerateCallFn<DepositParams> };
+  }
+
+  /**
+   * Returns withdraw leaf adapter using configured proof id
+   */
+  getWithdrawLeaf(): AdapterLeafType<WithdrawParams> {
+    const leafConfigs = this._getWithdrawLeaf();
+    const leaves = leafConfigs.map(config => {
+      const { target, method, packedArguments, sanitizer, id } = config;
+      const leaf = this.constructSimpleLeafData({
+        id: id,
+        target,
+        method,
+        packedArguments
+      }, sanitizer ?? SIMPLE_SANITIZER);
+      return leaf;
+    });
+    return { leaves, callConstructor: this.getWithdrawCall.bind(this) as unknown as GenerateCallFn<WithdrawParams> };
+  }
+
+  /**
+   * Implementor must provide deposit call
+   * @param params 
+   */
+  abstract getDepositCall(params: DepositParams): Promise<ManageCall[]>;
+
+  /**
+   * Implementor must provide withdraw call
+   * @param params 
+   */
+  abstract getWithdrawCall(params: WithdrawParams): Promise<ManageCall[]>;
+
+
+  getProofs<T>(isDeposit: boolean, tree: StandardMerkleTree): { proofs: string[][], callConstructor: GenerateCallFn<DepositParams> | GenerateCallFn<WithdrawParams> } {
+    let proofGroups: string[][] = [];
+
+    const ids = isDeposit ? this.getDepositLeaf().leaves.map(l => l.readableId) : this.getWithdrawLeaf().leaves.map(l => l.readableId);
+    // console.log(`${this.name}::getProofs ids: ${ids}`);
+    for (const [i, v] of tree.entries()) {
+     // console.log(`${this.name}::getProofs v: ${v.readableId}`);
+      if (ids.includes(v.readableId)) {
+       // console.log(`${this.name}::getProofs found id: ${v.readableId}`);
+        proofGroups.push(tree.getProof(i));
+      }
+    }
+    if (proofGroups.length != ids.length) {
+      throw new Error(`Not all proofs found for IDs: ${ids.join(', ')}`);
+    }
+
+    // find leaf adapter
+    return {
+      proofs: proofGroups,
+      callConstructor: isDeposit ? 
+        this.getDepositCall.bind(this) :
+        this.getWithdrawCall.bind(this)
+      };
+    }
+
+  async getNetAPY(): Promise<number> {
+    const positions = await this.getPositions();
+    logger.verbose(`${this.name}::getNetAPY: positions: ${JSON.stringify(positions)}`);
+    const netAmount = positions.reduce((acc, curr) => acc + curr.usdValue, 0);
+    const netAPY = positions.reduce((acc, curr) => acc + curr.apy.apy * curr.usdValue, 0) / netAmount;
+    logger.verbose(`${this.name}::getNetAPY: netAPY: ${netAPY}`);
+    return netAPY;
+  }
+
+  abstract getHealthFactor(): Promise<number>;
+}
+

package/src/strategies/universal-adapters/common-adapter.ts

@@ -24,15 +24,34 @@ export interface CommonAdapterConfig {
   asset: ContractAddr
 }
 
-export class CommonAdapter extends BaseAdapter {
+export class CommonAdapter {
   config: CommonAdapterConfig;
 
   constructor(config: CommonAdapterConfig) {
-    super();
     this.config = config;
   }
 
-  getFlashloanAdapter(): AdapterLeafType<FlashloanCallParams> {
+  protected constructSimpleLeafData(params: {
+    id: string,
+    target: ContractAddr,
+    method: string,
+    packedArguments: bigint[],
+  }, sanitizer: ContractAddr = SIMPLE_SANITIZER): LeafData {
+    const { id, target, method, packedArguments } = params;
+    return {
+      id: BigInt(num.getDecimalString(shortString.encodeShortString(id))),
+      readableId: id,
+      data: [
+        sanitizer.toBigInt(), // sanitizer address
+        target.toBigInt(), // contract
+        toBigInt(hash.getSelectorFromName(method)), // method name
+        BigInt(packedArguments.length),
+        ...packedArguments
+      ]
+    };
+  }
+
+  async getFlashloanAdapter(): Promise<AdapterLeafType<FlashloanCallParams>> {
     const manageCall = this.getFlashloanCall.bind(this)({amount: Web3Number.fromWei('0', 6), data: []});
     const packedArguments: bigint[] = [
       this.config.manager.toBigInt(), // receiver
@@ -41,16 +60,16 @@ export class CommonAdapter extends BaseAdapter {
     ];
     const leaf = this.constructSimpleLeafData({
       id: this.config.id,
-      target: manageCall.call.contractAddress,
+      target: (await manageCall)[0].call.contractAddress,
       method: 'flash_loan',
       packedArguments
     });
-    return { leaf, callConstructor: this.getFlashloanCall.bind(this) };
+    return { leaves: [leaf], callConstructor: this.getFlashloanCall.bind(this) };
   }
 
-  getFlashloanCall(params: FlashloanCallParams): ManageCall {
+  async getFlashloanCall(params: FlashloanCallParams): Promise<ManageCall[]> {
     const uint256Amount = uint256.bnToUint256(params.amount.toWei());
-    return {
+    return [{
       sanitizer: SIMPLE_SANITIZER,
       call: {
         contractAddress: this.config.manager,
@@ -65,27 +84,40 @@ export class CommonAdapter extends BaseAdapter {
           ...params.data
         ]
       }
-    }
+    }]
+  }
+
+  getBringLiquidityAdapter(id: string): () => AdapterLeafType<ApproveCallParams> {
+    return () => ({
+      leaves: [this.constructSimpleLeafData({
+        id: id,
+        target: this.config.vaultAddress,
+        method: 'bring_liquidity',
+        packedArguments: []
+      })],
+      callConstructor: this.getBringLiquidityCall().bind(this)
+    });
   }
 
   getApproveAdapter(token: ContractAddr, spender: ContractAddr, id: string): () => AdapterLeafType<ApproveCallParams> {
     return () => ({
-      leaf: this.constructSimpleLeafData({
+      leaves: [this.constructSimpleLeafData({
         id: id,
         target: token,
         method: 'approve',
         packedArguments: [
           spender.toBigInt(), // spender
         ]
-      }),
+      })],
       callConstructor: this.getApproveCall(token, spender).bind(this)
     });
   }
 
   getApproveCall(token: ContractAddr, spender: ContractAddr) {
-    return (params: ApproveCallParams) => {
+    return async (params: ApproveCallParams) => {
       const uint256Amount = uint256.bnToUint256(params.amount.toWei());
-      return {
+      console.log(`${CommonAdapter.name}::getApproveCall token: ${token}, spender: ${spender}, amount: ${params.amount}`);
+      return [{
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: token,
@@ -96,26 +128,15 @@ export class CommonAdapter extends BaseAdapter {
             toBigInt(uint256Amount.high.toString()), // amount high
           ]
         }
-      }
+      }]
     }
   }
 
-  getBringLiquidityAdapter(id: string): () => AdapterLeafType<ApproveCallParams> {
-    return () => ({
-      leaf: this.constructSimpleLeafData({
-        id: id,
-        target: this.config.vaultAddress,
-        method: 'bring_liquidity',
-        packedArguments: []
-      }),
-      callConstructor: this.getBringLiquidityCall().bind(this)
-    });
-  }
 
-  getBringLiquidityCall() {
-    return (params: ApproveCallParams) => {
+  getBringLiquidityCall(): GenerateCallFn<ApproveCallParams> {
+    return async (params: ApproveCallParams) => {
       const uint256Amount = uint256.bnToUint256(params.amount.toWei());
-      return {
+      return [{
         sanitizer: SIMPLE_SANITIZER,
         call: {
           contractAddress: this.config.vaultAddress,
@@ -125,59 +146,59 @@ export class CommonAdapter extends BaseAdapter {
             toBigInt(uint256Amount.high.toString()), // amount high
           ]
         }
-      }
+      }]
     }
   }
 
-  getAvnuAdapter(fromToken: ContractAddr, toToken: ContractAddr, id: string, isMiddleware: boolean): () => AdapterLeafType<AvnuSwapCallParams> {
-    return () => ({
-      leaf: this.constructSimpleLeafData({
-        id: id,
-        target: isMiddleware ? AVNU_MIDDLEWARE : AVNU_EXCHANGE,
-        method: 'multi_route_swap',
-        packedArguments: [
-          fromToken.toBigInt(),
-          toToken.toBigInt(),
-          this.config.vaultAllocator.toBigInt(),
-        ]
-      }),
-      callConstructor: this.getAvnuCall(fromToken, toToken, isMiddleware).bind(this)
-    });
-  }
+  // getAvnuAdapter(fromToken: ContractAddr, toToken: ContractAddr, id: string, isMiddleware: boolean): () => AdapterLeafType<AvnuSwapCallParams> {
+  //   return () => ({
+  //     leaf: this.constructSimpleLeafData({
+  //       id: id,
+  //       target: isMiddleware ? AVNU_MIDDLEWARE : AVNU_EXCHANGE,
+  //       method: 'multi_route_swap',
+  //       packedArguments: [
+  //         fromToken.toBigInt(),
+  //         toToken.toBigInt(),
+  //         this.config.vaultAllocator.toBigInt(),
+  //       ]
+  //     }),
+  //     callConstructor: this.getAvnuCall(fromToken, toToken, isMiddleware).bind(this)
+  //   });
+  // }
 
-  getAvnuCall(fromToken: ContractAddr, toToken: ContractAddr, isMiddleware: boolean): GenerateCallFn<AvnuSwapCallParams> {
-    return (params: AvnuSwapCallParams): ManageCall => {
-      return {
-        sanitizer: SIMPLE_SANITIZER,
-        call: {
-          contractAddress: isMiddleware ? AVNU_MIDDLEWARE : AVNU_EXCHANGE,
-          selector: hash.getSelectorFromName('multi_route_swap'),
-          calldata: [
-            fromToken.toBigInt(), // sell_token_address
-            toBigInt(params.props.token_from_amount.low.toString()), // sell_token_amount low
-            toBigInt(params.props.token_from_amount.high.toString()), // sell_token_amount high
-            toToken.toBigInt(), // buy_token_address
-            toBigInt(params.props.token_to_amount.low.toString()), // buy_token_amount low
-            toBigInt(params.props.token_to_amount.high.toString()), // buy_token_amount high
-            toBigInt(params.props.token_to_min_amount.low.toString()), // buy_token_min_amount low
-            toBigInt(params.props.token_to_min_amount.high.toString()), // buy_token_min_amount high
-            this.config.vaultAllocator.toBigInt(), // beneficiary
-            toBigInt(0), // integrator_fee_amount_bps
-            this.config.vaultAllocator.toBigInt(), // integrator_fee_recipient
+  // getAvnuCall(fromToken: ContractAddr, toToken: ContractAddr, isMiddleware: boolean): GenerateCallFn<AvnuSwapCallParams> {
+  //   return (params: AvnuSwapCallParams): ManageCall => {
+  //     return {
+  //       sanitizer: SIMPLE_SANITIZER,
+  //       call: {
+  //         contractAddress: isMiddleware ? AVNU_MIDDLEWARE : AVNU_EXCHANGE,
+  //         selector: hash.getSelectorFromName('multi_route_swap'),
+  //         calldata: [
+  //           fromToken.toBigInt(), // sell_token_address
+  //           toBigInt(params.props.token_from_amount.low.toString()), // sell_token_amount low
+  //           toBigInt(params.props.token_from_amount.high.toString()), // sell_token_amount high
+  //           toToken.toBigInt(), // buy_token_address
+  //           toBigInt(params.props.token_to_amount.low.toString()), // buy_token_amount low
+  //           toBigInt(params.props.token_to_amount.high.toString()), // buy_token_amount high
+  //           toBigInt(params.props.token_to_min_amount.low.toString()), // buy_token_min_amount low
+  //           toBigInt(params.props.token_to_min_amount.high.toString()), // buy_token_min_amount high
+  //           this.config.vaultAllocator.toBigInt(), // beneficiary
+  //           toBigInt(0), // integrator_fee_amount_bps
+  //           this.config.vaultAllocator.toBigInt(), // integrator_fee_recipient
 
-            // unpack routes
-            BigInt(params.props.routes.length),
-            ...params.props.routes.map(r => ([
-              BigInt(num.hexToDecimalString(r.token_from)),
-              BigInt(num.hexToDecimalString(r.token_to)),
-              BigInt(num.hexToDecimalString(r.exchange_address)),
-              BigInt(r.percent),
-              BigInt(r.additional_swap_params.length),
-              ...r.additional_swap_params.map(p => BigInt(num.hexToDecimalString(p)))
-            ])).flat()
-          ]
-        }
-      }
-    }
-  }
+  //           // unpack routes
+  //           BigInt(params.props.routes.length),
+  //           ...params.props.routes.map(r => ([
+  //             BigInt(num.hexToDecimalString(r.token_from)),
+  //             BigInt(num.hexToDecimalString(r.token_to)),
+  //             BigInt(num.hexToDecimalString(r.exchange_address)),
+  //             BigInt(r.percent),
+  //             BigInt(r.additional_swap_params.length),
+  //             ...r.additional_swap_params.map(p => BigInt(num.hexToDecimalString(p)))
+  //           ])).flat()
+  //         ]
+  //       }
+  //     }
+  //   }
+  // }
 }