@gearbox-protocol/sdk 14.12.0-next.12 → 14.12.0-next.14

package/dist/esm/preview/prerequisites/checkPrerequisites.js

@@ -0,0 +1,63 @@
+import {
+  parseOperationCalldata
+} from "../parse/parseOperationCalldata.js";
+import { buildCollateralPrerequisites } from "./buildCollateralPrerequisites.js";
+import { buildPartialLiquidationPrerequisites } from "./buildPartialLiquidationPrerequisites.js";
+import { buildPoolPrerequisites } from "./buildPoolPrerequisites.js";
+import { buildRWAPrerequisites } from "./buildRWAPrerequisites.js";
+async function checkPrerequisites(input) {
+  const { sdk, sender: wallet, blockNumber } = input;
+  const tx = parseOperationCalldata(input);
+  const ctx = { sdk, wallet, blockNumber };
+  const prereqs = await buildPrerequisites(tx, ctx);
+  return Promise.all(
+    // Each prereq pairs its own kind with its detail, so the widened
+    // `verify` return is safe to narrow back to the discriminated union.
+    prereqs.map((p) => p.verify(ctx))
+  );
+}
+async function buildPrerequisites(tx, ctx) {
+  const { wallet } = ctx;
+  switch (tx.operation) {
+    case "Deposit":
+    case "Mint":
+    case "Redeem":
+    case "Withdraw":
+      return buildPoolPrerequisites(tx, wallet);
+    case "MultiCall":
+    case "BotMulticall":
+    case "OpenCreditAccount":
+    case "CloseCreditAccount":
+    case "LiquidateCreditAccount":
+      return buildCollateralPrerequisites(
+        tx.operation === "OpenCreditAccount" ? { creditManager: tx.creditManager, borrower: wallet } : {
+          creditManager: tx.creditManager,
+          creditAccount: tx.creditAccount
+        },
+        tx.multicall,
+        ctx
+      );
+    case "RWAOpenCreditAccount":
+      return [
+        ...await buildCollateralPrerequisites(
+          { creditManager: tx.creditManager, borrower: wallet },
+          tx.multicall,
+          ctx
+        ),
+        ...buildRWAPrerequisites(tx.multicall, tx.creditManager, tx.args, ctx)
+      ];
+    case "RWAMulticall":
+      return buildCollateralPrerequisites(
+        { creditManager: tx.creditManager, creditAccount: tx.creditAccount },
+        tx.multicall,
+        ctx
+      );
+    case "PartiallyLiquidateCreditAccount":
+      return buildPartialLiquidationPrerequisites(tx, ctx);
+    default:
+      return [];
+  }
+}
+export {
+  checkPrerequisites
+};

package/dist/esm/preview/prerequisites/helpers.js

@@ -0,0 +1,23 @@
+import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
+import { BalancePrerequisite } from "./BalancePrerequisite.js";
+function allowanceAndBalance(props) {
+  const { token, owner, spender, required } = props;
+  return [
+    new AllowancePrerequisite({
+      token,
+      owner,
+      spender,
+      required,
+      title: props.allowanceTitle
+    }),
+    new BalancePrerequisite({
+      token,
+      owner,
+      required,
+      title: props.balanceTitle
+    })
+  ];
+}
+export {
+  allowanceAndBalance
+};

package/dist/esm/preview/prerequisites/index.js

@@ -1,8 +1,6 @@
 export * from "./AllowancePrerequisite.js";
 export * from "./BalancePrerequisite.js";
-export * from "./buildPrerequisites.js";
+export * from "./checkPrerequisites.js";
 export * from "./Prerequisite.js";
-export * from "./prepareAction.js";
 export * from "./RWAOpenRequirementsPrerequisite.js";
-export * from "./runPrerequisites.js";
 export * from "./types.js";

package/dist/esm/preview/preview/detectCloseOrRepay.js

@@ -0,0 +1,26 @@
+import { isAddressEqual } from "viem";
+import { MAX_UINT256 } from "../../sdk/index.js";
+function isCloseOrRepay(multicall) {
+  const repaysFullDebt = multicall.some(
+    (op) => op.operation === "DecreaseBorrowedAmount" && op.amount === MAX_UINT256
+  );
+  const withdrawsEverything = multicall.some(
+    (op) => op.operation === "WithdrawCollateral" && op.amount === MAX_UINT256
+  );
+  return repaysFullDebt && withdrawsEverything;
+}
+function classifyCloseOrRepay(multicall, underlying) {
+  for (const op of multicall) {
+    if (op.operation === "AddCollateral") {
+      return "repay";
+    }
+    if (op.operation === "WithdrawCollateral" && !isAddressEqual(op.token, underlying)) {
+      return "repay";
+    }
+  }
+  return "close";
+}
+export {
+  classifyCloseOrRepay,
+  isCloseOrRepay
+};

package/dist/esm/preview/preview/index.js

@@ -1,5 +1,7 @@
 export * from "./applyInnerOperations.js";
+export * from "./detectCloseOrRepay.js";
 export * from "./errors.js";
 export * from "./previewAdjustCreditAccount.js";
+export * from "./previewCloseOrRepay.js";
 export * from "./previewOperation.js";
 export * from "./types.js";

package/dist/esm/preview/preview/previewCloseOrRepay.js

@@ -0,0 +1,76 @@
+import {
+  AP_WETH_TOKEN,
+  NO_VERSION
+} from "../../sdk/index.js";
+import {
+  applyInnerOperations,
+  makeInnerOperationsState
+} from "./applyInnerOperations.js";
+import { classifyCloseOrRepay } from "./detectCloseOrRepay.js";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
+async function previewCloseOrRepay(input, operation, permanent, options) {
+  const { sdk } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const kind = classifyCloseOrRepay(operation.multicall, market.underlying);
+  return kind === "close" ? previewCloseCreditAccount(input, operation, permanent, options) : previewRepayCreditAccount(input, operation, permanent, options);
+}
+async function previewCloseCreditAccount(input, operation, permanent, options) {
+  const { sdk } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const { state } = await replayMulticall(sdk, operation, options);
+  return {
+    operation: "CloseCreditAccount",
+    permanent,
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    receivedAmount: state.collateralWithdrawn.getOrZero(market.underlying)
+  };
+}
+async function previewRepayCreditAccount(input, operation, permanent, options) {
+  const { sdk, value = 0n } = input;
+  const { ca, state } = await replayMulticall(sdk, operation, options);
+  const collateralAdded = unwrapNativeCollateral(
+    state.collateralAdded.toAssets(),
+    value,
+    sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
+  );
+  const initialTotalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
+  return {
+    operation: "RepayCreditAccount",
+    permanent,
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    collateralAdded,
+    debtRepaid: initialTotalDebt - state.totalDebt,
+    collateralWithdrawn: state.collateralWithdrawn.toAssets()
+  };
+}
+async function replayMulticall(sdk, operation, options) {
+  let ca = options?.creditAccount;
+  if (!ca) {
+    ca = await sdk.accounts.getCreditAccountData(
+      operation.creditAccount,
+      options?.blockNumber
+    );
+  }
+  if (!ca) {
+    throw new Error(`credit account ${operation.creditAccount} not found`);
+  }
+  const state = makeInnerOperationsState();
+  for (const t of ca.tokens) {
+    if (t.balance > 1n) {
+      state.balances.upsert(t.token, t.balance);
+    }
+  }
+  state.debt = ca.debt;
+  state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
+  applyInnerOperations(sdk, operation.multicall, state);
+  return { ca, state };
+}
+export {
+  previewCloseOrRepay
+};

package/dist/esm/preview/preview/previewOperation.js

@@ -1,6 +1,8 @@
 import { isPoolOperation, parseOperationCalldata } from "../parse/index.js";
+import { isCloseOrRepay } from "./detectCloseOrRepay.js";
 import { UnsupportedOperationError } from "./errors.js";
 import { previewAdjustCreditAccount } from "./previewAdjustCreditAccount.js";
+import { previewCloseOrRepay } from "./previewCloseOrRepay.js";
 import { previewOpenCreditAccount } from "./previewOpenCreditAccount.js";
 import { previewPoolOperation } from "./previewPoolOperation.js";
 async function previewOperation(input, options) {
@@ -8,10 +10,16 @@ async function previewOperation(input, options) {
   if (isPoolOperation(operation)) {
     return previewPoolOperation(input, operation, options);
   }
-  if (operation.operation === "OpenCreditAccount" || operation.operation === "SecuritizeOpenCreditAccount") {
+  if (operation.operation === "OpenCreditAccount" || operation.operation === "RWAOpenCreditAccount") {
     return previewOpenCreditAccount(input, operation);
   }
-  if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "SecuritizeMulticall") {
+  if (operation.operation === "CloseCreditAccount") {
+    return previewCloseOrRepay(input, operation, true, options);
+  }
+  if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "RWAMulticall") {
+    if (isCloseOrRepay(operation.multicall)) {
+      return previewCloseOrRepay(input, operation, false, options);
+    }
     return previewAdjustCreditAccount(input, operation, options);
   }
   throw new UnsupportedOperationError(operation.operation);

package/dist/esm/sdk/market/rwa/securitize/SecuritizeRWAFactory.js

@@ -170,8 +170,8 @@ class SecuritizeRWAFactory extends BaseContract {
   /**
    * {@inheritDoc IRWAFactory.multicall}
    */
-  multicall(creditAccount, calls, options) {
-    const { tokensToRegister = [], signaturesToCache = [] } = options ?? {};
+  multicall(creditAccount, calls, args) {
+    const { tokensToRegister = [], signaturesToCache = [] } = args ?? {};
     return this.createRawTx({
       functionName: "multicall",
       args: [creditAccount, calls, tokensToRegister, signaturesToCache]
@@ -201,11 +201,33 @@ class SecuritizeRWAFactory extends BaseContract {
       requiredSignatures
     };
   }
+  /**
+   * {@inheritDoc IRWAFactory.getMissingRequirements}
+   *
+   * A required signature is omitted when `providedArgs.signaturesToCache`
+   * already carries a signature for the same token: the transaction caches it
+   * on-chain as part of the operation.
+   */
+  getMissingRequirements(requirements, providedArgs) {
+    const providedTokens = new AddressSet(
+      (providedArgs?.signaturesToCache ?? []).map((s) => s.token)
+    );
+    const requiredSignatures = requirements.requiredSignatures.filter(
+      (message) => !providedTokens.has(message.message.token)
+    );
+    if (requiredSignatures.length === 0) {
+      return void 0;
+    }
+    return {
+      type: RWA_FACTORY_SECURITIZE,
+      requiredSignatures
+    };
+  }
   /**
    * {@inheritDoc IRWAFactory.openCreditAccount}
    */
-  openCreditAccount(creditManager, calls, options) {
-    const { tokensToRegister = [], signaturesToCache = [] } = options ?? {};
+  openCreditAccount(creditManager, calls, args) {
+    const { tokensToRegister = [], signaturesToCache = [] } = args ?? {};
     return this.createRawTx({
       functionName: "openCreditAccount",
       args: [creditManager, calls, tokensToRegister, signaturesToCache]

package/dist/esm/sdk/utils/AddressSet.js

@@ -15,6 +15,13 @@ class AddressSet extends Set {
   has(value) {
     return super.has(getAddress(value));
   }
+  difference(other) {
+    const result = new AddressSet(this.keys());
+    for (const key of other) {
+      result.delete(getAddress(key));
+    }
+    return result;
+  }
   /**
    * Returns all addresses as an array.
    **/

package/dist/types/abi/IWithdrawalCompressorV312.d.ts

@@ -0,0 +1,216 @@
+export declare const iWithdrawalCompressorV312Abi: readonly [{
+    readonly type: "function";
+    readonly name: "contractType";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getCurrentWithdrawals";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple[]";
+        readonly internalType: "struct ClaimableWithdrawal[]";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "withdrawalPhantomToken";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "withdrawalTokenSpent";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "outputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct WithdrawalOutput[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "isDelayed";
+                readonly type: "bool";
+                readonly internalType: "bool";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "claimCalls";
+            readonly type: "tuple[]";
+            readonly internalType: "struct MultiCall[]";
+            readonly components: readonly [{
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "callData";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }, {
+            readonly name: "extraData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }, {
+        readonly name: "";
+        readonly type: "tuple[]";
+        readonly internalType: "struct PendingWithdrawal[]";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "withdrawalPhantomToken";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "expectedOutputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct WithdrawalOutput[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "isDelayed";
+                readonly type: "bool";
+                readonly internalType: "bool";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "claimableAt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getWithdrawableAssets";
+    readonly inputs: readonly [{
+        readonly name: "creditManager";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple[]";
+        readonly internalType: "struct WithdrawableAsset[]";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "withdrawalPhantomToken";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "underlying";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "withdrawalLength";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "maxWithdrawals";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getWithdrawalRequestResult";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct RequestableWithdrawal";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "amountIn";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "outputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct WithdrawalOutput[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "isDelayed";
+                readonly type: "bool";
+                readonly internalType: "bool";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "requestCalls";
+            readonly type: "tuple[]";
+            readonly internalType: "struct MultiCall[]";
+            readonly components: readonly [{
+                readonly name: "target";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "callData";
+                readonly type: "bytes";
+                readonly internalType: "bytes";
+            }];
+        }, {
+            readonly name: "claimableAt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "version";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}];

package/dist/types/preview/parse/parseRWAFactoryOperationCalldata.d.ts

@@ -17,6 +17,6 @@ export interface ParseRWAFactoryOperationCalldataProps {
  * identical to {@link parseFacadeOperationCalldata}.
  *
  * Dispatches on the factory's contract type; supporting a new factory type
- * requires a new branch here plus new operation types in `types-rwa.ts`.
+ * requires a new branch here.
  */
 export declare function parseRWAFactoryOperationCalldata(props: ParseRWAFactoryOperationCalldataProps): RWAOperation;

package/dist/types/preview/parse/types-rwa.d.ts

@@ -1,5 +1,5 @@
 import type { Address } from "viem";
-import type { SecuritizeRegisterMessage } from "../../sdk/index.js";
+import type { RWAOperationArgs } from "../../sdk/index.js";
 import type { InnerOperation } from "./types-facades.js";
 /**
  * Metadata shared by all RWA factory operations. RWA credit accounts are
@@ -13,36 +13,24 @@ export interface RWAOperationMetadata {
     creditManager: Address;
     creditFacade: Address;
 }
-export interface SecuritizeOpenCreditAccountOperation<Ext extends object = {}> extends RWAOperationMetadata {
-    operation: "SecuritizeOpenCreditAccount";
+export interface RWAOpenCreditAccountOperation<Ext extends object = {}> extends RWAOperationMetadata {
+    operation: "RWAOpenCreditAccount";
     multicall: InnerOperation<Ext>[];
     /**
-     * DSToken addresses to register, decoded from calldata. Empty in the
-     * template flow, where the real value comes from the factory's open-account
-     * requirements.
+     * Factory-specific registration args decoded from calldata (for
+     * Securitize: `tokensToRegister`/`signaturesToCache`).
      */
-    tokensToRegister: Address[];
-    /**
-     * EIP-712 registration signatures to store on-chain, decoded from calldata.
-     * Empty in the template flow.
-     */
-    signaturesToCache: SecuritizeRegisterMessage[];
+    args: RWAOperationArgs;
 }
-/**
- * `SecuritizeRWAFactory.multicall` call: like the facade's `multicall`, plus
- * the factory-specific registration args.
- */
-export interface SecuritizeMulticallOperation<Ext extends object = {}> extends RWAOperationMetadata {
-    operation: "SecuritizeMulticall";
+export interface RWAMulticallOperation<Ext extends object = {}> extends RWAOperationMetadata {
+    operation: "RWAMulticall";
     creditAccount: Address;
     multicall: InnerOperation<Ext>[];
-    /** DSToken addresses to register, decoded from calldata. */
-    tokensToRegister: Address[];
-    /** EIP-712 registration signatures to store on-chain, decoded from calldata. */
-    signaturesToCache: SecuritizeRegisterMessage[];
+    /** Factory-specific registration args decoded from calldata. */
+    args: RWAOperationArgs;
 }
 /**
  * Discriminated union of all RWA factory operation types. Extend it when
  * adding support for a new RWA factory type.
  */
-export type RWAOperation<Ext extends object = {}> = SecuritizeOpenCreditAccountOperation<Ext> | SecuritizeMulticallOperation<Ext>;
+export type RWAOperation<Ext extends object = {}> = RWAOpenCreditAccountOperation<Ext> | RWAMulticallOperation<Ext>;

package/dist/types/preview/prerequisites/AllowancePrerequisite.d.ts

@@ -1,6 +1,6 @@
-import { type Address, type ContractFunctionParameters } from "viem";
-import { type MulticallCallResult, Prerequisite } from "./Prerequisite.js";
-import type { PrerequisiteDetail, PrerequisiteResult } from "./types.js";
+import { type Address } from "viem";
+import { Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteResult } from "./types.js";
 export interface AllowancePrerequisiteProps {
     token: Address;
     owner: Address;
@@ -17,6 +17,5 @@ export declare class AllowancePrerequisite extends Prerequisite<"allowance"> {
     get kind(): "allowance";
     get title(): string;
     get detail(): PrerequisiteDetail<"allowance">;
-    calls(): ContractFunctionParameters[];
-    resolve(slice: MulticallCallResult[]): PrerequisiteResult<"allowance">;
+    protected check(ctx: PrerequisiteContext): Promise<PrerequisiteResult<"allowance">>;
 }

package/dist/types/preview/prerequisites/BalancePrerequisite.d.ts

@@ -1,5 +1,5 @@
-import { type Address, type ContractFunctionParameters } from "viem";
-import { type MulticallCallResult, Prerequisite } from "./Prerequisite.js";
+import { type Address } from "viem";
+import { Prerequisite } from "./Prerequisite.js";
 import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteResult } from "./types.js";
 export interface BalancePrerequisiteProps {
     token: Address;
@@ -11,8 +11,7 @@ export interface BalancePrerequisiteProps {
 /**
  * Checks that `owner` holds a token balance >= `required`. The token is read
  * as an ERC-20, except for the native pseudo-address ({@link NATIVE_ADDRESS},
- * e.g. ETH-zapper deposits) whose balance is read via multicall3's
- * `getEthBalance`.
+ * e.g. ETH-zapper deposits) whose balance is read via `getBalance`.
  */
 export declare class BalancePrerequisite extends Prerequisite<"balance"> {
     #private;
@@ -21,6 +20,5 @@ export declare class BalancePrerequisite extends Prerequisite<"balance"> {
     get kind(): "balance";
     get title(): string;
     get detail(): PrerequisiteDetail<"balance">;
-    calls(ctx: PrerequisiteContext): ContractFunctionParameters[];
-    resolve(slice: MulticallCallResult[]): PrerequisiteResult<"balance">;
+    protected check(ctx: PrerequisiteContext): Promise<PrerequisiteResult<"balance">>;
 }