@gearbox-protocol/sdk 14.12.0-next.9 → 14.12.0-test.2

package/dist/esm/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV313Contract.js

@@ -0,0 +1,204 @@
+import { iWithdrawalCompressorV313Abi } from "../../../abi/IWithdrawalCompressorV313.js";
+import {
+  AbstractWithdrawalCompressorContract,
+  iCreditAccountAbi,
+  toClaimableWithdrawal,
+  toPendingWithdrawal,
+  toRequestableWithdrawal
+} from "./AbstractWithdrawalCompressorContract.js";
+import { encodeDelayedIntent } from "./intent-codec.js";
+import { toWithdrawalStatus } from "./types.js";
+const abi = iWithdrawalCompressorV313Abi;
+const iExternalWithdrawalsBatchAbi = [
+  {
+    type: "function",
+    name: "getExternalAccountCurrentWithdrawals",
+    inputs: [
+      {
+        name: "withdrawalTokens",
+        type: "address[]",
+        internalType: "address[]"
+      },
+      { name: "account", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct ClaimableWithdrawal[]",
+        components: [
+          { name: "token", type: "address", internalType: "address" },
+          {
+            name: "withdrawalPhantomToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "withdrawalTokenSpent",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "outputs",
+            type: "tuple[]",
+            internalType: "struct WithdrawalOutput[]",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "isDelayed", type: "bool", internalType: "bool" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          {
+            name: "claimCalls",
+            type: "tuple[]",
+            internalType: "struct MultiCall[]",
+            components: [
+              { name: "target", type: "address", internalType: "address" },
+              { name: "callData", type: "bytes", internalType: "bytes" }
+            ]
+          },
+          { name: "extraData", type: "bytes", internalType: "bytes" }
+        ]
+      },
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct PendingWithdrawal[]",
+        components: [
+          { name: "token", type: "address", internalType: "address" },
+          {
+            name: "withdrawalPhantomToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "expectedOutputs",
+            type: "tuple[]",
+            internalType: "struct WithdrawalOutput[]",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "isDelayed", type: "bool", internalType: "bool" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          { name: "claimableAt", type: "uint256", internalType: "uint256" },
+          { name: "extraData", type: "bytes", internalType: "bytes" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+const iWithdrawalStatusBatchAbi = [
+  {
+    type: "function",
+    name: "getWithdrawalStatus",
+    inputs: [
+      { name: "redeemers", type: "address[]", internalType: "address[]" }
+    ],
+    outputs: [
+      { name: "", type: "uint8[]", internalType: "enum WithdrawalStatus[]" }
+    ],
+    stateMutability: "view"
+  }
+];
+class WithdrawalCompressorV313Contract extends AbstractWithdrawalCompressorContract {
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "WithdrawalCompressorV313",
+      abi,
+      version: 313
+    });
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getExternalAccountCurrentWithdrawals}
+   **/
+  async getExternalAccountCurrentWithdrawals(account, ...withdrawalTokens) {
+    if (withdrawalTokens.length === 0) {
+      return { claimable: [], pending: [] };
+    }
+    const [claimable, pending] = await this.client.readContract({
+      address: this.address,
+      abi: iExternalWithdrawalsBatchAbi,
+      functionName: "getExternalAccountCurrentWithdrawals",
+      args: [withdrawalTokens, account]
+    });
+    return {
+      claimable: claimable.map((w) => toClaimableWithdrawal(w, void 0)),
+      pending: pending.map((w) => toPendingWithdrawal(w, void 0)).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
+    };
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalStatus}
+   **/
+  async getWithdrawalStatus(...redeemers) {
+    if (redeemers.length === 0) {
+      return [];
+    }
+    const resp = await this.client.readContract({
+      address: this.address,
+      abi: iWithdrawalStatusBatchAbi,
+      functionName: "getWithdrawalStatus",
+      args: [redeemers]
+    });
+    return resp.map((s) => toWithdrawalStatus(s));
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalRequestResult}
+   *
+   * When an intent is provided, it is abi-encoded and attached to the request
+   * as `extraData`. The contract overload accepting `extraData` also requires
+   * the withdrawal phantom token; when not provided by the caller, it is
+   * resolved the same way the 3-arg overload does it internally: via the
+   * withdrawable assets of the account's credit manager.
+   **/
+  async getWithdrawalRequestResult({
+    creditAccount,
+    token,
+    amount,
+    withdrawalPhantomToken,
+    intent
+  }) {
+    let resp;
+    if (intent) {
+      const extraData = encodeDelayedIntent(intent);
+      let phantomToken = withdrawalPhantomToken;
+      if (!phantomToken) {
+        const creditManager = await this.client.readContract({
+          address: creditAccount,
+          abi: iCreditAccountAbi,
+          functionName: "creditManager"
+        });
+        phantomToken = await this.getWithdrawalPhantomToken(
+          creditManager,
+          token
+        );
+      }
+      resp = await this.contract.read.getWithdrawalRequestResult([
+        creditAccount,
+        token,
+        phantomToken,
+        amount,
+        extraData
+      ]);
+    } else if (withdrawalPhantomToken) {
+      resp = await this.contract.read.getWithdrawalRequestResult([
+        creditAccount,
+        token,
+        withdrawalPhantomToken,
+        amount
+      ]);
+    } else {
+      resp = await this.contract.read.getWithdrawalRequestResult([
+        creditAccount,
+        token,
+        amount
+      ]);
+    }
+    return toRequestableWithdrawal(resp);
+  }
+}
+export {
+  WithdrawalCompressorV313Contract
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/addresses.js

@@ -0,0 +1,16 @@
+const WITHDRAWAL_COMPRESSORS = {
+  Mainnet: {
+    address: "0x5c80d7e7b18eCb00Cc9FAd57c59eEC4eF7516597",
+    version: 313
+  },
+  Monad: {
+    address: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
+    version: 310
+  }
+};
+function getWithdrawalCompressorAddress(network) {
+  return WITHDRAWAL_COMPRESSORS[network];
+}
+export {
+  getWithdrawalCompressorAddress
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/createRedemptionLogger.js

@@ -0,0 +1,23 @@
+import {
+  AP_REDEMPTION_LOGGER,
+  isV310,
+  VERSION_RANGE_310
+} from "../../constants/index.js";
+import { RedemptionLoggerV310Contract } from "./RedemptionLoggerV310Contract.js";
+function createRedemptionLogger(sdk) {
+  const latest = sdk.addressProvider.getLatest(
+    AP_REDEMPTION_LOGGER,
+    VERSION_RANGE_310
+  );
+  if (!latest) {
+    return void 0;
+  }
+  const [address, version] = latest;
+  if (isV310(version)) {
+    return new RedemptionLoggerV310Contract(sdk, address, version);
+  }
+  throw new Error(`Unsupported redemption logger version: ${version}`);
+}
+export {
+  createRedemptionLogger
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/createWithdrawalCompressor.js

@@ -0,0 +1,21 @@
+import { getWithdrawalCompressorAddress } from "./addresses.js";
+import { WithdrawalCompressorV310Contract } from "./WithdrawalCompressorV310Contract.js";
+import { WithdrawalCompressorV311Contract } from "./WithdrawalCompressorV311Contract.js";
+import { WithdrawalCompressorV313Contract } from "./WithdrawalCompressorV313Contract.js";
+function createWithdrawalCompressor(sdk) {
+  const location = getWithdrawalCompressorAddress(sdk.networkType);
+  if (!location) {
+    return void 0;
+  }
+  switch (location.version) {
+    case 310:
+      return new WithdrawalCompressorV310Contract(sdk, location.address);
+    case 311:
+      return new WithdrawalCompressorV311Contract(sdk, location.address);
+    case 313:
+      return new WithdrawalCompressorV313Contract(sdk, location.address);
+  }
+}
+export {
+  createWithdrawalCompressor
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/errors.js

@@ -0,0 +1,14 @@
+class InvalidDelayedIntentError extends Error {
+  /** Raw `extraData` that failed to decode. */
+  extraData;
+  constructor(extraData, cause) {
+    super(`cannot decode delayed intent from extraData ${extraData}`, {
+      cause
+    });
+    this.name = "InvalidDelayedIntentError";
+    this.extraData = extraData;
+  }
+}
+export {
+  InvalidDelayedIntentError
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/index.js

@@ -0,0 +1,11 @@
+export * from "./AbstractWithdrawalCompressorContract.js";
+export * from "./addresses.js";
+export * from "./createRedemptionLogger.js";
+export * from "./createWithdrawalCompressor.js";
+export * from "./errors.js";
+export * from "./intent-codec.js";
+export * from "./RedemptionLoggerV310Contract.js";
+export * from "./types.js";
+export * from "./WithdrawalCompressorV310Contract.js";
+export * from "./WithdrawalCompressorV311Contract.js";
+export * from "./WithdrawalCompressorV313Contract.js";

package/dist/esm/sdk/accounts/withdrawal-compressor/intent-codec.js

@@ -0,0 +1,92 @@
+import { decodeAbiParameters, encodeAbiParameters } from "viem";
+const DELAYED_INTENT_VERSION = 3;
+const DELAYED_INTENT_TYPES = {
+  INCREASE_LEVERAGE: 1,
+  DEPOSIT: 2,
+  DEPOSIT_AND_INCREASE_LEVERAGE: 3,
+  WITHDRAW_COLLATERAL: 4,
+  CLOSE_ACCOUNT: 5,
+  ADD_COLLATERAL: 6,
+  DECREASE_LEVERAGE: 7
+};
+const HEADER_PARAMS = [
+  { type: "uint8", name: "version" },
+  { type: "uint8", name: "intentType" }
+];
+const TO_PARAMS = [...HEADER_PARAMS, { type: "address", name: "to" }];
+const WITHDRAW_COLLATERAL_PARAMS = [
+  ...TO_PARAMS,
+  { type: "address", name: "withdrawToken" },
+  { type: "uint256", name: "withdrawAmount" },
+  { type: "address", name: "sourceToken" },
+  { type: "uint256", name: "debtRepaid" }
+];
+function encodeDelayedIntent(intent) {
+  const version = DELAYED_INTENT_VERSION;
+  const intentType = DELAYED_INTENT_TYPES[intent.type];
+  switch (intent.type) {
+    case "CLOSE_ACCOUNT":
+      return encodeAbiParameters(TO_PARAMS, [version, intentType, intent.to]);
+    case "WITHDRAW_COLLATERAL":
+      return encodeAbiParameters(WITHDRAW_COLLATERAL_PARAMS, [
+        version,
+        intentType,
+        intent.to,
+        intent.withdrawToken,
+        intent.withdrawAmount,
+        intent.sourceToken,
+        intent.debtRepaid
+      ]);
+    case "INCREASE_LEVERAGE":
+    case "DEPOSIT":
+    case "DEPOSIT_AND_INCREASE_LEVERAGE":
+    case "ADD_COLLATERAL":
+    case "DECREASE_LEVERAGE":
+      return encodeAbiParameters(HEADER_PARAMS, [version, intentType]);
+    default: {
+      const t = intent;
+      throw new Error(`unknown delayed intent: ${JSON.stringify(t)}`);
+    }
+  }
+}
+function decodeDelayedIntent(data) {
+  const [version, intentType] = decodeAbiParameters(HEADER_PARAMS, data);
+  if (version !== DELAYED_INTENT_VERSION) {
+    throw new Error(`unsupported delayed intent version: ${version}`);
+  }
+  switch (intentType) {
+    case DELAYED_INTENT_TYPES.INCREASE_LEVERAGE:
+      return { type: "INCREASE_LEVERAGE" };
+    case DELAYED_INTENT_TYPES.DEPOSIT:
+      return { type: "DEPOSIT" };
+    case DELAYED_INTENT_TYPES.DEPOSIT_AND_INCREASE_LEVERAGE:
+      return { type: "DEPOSIT_AND_INCREASE_LEVERAGE" };
+    case DELAYED_INTENT_TYPES.WITHDRAW_COLLATERAL: {
+      const [, , to, withdrawToken, withdrawAmount, sourceToken, debtRepaid] = decodeAbiParameters(WITHDRAW_COLLATERAL_PARAMS, data);
+      return {
+        type: "WITHDRAW_COLLATERAL",
+        to,
+        withdrawToken,
+        withdrawAmount,
+        sourceToken,
+        debtRepaid
+      };
+    }
+    case DELAYED_INTENT_TYPES.CLOSE_ACCOUNT: {
+      const [, , to] = decodeAbiParameters(TO_PARAMS, data);
+      return { type: "CLOSE_ACCOUNT", to };
+    }
+    case DELAYED_INTENT_TYPES.ADD_COLLATERAL:
+      return { type: "ADD_COLLATERAL" };
+    case DELAYED_INTENT_TYPES.DECREASE_LEVERAGE:
+      return { type: "DECREASE_LEVERAGE" };
+    default:
+      throw new Error(`unknown delayed intent type: ${intentType}`);
+  }
+}
+export {
+  DELAYED_INTENT_TYPES,
+  DELAYED_INTENT_VERSION,
+  decodeDelayedIntent,
+  encodeDelayedIntent
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/types.js

@@ -0,0 +1,12 @@
+const WITHDRAWAL_STATUSES = [
+  "NULL",
+  "PENDING",
+  "CLAIMABLE",
+  "CLAIMED"
+];
+function toWithdrawalStatus(status) {
+  return WITHDRAWAL_STATUSES[status] ?? "NULL";
+}
+export {
+  toWithdrawalStatus
+};

package/dist/esm/sdk/constants/address-provider.js

@@ -32,6 +32,7 @@ const AP_WETH_TOKEN = "WETH_TOKEN";
 const AP_ZAPPER_REGISTER = "ZAPPER_REGISTER";
 const AP_ZERO_PRICE_FEED = "ZERO_PRICE_FEED";
 const AP_RWA_COMPRESSOR = "GLOBAL::RWA_COMPRESSOR";
+const AP_REDEMPTION_LOGGER = "LOCAL::REDEMPTION_LOGGER";
 const ADDRESS_PROVIDER_V310 = "0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38";
 export {
   ADDRESS_PROVIDER_V310,
@@ -59,6 +60,7 @@ export {
   AP_PRICE_FEED_COMPRESSOR,
   AP_PRICE_FEED_STORE,
   AP_PRICE_ORACLE,
+  AP_REDEMPTION_LOGGER,
   AP_REWARDS_COMPRESSOR,
   AP_ROUTER,
   AP_RWA_COMPRESSOR,

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/esm/sdk/utils/AssetsMap.js

@@ -10,11 +10,17 @@ class AssetsMap extends AddressMap {
       name
     );
   }
+  /**
+   * Looks up a token balance, treating a missing key as `0n`.
+   */
+  getOrZero(address) {
+    return this.get(address) ?? 0n;
+  }
   /**
    * Adds `amount` to the token balance, treating a missing key as `0n`.
    */
   inc(address, amount) {
-    this.upsert(address, (this.get(address) ?? 0n) + amount);
+    this.upsert(address, this.getOrZero(address) + amount);
   }
   /**
    * Subtracts `amount` from the token balance, treating a missing key as `0n`.
@@ -22,11 +28,41 @@ class AssetsMap extends AddressMap {
   dec(address, amount) {
     this.inc(address, -amount);
   }
+  /**
+   * Per-token difference `this - before`, non-zero entries only.
+   *
+   * Assumes this map's keys are a superset of `before`'s keys; tokens present
+   * only in `before` are not reported.
+   */
+  difference(before) {
+    const result = new AssetsMap();
+    for (const [token, balance] of this.entries()) {
+      const change = balance - before.getOrZero(token);
+      if (change !== 0n) {
+        result.upsert(token, change);
+      }
+    }
+    return result;
+  }
+  /**
+   * Sums `fn` over all entries.
+   */
+  sum(fn) {
+    return this.entries().reduce(
+      (acc, [token, balance]) => acc + fn(token, balance),
+      0n
+    );
+  }
   /**
    * Converts the map to an array of {@link Asset} objects.
+   * @param minBalance - If provided, keeps only entries with a balance
+   * strictly greater than this threshold (e.g. `1n` to filter out dust).
    */
-  toAssets() {
-    return this.entries().map(([token, balance]) => ({ token, balance }));
+  toAssets(minBalance) {
+    const abs = (balance) => balance > 0n ? balance : -balance;
+    return this.entries().filter(
+      ([, balance]) => minBalance === void 0 || abs(balance) > minBalance
+    ).map(([token, balance]) => ({ token, balance }));
   }
   clone() {
     return new AssetsMap(this.entries(), this.name);