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

package/dist/cjs/common-utils/utils/validation/validate-quota.spec.js

@@ -0,0 +1,79 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../test-utils/index.js");
+var import_validate_quota = require("./validate-quota.js");
+const mockCreditManager = (0, import_test_utils.buildCreditManager)({
+  minDebt: 1000n,
+  maxDebt: 1000000n,
+  totalDebtLimit: 5000000n,
+  totalDebt: 2000000n,
+  availableToBorrow: 3000000n,
+  quotas: {
+    [import_test_utils.mockToken1]: (0, import_test_utils.buildQuota)({
+      token: import_test_utils.mockToken1,
+      limit: 1000000n,
+      totalQuoted: 500000n,
+      rate: 0n
+    }),
+    [import_test_utils.mockToken2]: (0, import_test_utils.buildQuota)({
+      token: import_test_utils.mockToken2,
+      limit: 2000000n,
+      totalQuoted: 1000000n,
+      rate: 0n
+    })
+  },
+  maxEnabledTokensLength: 2
+});
+(0, import_vitest.describe)("validateQuota", () => {
+  (0, import_vitest.it)("returns null when all conditions are met", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {},
+      quotaUpdate: [],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: false
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns error when max quotas length is reached", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {
+        [import_test_utils.mockToken1]: { token: import_test_utils.mockToken1, balance: 1000n },
+        [import_test_utils.mockToken2]: { token: import_test_utils.mockToken2, balance: 1000n }
+      },
+      quotaUpdate: [],
+      creditManager: (0, import_test_utils.buildCreditManager)({
+        ...mockCreditManager,
+        maxEnabledTokensLength: 1
+      }),
+      throwOnZeroQuotaUpdate: false
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "maxQuotasLengthReached",
+      count: 2,
+      max: 1
+    });
+  });
+  (0, import_vitest.it)("returns error when quota update is empty and throwOnZeroQuotaUpdate is true", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {},
+      quotaUpdate: [],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: true
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "quotaShouldBeUpdated"
+    });
+  });
+  (0, import_vitest.it)("returns error when quota is insufficient", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {},
+      quotaUpdate: [{ token: import_test_utils.mockToken1, balance: 600000n }],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: false
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "insufficientQuota",
+      token: import_test_utils.mockToken1
+    });
+  });
+});

package/dist/cjs/common-utils/utils/validation/validate-token-to-obtain.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validate_token_to_obtain_exports = {};
+__export(validate_token_to_obtain_exports, {
+  validateTokenToObtain: () => validateTokenToObtain
+});
+module.exports = __toCommonJS(validate_token_to_obtain_exports);
+function validateTokenToObtain({
+  creditManager,
+  targetToken
+}) {
+  if (Array.isArray(targetToken)) {
+    for (const asset of targetToken) {
+      if (creditManager.forbiddenTokens[asset.token])
+        return { message: "tokenIsForbidden", token: asset.token };
+    }
+    return null;
+  }
+  if (targetToken !== null && creditManager.forbiddenTokens[targetToken])
+    return { message: "tokenIsForbidden", token: targetToken };
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateTokenToObtain
+});

package/dist/cjs/common-utils/utils/validation/validate-token-to-obtain.spec.js

@@ -0,0 +1,35 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../test-utils/index.js");
+var import_validate_token_to_obtain = require("./validate-token-to-obtain.js");
+const mockCreditManager = (0, import_test_utils.buildCreditManager)({
+  forbiddenTokens: {}
+});
+(0, import_vitest.describe)("validateTokenToObtain", () => {
+  (0, import_vitest.it)("returns null when targetToken is null", () => {
+    const result = (0, import_validate_token_to_obtain.validateTokenToObtain)({
+      targetToken: null,
+      creditManager: mockCreditManager
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns null when targetToken is not forbidden", () => {
+    const result = (0, import_validate_token_to_obtain.validateTokenToObtain)({
+      targetToken: import_test_utils.mockToken1,
+      creditManager: mockCreditManager
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns error when targetToken is forbidden", () => {
+    const result = (0, import_validate_token_to_obtain.validateTokenToObtain)({
+      targetToken: import_test_utils.mockToken1,
+      creditManager: (0, import_test_utils.buildCreditManager)({
+        ...mockCreditManager,
+        forbiddenTokens: {
+          [import_test_utils.mockToken1]: true
+        }
+      })
+    });
+    (0, import_vitest.expect)(result).toEqual({ message: "tokenIsForbidden", token: import_test_utils.mockToken1 });
+  });
+});

package/dist/cjs/common-utils/utils/validation/validation-types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validation_types_exports = {};
+module.exports = __toCommonJS(validation_types_exports);

package/dist/cjs/dev/AccountOpener.js

@@ -498,10 +498,10 @@ class AccountOpener extends import_sdk.SDKConstruct {
       );
       txHash = await this.#anvil.writeContract({
         account: depositor,
-        address: metadata.approveTarget,
+        address: underlying,
         abi: import_iERC20.ierc20Abi,
         functionName: "approve",
-        args: [address, allowance],
+        args: [metadata.approveTarget, allowance],
         chain: this.#anvil.chain
       });
       let receipt = await this.#anvil.waitForTransactionReceipt({
@@ -524,12 +524,11 @@ class AccountOpener extends import_sdk.SDKConstruct {
       if (!depositCall) {
         throw new Error(`no deposit call could be created for ${poolName}`);
       }
-      txHash = await this.#anvil.writeContract({
+      txHash = await this.#anvil.sendTransaction({
         account: depositor,
-        address: depositCall.target,
-        abi: depositCall.abi,
-        functionName: depositCall.functionName,
-        args: depositCall.args,
+        to: depositCall.tx.to,
+        data: depositCall.tx.callData,
+        value: BigInt(depositCall.tx.value ?? "0"),
         chain: this.#anvil.chain
       });
       receipt = await this.#anvil.waitForTransactionReceipt({ hash: txHash });

package/dist/cjs/dev/abi.js

@@ -18,7 +18,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var abi_exports = {};
 __export(abi_exports, {
+  faucetAbi: () => faucetAbi,
   iDegenNftv2Abi: () => iDegenNftv2Abi,
+  iOnchainExecutionIdAbi: () => iOnchainExecutionIdAbi,
   iOwnableAbi: () => iOwnableAbi,
   iaclTraitAbi: () => iaclTraitAbi
 });
@@ -34,9 +36,214 @@ const iDegenNftv2Abi = (0, import_viem.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"
+  }
+];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  faucetAbi,
   iDegenNftv2Abi,
+  iOnchainExecutionIdAbi,
   iOwnableAbi,
   iaclTraitAbi
 });

package/dist/cjs/dev/claimDSToken.js

@@ -0,0 +1,208 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var claimDSToken_exports = {};
+__export(claimDSToken_exports, {
+  claimDSToken: () => claimDSToken,
+  claimDSTokens: () => claimDSTokens,
+  registerInvestor: () => registerInvestor
+});
+module.exports = __toCommonJS(claimDSToken_exports);
+var import_viem = require("viem");
+var import_accounts = require("viem/accounts");
+var import_iDSRegistryService = require("../abi/rwa/iDSRegistryService.js");
+var import_iDSToken = require("../abi/rwa/iDSToken.js");
+var import_sdk = require("../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 = (0, import_accounts.privateKeyToAccount)(adminPrivateKey);
+  const registryServiceId = await anvil.readContract({
+    address: token,
+    abi: import_iDSToken.iDSTokenAbi,
+    functionName: "REGISTRY_SERVICE"
+  });
+  const registryService = await anvil.readContract({
+    address: token,
+    abi: import_iDSToken.iDSTokenAbi,
+    functionName: "getDSService",
+    args: [registryServiceId]
+  });
+  logger?.debug(`Registry service: ${registryService} (${registryServiceId})`);
+  const [isRegistered, ACCREDITED, APPROVED] = await anvil.multicall({
+    contracts: [
+      {
+        address: registryService,
+        abi: import_iDSRegistryService.iDSRegistryServiceAbi,
+        functionName: "isWallet",
+        args: [claimer]
+      },
+      {
+        address: registryService,
+        abi: import_iDSRegistryService.iDSRegistryServiceAbi,
+        functionName: "ACCREDITED",
+        args: []
+      },
+      {
+        address: registryService,
+        abi: import_iDSRegistryService.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: import_iDSRegistryService.iDSRegistryServiceAbi,
+      functionName: "isInvestor",
+      args: [investorId]
+    });
+    if (!investorExists) {
+      await writeAndWait(anvil, {
+        account,
+        chain: anvil.chain,
+        address: registryService,
+        abi: import_iDSRegistryService.iDSRegistryServiceAbi,
+        functionName: "registerInvestor",
+        args: [investorId, investorId]
+      });
+      logger?.debug(`Registered investor "${investorId}"`);
+    }
+    await writeAndWait(anvil, {
+      account,
+      chain: anvil.chain,
+      address: registryService,
+      abi: import_iDSRegistryService.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: import_iDSRegistryService.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: import_iDSRegistryService.iDSRegistryServiceAbi,
+        functionName: "setAttribute",
+        args: [
+          investorId,
+          ACCREDITED,
+          BigInt(APPROVED),
+          import_sdk.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 = (0, import_accounts.privateKeyToAccount)(adminPrivateKey);
+  const symbol = await anvil.readContract({
+    address: token,
+    abi: import_viem.erc20Abi,
+    functionName: "symbol",
+    args: []
+  });
+  const logger = props.logger?.child?.({ symbol });
+  const usdAmount = BigInt(usdAmountProp) * 10n ** 8n;
+  const sdk = new import_sdk.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: import_iDSToken.iDSTokenAbi,
+    functionName: "issueTokens",
+    args: [claimer, amount]
+  });
+  logger?.debug(`Done! tx: ${mintHash}`);
+  const balance = await anvil.readContract({
+    address: token,
+    abi: import_viem.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 });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  claimDSToken,
+  claimDSTokens,
+  registerInvestor
+});