@gearbox-protocol/sdk 14.12.0-next.5 → 14.12.0-next.51

package/dist/cjs/dev/claimDSToken.js

@@ -19,129 +19,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var claimDSToken_exports = {};
 __export(claimDSToken_exports, {
   claimDSToken: () => claimDSToken,
-  claimDSTokens: () => claimDSTokens,
-  registerInvestor: () => registerInvestor
+  claimDSTokens: () => claimDSTokens
 });
 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`);
-  }
-}
+var import_kycUtils = require("./kycUtils.js");
 async function claimDSToken(props) {
   const {
     anvil,
-    claimer,
+    investor,
     adminPrivateKey,
     token,
     marketConfigurators,
@@ -173,25 +62,25 @@ async function claimDSToken(props) {
     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, {
+  await (0, import_kycUtils.registerSecuritizeInvestor)({ ...props, logger });
+  logger?.debug(`Issuing ${amount} tokens to ${investor}...`);
+  const mintHash = await (0, import_kycUtils.writeAndWait)(anvil, {
     account,
     chain: anvil.chain,
     address: token,
     abi: import_iDSToken.iDSTokenAbi,
     functionName: "issueTokens",
-    args: [claimer, amount]
+    args: [investor, amount]
   });
   logger?.debug(`Done! tx: ${mintHash}`);
   const balance = await anvil.readContract({
     address: token,
     abi: import_viem.erc20Abi,
     functionName: "balanceOf",
-    args: [claimer]
+    args: [investor]
   });
   logger?.debug(
-    `Balance of ${claimer}: ${sdk.tokensMeta.formatBN(token, balance)}`
+    `Balance of ${investor}: ${sdk.tokensMeta.formatBN(token, balance)}`
   );
 }
 async function claimDSTokens(props) {
@@ -203,6 +92,5 @@ async function claimDSTokens(props) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   claimDSToken,
-  claimDSTokens,
-  registerInvestor
+  claimDSTokens
 });

package/dist/cjs/dev/index.js

@@ -35,6 +35,7 @@ __reExport(dev_exports, require("./EthCallSpy.js"), module.exports);
 __reExport(dev_exports, require("./isOutOfSyncError.js"), module.exports);
 __reExport(dev_exports, require("./isRateLimitError.js"), module.exports);
 __reExport(dev_exports, require("./isTransientError.js"), module.exports);
+__reExport(dev_exports, require("./kycUtils.js"), module.exports);
 var import_logSplitterTransport = require("./logSplitterTransport.js");
 __reExport(dev_exports, require("./ltUtils.js"), module.exports);
 __reExport(dev_exports, require("./migrateFaucet.js"), module.exports);
@@ -46,6 +47,7 @@ __reExport(dev_exports, require("./resilientTransport.js"), module.exports);
 __reExport(dev_exports, require("./transports.js"), module.exports);
 __reExport(dev_exports, require("./types.js"), module.exports);
 __reExport(dev_exports, require("./verifyTestnet.js"), module.exports);
+__reExport(dev_exports, require("./withdrawalUtils.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   isRangeError,
@@ -62,6 +64,7 @@ __reExport(dev_exports, require("./verifyTestnet.js"), module.exports);
   ...require("./isOutOfSyncError.js"),
   ...require("./isRateLimitError.js"),
   ...require("./isTransientError.js"),
+  ...require("./kycUtils.js"),
   ...require("./ltUtils.js"),
   ...require("./migrateFaucet.js"),
   ...require("./mint/index.js"),
@@ -71,5 +74,6 @@ __reExport(dev_exports, require("./verifyTestnet.js"), module.exports);
   ...require("./resilientTransport.js"),
   ...require("./transports.js"),
   ...require("./types.js"),
-  ...require("./verifyTestnet.js")
+  ...require("./verifyTestnet.js"),
+  ...require("./withdrawalUtils.js")
 });

package/dist/cjs/dev/kycUtils.js

@@ -0,0 +1,351 @@
+"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 kycUtils_exports = {};
+__export(kycUtils_exports, {
+  greenlistMidasGateway: () => greenlistMidasGateway,
+  registerMidasInvestor: () => registerMidasInvestor,
+  registerRWAInvestor: () => registerRWAInvestor,
+  registerSecuritizeInvestor: () => registerSecuritizeInvestor,
+  writeAndWait: () => writeAndWait
+});
+module.exports = __toCommonJS(kycUtils_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");
+var import_withdrawalAbi = require("./withdrawalAbi.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 registerSecuritizeInvestor(props) {
+  const { investor, 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: [investor]
+      },
+      {
+        address: registryService,
+        abi: import_iDSRegistryService.iDSRegistryServiceAbi,
+        functionName: "ACCREDITED",
+        args: []
+      },
+      {
+        address: registryService,
+        abi: import_iDSRegistryService.iDSRegistryServiceAbi,
+        functionName: "APPROVED",
+        args: []
+      }
+    ],
+    allowFailure: false
+  });
+  if (!isRegistered) {
+    logger?.debug(
+      `Investor ${investor} is not a registered wallet, registering...`
+    );
+    const investorId = `investor-${investor.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: [investor, investorId]
+    });
+    logger?.debug(`Added wallet ${investor} 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(`Investor ${investor} is already a registered wallet`);
+  }
+}
+const MIDAS_MODE_PERMISSIONED = 2;
+const iMidasGatewayExtAbi = (0, import_viem.parseAbi)([
+  "function greenlistedRole() external view returns (bytes32)"
+]);
+const iMidasAccessControlAbi = (0, import_viem.parseAbi)([
+  "function hasRole(bytes32 role, address account) external view returns (bool)",
+  "function getRoleAdmin(bytes32 role) external view returns (bytes32)",
+  "function grantRole(bytes32 role, address account) external"
+]);
+async function registerMidasInvestor(props) {
+  const { anvil, investor, admin, logger } = props;
+  const gateway = await findMidasGateway(props);
+  await greenlistMidasGateway({ anvil, investor, admin, gateway, logger });
+}
+async function greenlistMidasGateway(props) {
+  const { anvil, investor, admin, gateway, logger } = props;
+  const [accessControl, mode, greenlistedRole] = await anvil.multicall({
+    allowFailure: false,
+    contracts: [
+      {
+        address: gateway,
+        abi: import_withdrawalAbi.midasGatewayAbi,
+        functionName: "accessControl"
+      },
+      {
+        address: gateway,
+        abi: import_withdrawalAbi.midasGatewayAbi,
+        functionName: "mode"
+      },
+      {
+        address: gateway,
+        abi: iMidasGatewayExtAbi,
+        functionName: "greenlistedRole"
+      }
+    ]
+  });
+  if ((0, import_viem.isAddressEqual)(accessControl, import_viem.zeroAddress)) {
+    logger?.debug(
+      `midas: gateway ${gateway} is permissionless, nothing to greenlist`
+    );
+    return;
+  }
+  const operatorRole = await anvil.readContract({
+    address: accessControl,
+    abi: iMidasAccessControlAbi,
+    functionName: "getRoleAdmin",
+    args: [greenlistedRole]
+  });
+  logger?.debug(
+    `midas: gateway ${gateway}, access control ${accessControl}, mode ${mode}, greenlisted role ${greenlistedRole}, operator role ${operatorRole}`
+  );
+  const grants = [[operatorRole, gateway]];
+  if (mode === MIDAS_MODE_PERMISSIONED) {
+    grants.push([operatorRole, admin], [greenlistedRole, investor]);
+  } else {
+    logger?.debug(
+      `midas: gateway ${gateway} does not require greenlisted borrowers, only granting the operator role to the gateway`
+    );
+  }
+  const granted = await anvil.multicall({
+    allowFailure: false,
+    contracts: grants.map(([role, account]) => ({
+      address: accessControl,
+      abi: iMidasAccessControlAbi,
+      functionName: "hasRole",
+      args: [role, account]
+    }))
+  });
+  await anvil.impersonateAccount({ address: admin });
+  try {
+    await anvil.setBalance({ address: admin, value: (0, import_viem.parseEther)("100") });
+    for (const [i, [role, account]] of grants.entries()) {
+      if (granted[i]) {
+        logger?.debug(`midas: ${account} already has role ${role}`);
+        continue;
+      }
+      await writeAndWait(anvil, {
+        account: admin,
+        chain: anvil.chain,
+        address: accessControl,
+        abi: iMidasAccessControlAbi,
+        functionName: "grantRole",
+        args: [role, account]
+      });
+      logger?.debug(`midas: granted role ${role} to ${account}`);
+    }
+  } finally {
+    await anvil.stopImpersonatingAccount({ address: admin });
+  }
+  if (mode === MIDAS_MODE_PERMISSIONED) {
+    const isGreenlisted = await anvil.readContract({
+      address: accessControl,
+      abi: iMidasAccessControlAbi,
+      functionName: "hasRole",
+      args: [greenlistedRole, investor]
+    });
+    if (!isGreenlisted) {
+      throw new Error(`midas: failed to greenlist investor ${investor}`);
+    }
+    logger?.debug(`midas: investor ${investor} is greenlisted`);
+  }
+}
+async function findMidasGateway(props) {
+  const { anvil, token, marketConfigurators, logger } = props;
+  let sdk = props.sdk;
+  if (!sdk) {
+    sdk = new import_sdk.OnchainSDK(anvil.chain.network, {
+      client: anvil,
+      timeout: 12e4
+    });
+    await sdk.attach({ marketConfigurators });
+  }
+  const candidates = collectMidasGateways(sdk);
+  if (candidates.length === 0) {
+    throw new Error("no midas gateway adapters found in loaded markets");
+  }
+  const mTokens = await anvil.multicall({
+    allowFailure: false,
+    contracts: candidates.map((address) => ({
+      address,
+      abi: import_withdrawalAbi.midasGatewayAbi,
+      functionName: "mToken"
+    }))
+  });
+  const index = mTokens.findIndex((mToken) => (0, import_viem.isAddressEqual)(mToken, token));
+  if (index === -1) {
+    throw new Error(`no midas gateway found for token ${token}`);
+  }
+  logger?.debug(`midas: gateway for ${token} is ${candidates[index]}`);
+  return candidates[index];
+}
+function collectMidasGateways(sdk) {
+  const gateways = new import_sdk.AddressSet();
+  for (const cm of sdk.marketRegister.creditManagers) {
+    for (const adapter of cm.creditManager.adapters.values()) {
+      if (adapter.contractType === "ADAPTER::MIDAS_GATEWAY") {
+        gateways.add(adapter.targetContract);
+      }
+    }
+  }
+  return gateways.asArray();
+}
+async function registerRWAInvestor(props) {
+  const { anvil, sdk, investor, adminPrivateKey, midasAdmin, logger } = props;
+  const securitizeTokens = [];
+  const midasGateways = [];
+  const failed = [];
+  const dsTokens = new import_sdk.AddressSet(
+    sdk.rwa.factories.flatMap((factory) => factory.getTokens())
+  );
+  if (adminPrivateKey) {
+    for (const token of dsTokens) {
+      try {
+        await registerSecuritizeInvestor({
+          anvil,
+          investor,
+          adminPrivateKey,
+          token,
+          logger
+        });
+        securitizeTokens.push(token);
+      } catch (e) {
+        logger?.error(`securitize: failed to register ${investor} in ${token}`);
+        logger?.error(e);
+        failed.push({ target: token, error: e });
+      }
+    }
+  } else if (dsTokens.size > 0) {
+    logger?.warn(
+      `securitize: no admin private key, skipping ${dsTokens.size} DSToken(s)`
+    );
+  }
+  const gateways = collectMidasGateways(sdk);
+  if (midasAdmin) {
+    for (const gateway of gateways) {
+      try {
+        await greenlistMidasGateway({
+          anvil,
+          investor,
+          admin: midasAdmin,
+          gateway,
+          logger
+        });
+        midasGateways.push(gateway);
+      } catch (e) {
+        logger?.error(`midas: failed to greenlist ${investor} in ${gateway}`);
+        logger?.error(e);
+        failed.push({ target: gateway, error: e });
+      }
+    }
+  } else if (gateways.length > 0) {
+    logger?.warn(
+      `midas: no access control admin, skipping ${gateways.length} gateway(s)`
+    );
+  }
+  logger?.debug(
+    `${investor} passed KYC on ${securitizeTokens.length} DSToken(s) and ${midasGateways.length} midas gateway(s), ${failed.length} failure(s)`
+  );
+  return { securitizeTokens, midasGateways, failed };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  greenlistMidasGateway,
+  registerMidasInvestor,
+  registerRWAInvestor,
+  registerSecuritizeInvestor,
+  writeAndWait
+});