@lifi/composer-sdk 0.0.1-alpha → 0.2.0-staging.3

package/src/generated/config.generated.ts

@@ -11,6 +11,16 @@ export interface CoreSplitConfig {
  * a positive number
  */
 export type Positive = number;
+/**
+ * a string at most 64 character(s) long
+ */
+export type MaxLength64 = string;
+/**
+ * an array of at most 50 item(s)
+ *
+ * @maxItems 50
+ */
+export type MaxItems50 = MaxLength64[];
 
 export interface LifiSwapConfig {
   resourceOut:
@@ -38,19 +48,11 @@ export interface LifiSwapConfig {
       reduceEveryMs: number;
     }[];
   };
-}
-
-export interface LifiZapConfig {
-  resourceOut:
-    | {
-        kind: 'native';
-        chainId: Positive;
-      }
-    | {
-        kind: 'erc20';
-        token: Address;
-        chainId: Positive;
-      };
+  exchanges?: {
+    allow?: MaxItems50;
+    deny?: MaxItems50;
+    prefer?: MaxItems50;
+  };
 }
 
 export interface CoreBpsDownConfig {
@@ -120,22 +122,357 @@ export interface CoreAsResourceConfig {
       };
 }
 
-export interface CorePeekConfig {
-  target: Address;
-  functionSignature: string;
-  args?: string[];
+export interface AaveBorrowConfig {
+  pool: string;
+  asset: string;
+  variableDebtToken: string;
+  amount: IntegerStringInput;
+  referralId?: number;
+}
+
+export type AaveRepayConfig =
+  | {
+      pool: string;
+      mode: 'exact';
+    }
+  | {
+      pool: string;
+      mode: 'max';
+    };
+
+export interface AaveRepayWithATokensConfig {
+  pool: string;
+  asset: string;
+}
+
+export interface AaveClaimRewardsConfig {
+  rewardsController: string;
+  assets: string[];
+  reward: string;
+  amount?: IntegerStringInput;
+  to?: string;
+}
+
+/**
+ * a number between 0 and 255
+ */
+export type Between0255 = number;
+
+export interface AaveSetEModeConfig {
+  pool: string;
+  category: Between0255;
+}
+
+export interface AaveGetHealthFactorConfig {
+  pool: string;
+  user?: string;
+}
+
+export type MorphoBlueSupplyCollateralConfig =
+  | (
+      | {
+          morpho?: string;
+          onBehalfOf?: string;
+          mode: 'exact';
+          /**
+           * a string matching the pattern ^0x[0-9a-fA-F]{64}$
+           */
+          marketId: string;
+        }
+      | {
+          morpho?: string;
+          onBehalfOf?: string;
+          mode: 'exact';
+          marketParams: {
+            loanToken: string;
+            collateralToken: string;
+            oracle: string;
+            irm: string;
+            lltv: string;
+          };
+        }
+    )
+  | (
+      | {
+          morpho?: string;
+          onBehalfOf?: string;
+          mode: 'all';
+          /**
+           * a string matching the pattern ^0x[0-9a-fA-F]{64}$
+           */
+          marketId: string;
+        }
+      | {
+          morpho?: string;
+          onBehalfOf?: string;
+          mode: 'all';
+          marketParams: {
+            loanToken: string;
+            collateralToken: string;
+            oracle: string;
+            irm: string;
+            lltv: string;
+          };
+        }
+    );
+
+export type MorphoBlueWithdrawCollateralConfig =
+  | {
+      morpho?: string;
+      amount: IntegerStringInput;
+      onBehalfOf?: string;
+      receiver?: string;
+      /**
+       * a string matching the pattern ^0x[0-9a-fA-F]{64}$
+       */
+      marketId: string;
+    }
+  | {
+      morpho?: string;
+      amount: IntegerStringInput;
+      onBehalfOf?: string;
+      receiver?: string;
+      marketParams: {
+        loanToken: string;
+        collateralToken: string;
+        oracle: string;
+        irm: string;
+        lltv: string;
+      };
+    };
+
+export type MorphoBlueBorrowConfig =
+  | {
+      morpho?: string;
+      amount: IntegerStringInput;
+      onBehalfOf?: string;
+      receiver?: string;
+      /**
+       * a string matching the pattern ^0x[0-9a-fA-F]{64}$
+       */
+      marketId: string;
+    }
+  | {
+      morpho?: string;
+      amount: IntegerStringInput;
+      onBehalfOf?: string;
+      receiver?: string;
+      marketParams: {
+        loanToken: string;
+        collateralToken: string;
+        oracle: string;
+        irm: string;
+        lltv: string;
+      };
+    };
+
+export type MorphoBlueRepayConfig =
+  | (
+      | {
+          morpho?: string;
+          mode: 'exact';
+          /**
+           * a string matching the pattern ^0x[0-9a-fA-F]{64}$
+           */
+          marketId: string;
+        }
+      | {
+          morpho?: string;
+          mode: 'exact';
+          marketParams: {
+            loanToken: string;
+            collateralToken: string;
+            oracle: string;
+            irm: string;
+            lltv: string;
+          };
+        }
+    )
+  | (
+      | {
+          morpho?: string;
+          mode: 'max';
+          /**
+           * a string matching the pattern ^0x[0-9a-fA-F]{64}$
+           */
+          marketId: string;
+        }
+      | {
+          morpho?: string;
+          mode: 'max';
+          marketParams: {
+            loanToken: string;
+            collateralToken: string;
+            oracle: string;
+            irm: string;
+            lltv: string;
+          };
+        }
+    );
+
+export type MorphoBlueSupplyConfig =
+  | {
+      morpho?: string;
+      onBehalfOf?: string;
+      /**
+       * a string matching the pattern ^0x[0-9a-fA-F]{64}$
+       */
+      marketId: string;
+    }
+  | {
+      morpho?: string;
+      onBehalfOf?: string;
+      marketParams: {
+        loanToken: string;
+        collateralToken: string;
+        oracle: string;
+        irm: string;
+        lltv: string;
+      };
+    };
+
+export type MorphoBlueWithdrawConfig =
+  | (
+      | {
+          morpho?: string;
+          mode: 'exact';
+          amount: IntegerStringInput;
+          onBehalfOf?: string;
+          receiver?: string;
+          /**
+           * a string matching the pattern ^0x[0-9a-fA-F]{64}$
+           */
+          marketId: string;
+        }
+      | {
+          morpho?: string;
+          mode: 'exact';
+          amount: IntegerStringInput;
+          onBehalfOf?: string;
+          receiver?: string;
+          marketParams: {
+            loanToken: string;
+            collateralToken: string;
+            oracle: string;
+            irm: string;
+            lltv: string;
+          };
+        }
+    )
+  | (
+      | {
+          morpho?: string;
+          mode: 'max';
+          onBehalfOf?: string;
+          receiver?: string;
+          /**
+           * a string matching the pattern ^0x[0-9a-fA-F]{64}$
+           */
+          marketId: string;
+        }
+      | {
+          morpho?: string;
+          mode: 'max';
+          onBehalfOf?: string;
+          receiver?: string;
+          marketParams: {
+            loanToken: string;
+            collateralToken: string;
+            oracle: string;
+            irm: string;
+            lltv: string;
+          };
+        }
+    );
+
+export type MorphoBlueGetPositionConfig =
+  | {
+      morpho?: string;
+      user?: string;
+      /**
+       * a string matching the pattern ^0x[0-9a-fA-F]{64}$
+       */
+      marketId: string;
+    }
+  | {
+      morpho?: string;
+      user?: string;
+      marketParams: {
+        loanToken: string;
+        collateralToken: string;
+        oracle: string;
+        irm: string;
+        lltv: string;
+      };
+    };
+
+export interface LifiFlashloanRepayConfig {
+  leg: string;
+  fee?: string;
+}
+
+export interface LifiZapConfig {
+  resourceOut:
+    | {
+        kind: 'native';
+        chainId: Positive;
+      }
+    | {
+        kind: 'erc20';
+        token: Address;
+        chainId: Positive;
+      };
 }
 
+/**
+ * a non-negative number
+ */
+export type GreaterThanOrEqualTo0 = number;
 /**
  * a number between 0 and 10000
  */
 export type Between010000 = number;
 
+export interface ParaswapBuyConfig {
+  resourceOut:
+    | {
+        kind: 'native';
+        chainId: Positive;
+      }
+    | {
+        kind: 'erc20';
+        token: Address;
+        chainId: Positive;
+      };
+  exactAmountOut: string;
+  srcDecimals: GreaterThanOrEqualTo0;
+  destDecimals: GreaterThanOrEqualTo0;
+  maxSlippageBps?: Between010000;
+  partner?: string;
+  partnerAddress?: string;
+  /**
+   * Integrator fee in basis points; non-negative integer string capped at 9000.
+   */
+  partnerFeeBps?: string;
+}
+
+export interface CorePeekConfig {
+  target: Address;
+  functionSignature: string;
+  args?: string[];
+}
+
 export interface SlippageGuardConfig {
   port: string;
   bps: Between010000;
 }
 
+export interface CoreNumericInvariantGuardConfig {
+  port: string;
+  op: 'gte' | 'gt' | 'lte' | 'lt' | 'eq' | 'neq';
+  threshold: IntegerStringInput;
+}
+
 export interface BalanceOfMaterialiserConfig {
   owner: Address;
 }
@@ -146,8 +483,12 @@ export type DirectDepositMaterialiserConfig =
       allowNonExact?: false;
     }
   | {
-      amount?: IntegerStringInput;
+      amount: IntegerStringInput;
       allowNonExact: true;
+    }
+  | {
+      allowNonExact: true;
+      simAmount?: string;
     };
 
 export interface CallMaterialiserConfig {
@@ -155,6 +496,11 @@ export interface CallMaterialiserConfig {
   calldata: string;
 }
 
+export interface FlashloanMaterialiserConfig {
+  providerKind: 'aave-v3' | 'erc3156' | 'balancer-v2' | 'morpho-blue';
+  amount: IntegerStringInput;
+}
+
 export interface Erc20BalancePreconditionConfig {
   wallet: Address;
   token: Address;

package/src/generated/guards.generated.ts

@@ -3,7 +3,10 @@
 
 import type { TypedGuard } from '../types.js';
 
-import type { SlippageGuardConfig } from './config.generated.js';
+import type {
+  CoreNumericInvariantGuardConfig,
+  SlippageGuardConfig,
+} from './config.generated.js';
 
 /** Assert that output amounts are within a slippage tolerance in basis points */
 export const slippage = <P extends string>(
@@ -12,3 +15,11 @@ export const slippage = <P extends string>(
   kind: 'slippage',
   ...config,
 });
+
+/** Assert a numeric (uint256) handle output of the target op satisfies a comparison against a constant threshold. Emits one IR1 binary invariant; reverts the run on violation. */
+export const coreNumericInvariant = <P extends string>(
+  config: Omit<CoreNumericInvariantGuardConfig, 'port'> & { port: P },
+): TypedGuard<P> => ({
+  kind: 'core.numericInvariant',
+  ...config,
+});

package/src/generated/materialisers.generated.ts

@@ -7,38 +7,50 @@ import type {
 } from '@lifi/compose-spec';
 
 import type {
-  BalanceOfMaterialiserConfig,
-  CallMaterialiserConfig,
-  DirectDepositMaterialiserConfig,
+  BalanceOfMaterialiserConfig as BalanceOfMaterialiserConfigSchema,
+  CallMaterialiserConfig as CallMaterialiserConfigSchema,
+  DirectDepositMaterialiserConfig as DirectDepositMaterialiserConfigSchema,
+  FlashloanMaterialiserConfig as FlashloanMaterialiserConfigSchema,
 } from './config.generated.js';
 
-export type BalanceOfMaterialiserInput =
-  MaterialiserConfigOf<BalanceOfMaterialiserConfig>;
+export type BalanceOfMaterialiserConfig =
+  MaterialiserConfigOf<BalanceOfMaterialiserConfigSchema>;
 
 /** Read the on-chain token balance of an address as the input amount — accepts: resource */
 export const balanceOf = (
-  config: BalanceOfMaterialiserInput,
+  config: BalanceOfMaterialiserConfig,
 ): MaterialiserInput => ({
   kind: 'balanceOf',
   ...config,
 });
 
-export type DirectDepositMaterialiserInput =
-  MaterialiserConfigOf<DirectDepositMaterialiserConfig>;
+export type DirectDepositMaterialiserConfig =
+  MaterialiserConfigOf<DirectDepositMaterialiserConfigSchema>;
 
 /** Deposit tokens into the VM — native via msg.value, ERC-20 via transferFrom — accepts: resource */
 export const directDeposit = (
-  config: DirectDepositMaterialiserInput,
+  config: DirectDepositMaterialiserConfig,
 ): MaterialiserInput => ({
   kind: 'directDeposit',
   ...config,
 });
 
-export type CallMaterialiserInput =
-  MaterialiserConfigOf<CallMaterialiserConfig>;
+export type CallMaterialiserConfig =
+  MaterialiserConfigOf<CallMaterialiserConfigSchema>;
 
 /** Execute an arbitrary contract call and measure the resulting token balance diff — accepts: resource */
-export const call = (config: CallMaterialiserInput): MaterialiserInput => ({
+export const call = (config: CallMaterialiserConfig): MaterialiserInput => ({
   kind: 'call',
   ...config,
 });
+
+export type FlashloanMaterialiserConfig =
+  MaterialiserConfigOf<FlashloanMaterialiserConfigSchema>;
+
+/** Borrow tokens from a flashloan provider; amount becomes a register populated by the proxy at callback time — accepts: resource */
+export const flashloan = (
+  config: FlashloanMaterialiserConfig,
+): MaterialiserInput => ({
+  kind: 'flashloan',
+  ...config,
+});