@gearbox-protocol/sdk 14.12.0-next.50 → 14.12.0-next.52

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);
@@ -63,6 +64,7 @@ __reExport(dev_exports, require("./withdrawalUtils.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"),

package/dist/cjs/dev/kycUtils.js

@@ -0,0 +1,388 @@
+"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 useSecuritizeAdmin(props) {
+  const { anvil, adminPrivateKey, admin, logger } = props;
+  if (adminPrivateKey) {
+    return {
+      account: (0, import_accounts.privateKeyToAccount)(adminPrivateKey),
+      release: async () => {
+      }
+    };
+  }
+  if (!admin) {
+    throw new Error(
+      "securitize: either adminPrivateKey or admin address is required"
+    );
+  }
+  await anvil.impersonateAccount({ address: admin });
+  await anvil.setBalance({ address: admin, value: (0, import_viem.parseEther)("100") });
+  logger?.debug(`securitize: impersonating registry admin ${admin}`);
+  return {
+    account: admin,
+    release: async () => {
+      await anvil.stopImpersonatingAccount({ address: admin });
+    }
+  };
+}
+async function registerSecuritizeInvestor(props) {
+  const { investor, anvil, token, logger } = props;
+  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]
+    });
+    const { account, release } = await useSecuritizeAdmin(props);
+    try {
+      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);
+      }
+    } finally {
+      await release();
+    }
+  } 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,
+    securitizeAdmin,
+    midasAdmin,
+    logger
+  } = props;
+  const securitizeTokens = [];
+  const midasGateways = [];
+  const failed = [];
+  const dsTokens = new import_sdk.AddressSet(
+    sdk.rwa.factories.flatMap((factory) => factory.getTokens())
+  );
+  if (adminPrivateKey || securitizeAdmin) {
+    for (const token of dsTokens) {
+      try {
+        await registerSecuritizeInvestor({
+          anvil,
+          investor,
+          adminPrivateKey,
+          admin: securitizeAdmin,
+          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 registry admin, 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
+});

package/dist/esm/dev/claimDSToken.js

@@ -2,126 +2,13 @@ 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`);
-  }
-}
+import { OnchainSDK } from "../sdk/index.js";
+import { registerSecuritizeInvestor, writeAndWait } from "./kycUtils.js";
 async function claimDSToken(props) {
   const {
     anvil,
-    claimer,
+    investor,
     adminPrivateKey,
     token,
     marketConfigurators,
@@ -153,25 +40,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}...`);
+  await registerSecuritizeInvestor({ ...props, logger });
+  logger?.debug(`Issuing ${amount} tokens to ${investor}...`);
   const mintHash = await writeAndWait(anvil, {
     account,
     chain: anvil.chain,
     address: token,
     abi: iDSTokenAbi,
     functionName: "issueTokens",
-    args: [claimer, amount]
+    args: [investor, amount]
   });
   logger?.debug(`Done! tx: ${mintHash}`);
   const balance = await anvil.readContract({
     address: token,
     abi: 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) {
@@ -182,6 +69,5 @@ async function claimDSTokens(props) {
 }
 export {
   claimDSToken,
-  claimDSTokens,
-  registerInvestor
+  claimDSTokens
 };

package/dist/esm/dev/index.js

@@ -10,6 +10,7 @@ export * from "./EthCallSpy.js";
 export * from "./isOutOfSyncError.js";
 export * from "./isRateLimitError.js";
 export * from "./isTransientError.js";
+export * from "./kycUtils.js";
 import {
   isRangeError,
   logSplitterTransport

package/dist/esm/dev/kycUtils.js

@@ -0,0 +1,369 @@
+import {
+  isAddressEqual,
+  parseAbi,
+  parseEther,
+  zeroAddress
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { iDSRegistryServiceAbi } from "../abi/rwa/iDSRegistryService.js";
+import { iDSTokenAbi } from "../abi/rwa/iDSToken.js";
+import {
+  AddressSet,
+  MAX_UINT256,
+  OnchainSDK
+} from "../sdk/index.js";
+import { midasGatewayAbi } from "./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 useSecuritizeAdmin(props) {
+  const { anvil, adminPrivateKey, admin, logger } = props;
+  if (adminPrivateKey) {
+    return {
+      account: privateKeyToAccount(adminPrivateKey),
+      release: async () => {
+      }
+    };
+  }
+  if (!admin) {
+    throw new Error(
+      "securitize: either adminPrivateKey or admin address is required"
+    );
+  }
+  await anvil.impersonateAccount({ address: admin });
+  await anvil.setBalance({ address: admin, value: parseEther("100") });
+  logger?.debug(`securitize: impersonating registry admin ${admin}`);
+  return {
+    account: admin,
+    release: async () => {
+      await anvil.stopImpersonatingAccount({ address: admin });
+    }
+  };
+}
+async function registerSecuritizeInvestor(props) {
+  const { investor, anvil, token, logger } = props;
+  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: [investor]
+      },
+      {
+        address: registryService,
+        abi: iDSRegistryServiceAbi,
+        functionName: "ACCREDITED",
+        args: []
+      },
+      {
+        address: registryService,
+        abi: 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: iDSRegistryServiceAbi,
+      functionName: "isInvestor",
+      args: [investorId]
+    });
+    const { account, release } = await useSecuritizeAdmin(props);
+    try {
+      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: [investor, investorId]
+      });
+      logger?.debug(`Added wallet ${investor} 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);
+      }
+    } finally {
+      await release();
+    }
+  } else {
+    logger?.debug(`Investor ${investor} is already a registered wallet`);
+  }
+}
+const MIDAS_MODE_PERMISSIONED = 2;
+const iMidasGatewayExtAbi = parseAbi([
+  "function greenlistedRole() external view returns (bytes32)"
+]);
+const iMidasAccessControlAbi = 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: midasGatewayAbi,
+        functionName: "accessControl"
+      },
+      {
+        address: gateway,
+        abi: midasGatewayAbi,
+        functionName: "mode"
+      },
+      {
+        address: gateway,
+        abi: iMidasGatewayExtAbi,
+        functionName: "greenlistedRole"
+      }
+    ]
+  });
+  if (isAddressEqual(accessControl, 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: 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 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: midasGatewayAbi,
+      functionName: "mToken"
+    }))
+  });
+  const index = mTokens.findIndex((mToken) => 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 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,
+    securitizeAdmin,
+    midasAdmin,
+    logger
+  } = props;
+  const securitizeTokens = [];
+  const midasGateways = [];
+  const failed = [];
+  const dsTokens = new AddressSet(
+    sdk.rwa.factories.flatMap((factory) => factory.getTokens())
+  );
+  if (adminPrivateKey || securitizeAdmin) {
+    for (const token of dsTokens) {
+      try {
+        await registerSecuritizeInvestor({
+          anvil,
+          investor,
+          adminPrivateKey,
+          admin: securitizeAdmin,
+          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 registry admin, 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 };
+}
+export {
+  greenlistMidasGateway,
+  registerMidasInvestor,
+  registerRWAInvestor,
+  registerSecuritizeInvestor,
+  writeAndWait
+};

package/dist/types/dev/claimDSToken.d.ts

@@ -3,7 +3,7 @@ import { type ILogger } from "../sdk/index.js";
 import type { AnvilClient } from "./createAnvilClient.js";
 interface ClaimDSTokenProps {
     anvil: AnvilClient;
-    claimer: Address;
+    investor: Address;
     adminPrivateKey: Hex;
     /**
      * DSToken addresses
@@ -20,14 +20,13 @@ interface ClaimDSTokenProps {
 type ClaimDSTokensProps = Omit<ClaimDSTokenProps, "token"> & {
     tokens: Address[];
 };
-export declare function registerInvestor(props: ClaimDSTokenProps): Promise<void>;
 export declare function claimDSToken(props: ClaimDSTokenProps): Promise<void>;
 /**
  * Helper function to claim DSToken from the faucet.
  * Works both for MockDStoken and real DSToken connected by securitize-deploy script
  * @param forkStatus
  * @param publicClient
- * @param claimer
+ * @param investor
  * @returns
  */
 export declare function claimDSTokens(props: ClaimDSTokensProps): Promise<void>;

package/dist/types/dev/index.d.ts

@@ -10,6 +10,7 @@ export * from "./EthCallSpy.js";
 export * from "./isOutOfSyncError.js";
 export * from "./isRateLimitError.js";
 export * from "./isTransientError.js";
+export * from "./kycUtils.js";
 export { isRangeError, type LogSplitterTransportOptions, logSplitterTransport, } from "./logSplitterTransport.js";
 export * from "./ltUtils.js";
 export * from "./migrateFaucet.js";

package/dist/types/dev/kycUtils.d.ts

@@ -0,0 +1,136 @@
+import { type Address, type Hex } from "viem";
+import { type ILogger, OnchainSDK } from "../sdk/index.js";
+import type { AnvilClient } from "./createAnvilClient.js";
+/**
+ * Writes to a contract, mines a block and waits for the receipt
+ */
+export declare function writeAndWait(anvil: AnvilClient, params: Parameters<AnvilClient["writeContract"]>[0]): Promise<Hex>;
+export interface RegisterSecuritizeInvestorProps {
+    anvil: AnvilClient;
+    /**
+     * Wallet to register in the Securitize DS registry
+     */
+    investor: Address;
+    /**
+     * Private key of the DS registry admin, signs the registry writes
+     */
+    adminPrivateKey?: Hex;
+    /**
+     * DS registry admin, impersonated on the fork when no private key is given
+     */
+    admin?: Address;
+    /**
+     * DSToken address
+     */
+    token: Address;
+    logger?: ILogger;
+}
+/**
+ * Registers a wallet as a Securitize investor (fake KYC) in the DS registry
+ * service of a DSToken.
+ * Works both for MockDSToken and real DSToken connected by securitize-deploy script
+ */
+export declare function registerSecuritizeInvestor(props: RegisterSecuritizeInvestorProps): Promise<void>;
+export interface RegisterMidasInvestorProps {
+    anvil: AnvilClient;
+    /**
+     * Investor EOA to greenlist
+     */
+    investor: Address;
+    /**
+     * Midas access control admin, impersonated on the fork
+     * (MIDAS_ACL_ADMIN in periphery-v3/router-v3 foundry tests)
+     */
+    admin: Address;
+    /**
+     * mToken address, the gateway is resolved from it
+     */
+    token: Address;
+    /**
+     * Attached SDK, created from `anvil` when omitted
+     */
+    sdk?: OnchainSDK;
+    marketConfigurators?: Address[];
+    logger?: ILogger;
+}
+/**
+ * Greenlists an investor in Midas access control (fake KYC) on an anvil fork.
+ *
+ * Replicates the `_grantGreenlistAdmin` / `_grantGreenlist` logic from the
+ * foundry tests (periphery-v3's WithdrawalCompressorMidasRWA.t.sol and
+ * router-v3's RouterLiveTestMidas.sol) by impersonating the Midas access
+ * control admin instead of pranking it.
+ */
+export declare function registerMidasInvestor(props: RegisterMidasInvestorProps): Promise<void>;
+export interface GreenlistMidasGatewayProps {
+    anvil: AnvilClient;
+    /**
+     * Investor EOA to greenlist
+     */
+    investor: Address;
+    /**
+     * Midas access control admin, impersonated on the fork
+     * (MIDAS_ACL_ADMIN in periphery-v3/router-v3 foundry tests)
+     */
+    admin: Address;
+    /**
+     * Midas gateway address
+     */
+    gateway: Address;
+    logger?: ILogger;
+}
+/**
+ * Greenlists an investor in the access control of a single Midas gateway
+ */
+export declare function greenlistMidasGateway(props: GreenlistMidasGatewayProps): Promise<void>;
+export interface RegisterRWAInvestorProps {
+    anvil: AnvilClient;
+    /**
+     * Attached SDK, markets and RWA factories are read from it
+     */
+    sdk: OnchainSDK;
+    /**
+     * Wallet to pass the KYC of every RWA token
+     */
+    investor: Address;
+    /**
+     * Private key of the Securitize registry admin, DSTokens are skipped when
+     * neither this nor `securitizeAdmin` is set
+     */
+    adminPrivateKey?: Hex;
+    /**
+     * Securitize registry admin, impersonated on the fork
+     */
+    securitizeAdmin?: Address;
+    /**
+     * Midas access control admin, Midas gateways are skipped when omitted
+     */
+    midasAdmin?: Address;
+    logger?: ILogger;
+}
+export interface RWAKycFailure {
+    /**
+     * DSToken or Midas gateway that failed
+     */
+    target: Address;
+    error: unknown;
+}
+export interface RegisterRWAInvestorResult {
+    /**
+     * DSTokens the investor was registered in
+     */
+    securitizeTokens: Address[];
+    /**
+     * Midas gateways the investor was greenlisted in
+     */
+    midasGateways: Address[];
+    failed: RWAKycFailure[];
+}
+/**
+ * Registers a wallet as an investor (fake KYC) in every Securitize DSToken and
+ * every Midas gateway of the markets loaded by `sdk`.
+ *
+ * Failures of a single token or gateway are collected and reported in the
+ * result instead of aborting the whole run.
+ */
+export declare function registerRWAInvestor(props: RegisterRWAInvestorProps): Promise<RegisterRWAInvestorResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "14.12.0-next.50",
+  "version": "14.12.0-next.52",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {