@gearbox-protocol/sdk 15.0.0-next.2 → 15.0.0-pyth.1

package/dist/esm/dev/abi.js

@@ -9,8 +9,213 @@ const iDegenNftv2Abi = parseAbi([
   "function minter() external view returns (address)",
   "function mint(address to, uint256 amount) external"
 ]);
+const faucetAbi = [
+  {
+    type: "function",
+    name: "assets",
+    inputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "claim",
+    inputs: [
+      {
+        name: "amountUSD",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "claim",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "claim",
+    inputs: [
+      {
+        name: "claims",
+        type: "tuple[]",
+        internalType: "struct TokenClaim[]",
+        components: [
+          {
+            name: "token",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "amount",
+            type: "uint256",
+            internalType: "uint256"
+          }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getAssets",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address[]",
+        internalType: "address[]"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "hasClaimed",
+    inputs: [
+      {
+        name: "user",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "bool",
+        internalType: "bool"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "minAmountUSD",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "owner",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "prices",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "scales",
+    inputs: [
+      {
+        name: "",
+        type: "address",
+        internalType: "address"
+      }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "uint256",
+        internalType: "uint256"
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+const iOnchainExecutionIdAbi = [
+  {
+    type: "function",
+    name: "deployer",
+    inputs: [],
+    outputs: [{ name: "", type: "string", internalType: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "executionId",
+    inputs: [],
+    outputs: [{ name: "", type: "string", internalType: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "forkAlias",
+    inputs: [],
+    outputs: [{ name: "", type: "string", internalType: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "info",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        internalType: "struct ExecutionId.Info",
+        components: [
+          { name: "deployer", type: "string", internalType: "string" },
+          { name: "executionId", type: "string", internalType: "string" },
+          { name: "forkAlias", type: "string", internalType: "string" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
 export {
+  faucetAbi,
   iDegenNftv2Abi,
+  iOnchainExecutionIdAbi,
   iOwnableAbi,
   iaclTraitAbi
 };

package/dist/esm/dev/claimDSToken.js

@@ -0,0 +1,187 @@
+import {
+  erc20Abi
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { iDSRegistryServiceAbi } from "../abi/rwa/iDSRegistryService.js";
+import { iDSTokenAbi } from "../abi/rwa/iDSToken.js";
+import {
+  MAX_UINT256,
+  OnchainSDK
+} from "../sdk/index.js";
+async function writeAndWait(anvil, params) {
+  const hash = await anvil.writeContract(params);
+  await anvil.mine({ blocks: 1 });
+  await anvil.waitForTransactionReceipt({
+    hash,
+    pollingInterval: 100
+  });
+  return hash;
+}
+async function registerInvestor(props) {
+  const { claimer, anvil, token, adminPrivateKey, logger } = props;
+  const account = privateKeyToAccount(adminPrivateKey);
+  const registryServiceId = await anvil.readContract({
+    address: token,
+    abi: iDSTokenAbi,
+    functionName: "REGISTRY_SERVICE"
+  });
+  const registryService = await anvil.readContract({
+    address: token,
+    abi: iDSTokenAbi,
+    functionName: "getDSService",
+    args: [registryServiceId]
+  });
+  logger?.debug(`Registry service: ${registryService} (${registryServiceId})`);
+  const [isRegistered, ACCREDITED, APPROVED] = await anvil.multicall({
+    contracts: [
+      {
+        address: registryService,
+        abi: iDSRegistryServiceAbi,
+        functionName: "isWallet",
+        args: [claimer]
+      },
+      {
+        address: registryService,
+        abi: iDSRegistryServiceAbi,
+        functionName: "ACCREDITED",
+        args: []
+      },
+      {
+        address: registryService,
+        abi: iDSRegistryServiceAbi,
+        functionName: "APPROVED",
+        args: []
+      }
+    ],
+    allowFailure: false
+  });
+  if (!isRegistered) {
+    logger?.debug(
+      `Claimer ${claimer} is not a registered wallet, registering...`
+    );
+    const investorId = `investor-${claimer.toLowerCase()}`;
+    const investorExists = await anvil.readContract({
+      address: registryService,
+      abi: iDSRegistryServiceAbi,
+      functionName: "isInvestor",
+      args: [investorId]
+    });
+    if (!investorExists) {
+      await writeAndWait(anvil, {
+        account,
+        chain: anvil.chain,
+        address: registryService,
+        abi: iDSRegistryServiceAbi,
+        functionName: "registerInvestor",
+        args: [investorId, investorId]
+      });
+      logger?.debug(`Registered investor "${investorId}"`);
+    }
+    await writeAndWait(anvil, {
+      account,
+      chain: anvil.chain,
+      address: registryService,
+      abi: iDSRegistryServiceAbi,
+      functionName: "addWallet",
+      args: [claimer, investorId]
+    });
+    logger?.debug(`Added wallet ${claimer} for investor "${investorId}"`);
+    try {
+      await writeAndWait(anvil, {
+        account,
+        chain: anvil.chain,
+        address: registryService,
+        abi: iDSRegistryServiceAbi,
+        functionName: "setCountry",
+        args: [investorId, "US"]
+      });
+      logger?.debug(`Set country for investor "${investorId}" to "US"`);
+      await writeAndWait(anvil, {
+        account,
+        chain: anvil.chain,
+        address: registryService,
+        abi: iDSRegistryServiceAbi,
+        functionName: "setAttribute",
+        args: [
+          investorId,
+          ACCREDITED,
+          BigInt(APPROVED),
+          MAX_UINT256,
+          "fake proof"
+        ]
+      });
+      logger?.debug(`Set attributes for investor "${investorId}"`);
+    } catch (e) {
+      logger?.error(e);
+    }
+  } else {
+    logger?.debug(`Claimer ${claimer} is already a registered wallet`);
+  }
+}
+async function claimDSToken(props) {
+  const {
+    anvil,
+    claimer,
+    adminPrivateKey,
+    token,
+    marketConfigurators,
+    rwaFactories,
+    usdAmount: usdAmountProp = "100000"
+  } = props;
+  const account = privateKeyToAccount(adminPrivateKey);
+  const symbol = await anvil.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: "symbol",
+    args: []
+  });
+  const logger = props.logger?.child?.({ symbol });
+  const usdAmount = BigInt(usdAmountProp) * 10n ** 8n;
+  const sdk = new OnchainSDK(anvil.chain.network, {
+    client: anvil,
+    timeout: 12e4
+  });
+  await sdk.attach({ marketConfigurators, rwaFactories });
+  let amount = 0n;
+  for (const market of sdk.marketRegister.markets) {
+    try {
+      amount = market.priceOracle.convertFromUSD(token, usdAmount);
+    } catch {
+    }
+  }
+  if (amount === 0n) {
+    throw new Error(`No market found for token ${token}`);
+  }
+  logger?.debug(`${usdAmountProp} USD === ${amount} ${symbol}`);
+  await registerInvestor({ ...props, logger });
+  logger?.debug(`Issuing ${amount} tokens to ${claimer}...`);
+  const mintHash = await writeAndWait(anvil, {
+    account,
+    chain: anvil.chain,
+    address: token,
+    abi: iDSTokenAbi,
+    functionName: "issueTokens",
+    args: [claimer, amount]
+  });
+  logger?.debug(`Done! tx: ${mintHash}`);
+  const balance = await anvil.readContract({
+    address: token,
+    abi: erc20Abi,
+    functionName: "balanceOf",
+    args: [claimer]
+  });
+  logger?.debug(
+    `Balance of ${claimer}: ${sdk.tokensMeta.formatBN(token, balance)}`
+  );
+}
+async function claimDSTokens(props) {
+  const { tokens, ...rest } = props;
+  for (const token of tokens) {
+    await claimDSToken({ ...rest, token });
+  }
+}
+export {
+  claimDSToken,
+  claimDSTokens,
+  registerInvestor
+};

package/dist/esm/dev/claimFromFaucet.js

@@ -1,14 +1,6 @@
-import {
-  parseAbi
-} from "viem";
 import { readContract } from "viem/actions";
 import { formatBN } from "../sdk/index.js";
-const faucetAbi = parseAbi([
-  "function minAmountUSD() external view returns (uint256)",
-  "function claim() external",
-  "function claim(uint256 amountUSD) external",
-  "function claim((address token, uint256 amount)[] claims) external"
-]);
+import { faucetAbi } from "./abi.js";
 async function claimFromFaucet(opts) {
   const {
     sdk,
@@ -19,7 +11,8 @@ async function claimFromFaucet(opts) {
     role,
     amount,
     logger,
-    gasMultiplier = 10n
+    gasMultiplier = 10n,
+    sync = false
   } = opts;
   let amnt = "default amount";
   let args;
@@ -60,7 +53,8 @@ async function claimFromFaucet(opts) {
     functionName: "claim",
     args
   });
-  const hash = await wallet.writeContract({
+  logger?.debug({ gas }, "estimated claim tx gas");
+  const { request } = await publicClient.simulateContract({
     account: claimer,
     address: faucet,
     abi: faucetAbi,
@@ -69,15 +63,23 @@ async function claimFromFaucet(opts) {
     chain: wallet.chain,
     gas: gas * gasMultiplier
   });
-  const receipt = await publicClient.waitForTransactionReceipt({
-    hash
-  });
+  logger?.debug({ request }, "simulated claim tx request");
+  let receipt;
+  if (sync) {
+    receipt = await wallet.writeContractSync(request);
+  } else {
+    const hash = await wallet.writeContract(request);
+    logger?.debug({ hash }, "claim tx hash");
+    receipt = await publicClient.waitForTransactionReceipt({ hash });
+  }
   if (receipt.status === "reverted") {
     throw new Error(
-      `${usr} failed to claimed ${amnt} from faucet, tx: ${hash}`
+      `${usr} failed to claimed ${amnt} from faucet, tx: ${receipt.transactionHash}`
     );
   }
-  logger?.debug(`${usr} claimed ${amnt} from faucet, tx: ${hash}`);
+  logger?.debug(
+    `${usr} claimed ${amnt} from faucet, tx: ${receipt.transactionHash}`
+  );
 }
 export {
   claimFromFaucet

package/dist/esm/dev/createAnvilClient.js

@@ -1,9 +1,30 @@
-import { createPublicClient, testActions, toHex, walletActions } from "viem";
+import {
+  createTestClient,
+  publicActions,
+  testActions,
+  toHex,
+  walletActions
+} from "viem";
+let dealModulePromise;
+async function loadDeal() {
+  dealModulePromise ??= import("viem-deal").catch(() => null);
+  const mod = await dealModulePromise;
+  if (!mod) {
+    throw new Error(
+      "createAnvilClient: deal action requires the 'viem-deal' package; install it as a dependency"
+    );
+  }
+  return mod.deal;
+}
 function extendAnvilClient(client) {
-  return client.extend(testActions({ mode: "anvil" })).extend(walletActions).extend((c) => ({
+  return client.extend(() => ({ mode: "anvil" })).extend(testActions({ mode: "anvil" })).extend(walletActions).extend((c) => ({
     anvilNodeInfo: () => anvilNodeInfo(c),
     isAnvil: () => isAnvil(c),
-    evmMineDetailed: (timestamp) => evmMineDetailed(c, timestamp)
+    evmMineDetailed: (timestamp) => evmMineDetailed(c, timestamp),
+    deal: async (params) => {
+      const deal = await loadDeal();
+      await deal(c, params);
+    }
   }));
 }
 function createAnvilClient({
@@ -12,13 +33,21 @@ function createAnvilClient({
   cacheTime = 0,
   pollingInterval = 50
 }) {
-  const client = createPublicClient({
+  return createTestClient({
+    mode: "anvil",
     chain,
     transport,
     cacheTime,
     pollingInterval
-  });
-  return extendAnvilClient(client);
+  }).extend(publicActions).extend(walletActions).extend((c) => ({
+    anvilNodeInfo: () => anvilNodeInfo(c),
+    isAnvil: () => isAnvil(c),
+    evmMineDetailed: (timestamp) => evmMineDetailed(c, timestamp),
+    deal: async (params) => {
+      const deal = await loadDeal();
+      await deal(c, params);
+    }
+  }));
 }
 async function isAnvil(client) {
   try {

package/dist/esm/dev/index.js

@@ -1,5 +1,7 @@
 export * from "./AccountOpener.js";
+export * from "./abi.js";
 export * from "./calcLiquidatableLTs.js";
+export * from "./claimDSToken.js";
 export * from "./claimFromFaucet.js";
 export * from "./create2.js";
 export * from "./createAnvilClient.js";

package/dist/esm/dev/isOutOfSyncError.js

@@ -15,7 +15,9 @@ const OUT_OF_SYNC_PATTERNS = [
   // Optimism proxyd (code -32019) for future/non-existent blocks
   /block is out of range/i,
   // EIP-1474 standard (code -32001) when block/state is not available
-  /resource not found/i
+  /resource not found/i,
+  // DRPC when a requested block is ahead of the node's latest block
+  /greater than latest block/i
 ];
 function isOutOfSyncError(e) {
   if (e instanceof BaseError) {

package/dist/esm/dev/isTransientError.js

@@ -38,7 +38,9 @@ const TRANSIENT_PATTERNS = [
   // sometimes happens on DRPC: "GRPC Context cancellation"
   /context cancel/i,
   // DRPC error: Can't route your request to suitable provider, if you specified certain providers revise the list
-  /suitable provider/i
+  /suitable provider/i,
+  // DRPC error: Temporary internal error. Please retry, trace-id: xxx
+  /temporary internal error/i
 ];
 function isTransientError(e) {
   if (e instanceof BaseError) {

package/dist/esm/history/assembleOperations.js

@@ -9,16 +9,24 @@ function assembleOperations(input) {
     underlying,
     liquidationRemainingFunds,
     phantomTokens,
+    withdrawCollateralEvents = [],
     strict
   } = input;
-  let offset = 0;
+  let executeOffset = 0;
+  let withdrawOffset = 0;
   return facadeCalls.map((fc) => {
     if (fc.operation === "PartiallyLiquidateCreditAccount") {
       return assemblePartialLiquidation(fc);
     }
     const count = countAdapterCalls(fc.innerCalls, register);
-    const sliced = executeResults.slice(offset, offset + count);
-    offset += count;
+    const sliced = executeResults.slice(executeOffset, executeOffset + count);
+    executeOffset += count;
+    const withdrawCount = countWithdrawCollateralCalls(fc.innerCalls);
+    const slicedWithdrawEvents = withdrawCollateralEvents.slice(
+      withdrawOffset,
+      withdrawOffset + withdrawCount
+    );
+    withdrawOffset += withdrawCount;
     const protocolCalldatas = extractProtocolCalls(fc.trace, sliced);
     const multicall = classifyMulticallOperations({
       innerCalls: fc.innerCalls,
@@ -28,7 +36,8 @@ function assembleOperations(input) {
       creditAccount: fc.creditAccount,
       underlying,
       strict,
-      phantomTokens
+      phantomTokens,
+      withdrawCollateralEvents: slicedWithdrawEvents
     });
     switch (fc.operation) {
       case "OpenCreditAccount":
@@ -63,6 +72,11 @@ function countAdapterCalls(innerCalls, register) {
     return !contract || contract instanceof AbstractAdapterContract;
   }).length;
 }
+function countWithdrawCollateralCalls(innerCalls) {
+  return innerCalls.filter(
+    (call) => call.functionName.startsWith("withdrawCollateral")
+  ).length;
+}
 function assemblePartialLiquidation(fc) {
   const { rawArgs } = fc.parsed;
   return {

package/dist/esm/history/classifyMulticallOperations.js

@@ -4,7 +4,11 @@ import {
   swapFromTransfers,
   toNetTransfers
 } from "../plugins/adapters/index.js";
-import { TransferAlignmentError, UnknownAdapterError } from "./errors.js";
+import {
+  TransferAlignmentError,
+  UnknownAdapterError,
+  WithdrawCollateralAlignmentError
+} from "./errors.js";
 function classifyMulticallOperations(input) {
   const {
     innerCalls,
@@ -14,9 +18,11 @@ function classifyMulticallOperations(input) {
     creditAccount,
     underlying,
     strict,
-    phantomTokens
+    phantomTokens,
+    withdrawCollateralEvents
   } = input;
   let transferIdx = 0;
+  let withdrawIdx = 0;
   const result = [];
   for (const call of innerCalls) {
     const contract = register.getContract(call.target);
@@ -39,7 +45,14 @@ function classifyMulticallOperations(input) {
       continue;
     }
     if (contract !== void 0) {
-      const op = classifyFacadeInnerCall(call, underlying, phantomTokens);
+      const isWithdraw = call.functionName.startsWith("withdrawCollateral");
+      const withdrawEvent = isWithdraw ? withdrawCollateralEvents?.[withdrawIdx++] : void 0;
+      const op = classifyFacadeInnerCall(
+        call,
+        underlying,
+        phantomTokens,
+        withdrawEvent
+      );
       if (op) result.push(op);
       continue;
     }
@@ -74,9 +87,15 @@ function classifyMulticallOperations(input) {
   if (transferIdx !== executeResults.length) {
     throw new TransferAlignmentError(executeResults.length, transferIdx);
   }
+  if (withdrawCollateralEvents && withdrawCollateralEvents.length > 0 && withdrawIdx !== withdrawCollateralEvents.length) {
+    throw new WithdrawCollateralAlignmentError(
+      withdrawCollateralEvents.length,
+      withdrawIdx
+    );
+  }
   return result;
 }
-function classifyFacadeInnerCall(call, underlying, phantomTokens) {
+function classifyFacadeInnerCall(call, underlying, phantomTokens, withdrawEvent) {
   const { functionName: sig, rawArgs } = call;
   const functionName = sig.split("(")[0];
   switch (functionName) {
@@ -105,10 +124,11 @@ function classifyFacadeInnerCall(call, underlying, phantomTokens) {
         calldataToken,
         phantomTokens
       );
+      const amount = withdrawEvent ? withdrawEvent.amount : rawArgs.amount;
       return {
         operation: "WithdrawCollateral",
         token: depositedToken ?? calldataToken,
-        amount: rawArgs.amount,
+        amount,
         to: rawArgs.to,
         ...depositedToken ? { phantomToken: calldataToken } : {}
       };

package/dist/esm/history/errors.js

@@ -14,6 +14,14 @@ class TransferAlignmentError extends Error {
     this.name = "TransferAlignmentError";
   }
 }
+class WithdrawCollateralAlignmentError extends Error {
+  constructor(expected, actual) {
+    super(
+      `withdrawCollateral event alignment mismatch: expected ${expected} events, consumed ${actual}`
+    );
+    this.name = "WithdrawCollateralAlignmentError";
+  }
+}
 class ProtocolCallNotFoundError extends Error {
   targetContract;
   executeIndex;
@@ -60,5 +68,6 @@ export {
   TransferAlignmentError,
   UnexpectedFacadeEventOrderError,
   UnknownAdapterError,
-  UnknownFacadeCallError
+  UnknownFacadeCallError,
+  WithdrawCollateralAlignmentError
 };