@gearbox-protocol/sdk 17.0.0-next.3 → 17.0.0

package/dist/esm/dev/createAnvilClient.js

@@ -1,4 +1,6 @@
-import { createTestClient, publicActions, testActions, toHex, walletActions } from "viem";
+import { BaseError, createTestClient, publicActions, testActions, toHex, walletActions } from "viem";
+import { getAction } from "viem/utils";
+import { waitForTransactionReceipt, writeContract } from "viem/actions";
 //#region src/dev/createAnvilClient.ts
 let dealModulePromise;
 async function loadDeal() {
@@ -7,23 +9,27 @@ async function loadDeal() {
 	if (!mod) throw new Error("createAnvilClient: deal action requires the 'viem-deal' package; install it as a dependency");
 	return mod.deal;
 }
+function anvilActions(client) {
+	return {
+		anvilNodeInfo: () => anvilNodeInfo(client),
+		isAnvil: () => isAnvil(client),
+		evmMineDetailed: (timestamp) => evmMineDetailed(client, timestamp),
+		deal: async (params) => {
+			await (await loadDeal())(client, params);
+		},
+		writeContractSync: (parameters) => writeContractSync(client, parameters)
+	};
+}
 /**
 * Extends an arbitrary viem `PublicClient` with anvil + wallet actions plus
 * the SDK's bonus actions (`anvilNodeInfo`, `isAnvil`, `evmMineDetailed`,
-* `deal`).
+* `deal`, `writeContractSync`).
 *
 * Used to lift `sdk.client` into an `AnvilClient` shape on the fly when test
 * RPCs (impersonateAccount, setBalance, setStorageAt, ...) are needed.
 */
 function extendAnvilClient(client) {
-	return client.extend(() => ({ mode: "anvil" })).extend(testActions({ mode: "anvil" })).extend(walletActions).extend((c) => ({
-		anvilNodeInfo: () => anvilNodeInfo(c),
-		isAnvil: () => isAnvil(c),
-		evmMineDetailed: (timestamp) => evmMineDetailed(c, timestamp),
-		deal: async (params) => {
-			await (await loadDeal())(c, params);
-		}
-	}));
+	return client.extend(() => ({ mode: "anvil" })).extend(testActions({ mode: "anvil" })).extend(walletActions).extend((c) => anvilActions(c));
 }
 function createAnvilClient({ chain, transport, cacheTime = 0, pollingInterval = 50 }) {
 	return createTestClient({
@@ -32,14 +38,7 @@ function createAnvilClient({ chain, transport, cacheTime = 0, pollingInterval =
 		transport,
 		cacheTime,
 		pollingInterval
-	}).extend(publicActions).extend(walletActions).extend((c) => ({
-		anvilNodeInfo: () => anvilNodeInfo(c),
-		isAnvil: () => isAnvil(c),
-		evmMineDetailed: (timestamp) => evmMineDetailed(c, timestamp),
-		deal: async (params) => {
-			await (await loadDeal())(c, params);
-		}
-	}));
+	}).extend(publicActions).extend(walletActions).extend((c) => anvilActions(c));
 }
 /**
 * View action to detect if client is an anvil client
@@ -84,5 +83,23 @@ async function evmMineDetailed(client, timestamp) {
 		return;
 	}
 }
+/**
+* Anvil-compatible `writeContractSync`: send via `writeContract` (Anvil
+* supports `eth_sendTransaction` / `eth_sendRawTransaction`) then wait for
+* the receipt. Viem's own action uses `eth_sendRawTransactionSync`, which
+* Anvil does not implement.
+*/
+async function writeContractSync(client, parameters) {
+	const { throwOnReceiptRevert, pollingInterval, timeout, ...writeParams } = parameters;
+	const hash = await getAction(client, writeContract, "writeContract")(writeParams);
+	const receipt = await getAction(client, waitForTransactionReceipt, "waitForTransactionReceipt")({
+		checkReplacement: false,
+		hash,
+		pollingInterval,
+		timeout
+	});
+	if (throwOnReceiptRevert && receipt.status === "reverted") throw new BaseError(`Transaction with hash "${receipt.transactionHash}" reverted.`, { name: "TransactionReceiptRevertedError" });
+	return receipt;
+}
 //#endregion
-export { anvilNodeInfo, createAnvilClient, evmMineDetailed, extendAnvilClient, isAnvil };
+export { anvilNodeInfo, createAnvilClient, evmMineDetailed, extendAnvilClient, isAnvil, writeContractSync };

package/dist/esm/dev/index.js

@@ -1,6 +1,6 @@
 import { iDegenNftv2Abi, iFaucetAbi, iOnchainExecutionIdAbi, iOwnableAbi, iaclTraitAbi } from "./abi.js";
 import { claimFromFaucet } from "./claimFromFaucet.js";
-import { anvilNodeInfo, createAnvilClient, evmMineDetailed, extendAnvilClient, isAnvil } from "./createAnvilClient.js";
+import { anvilNodeInfo, createAnvilClient, evmMineDetailed, extendAnvilClient, isAnvil, writeContractSync } from "./createAnvilClient.js";
 import { createMinter } from "./mint/factory.js";
 import "./mint/index.js";
 import { AccountOpener, OpenTxRevertedError } from "./AccountOpener.js";
@@ -13,10 +13,10 @@ import { detectChain } from "./detectChain.js";
 import { isOutOfSyncError } from "./isOutOfSyncError.js";
 import { isRateLimitError } from "./isRateLimitError.js";
 import { isTransientError } from "./isTransientError.js";
-import { greenlistMidasGateway, registerMidasInvestor, registerRWAInvestor, registerSecuritizeInvestor, writeAndWait } from "./kycUtils.js";
+import { discoverMidasCreditSuites, discoverMidasGateways, discoverMidasMTokens, unpauseMidasIssuanceVault } from "./midasUtils.js";
+import { DEFAULT_MIDAS_ADMIN, getSecuritizeAdmin, greenlistMidasGateway, registerMidasInvestor, registerRWAInvestor, registerSecuritizeInvestor } from "./kycUtils.js";
 import { isRangeError, logSplitterTransport } from "./logSplitterTransport.js";
 import { setLTZero, setLTs } from "./ltUtils.js";
-import { unpauseMidasIssuanceVault } from "./midasUtils.js";
 import { migrateFaucet } from "./migrateFaucet.js";
 import { SUPPORTED_RPC_PROVIDERS, getAlchemyUrl, getAnkrUrl, getDrpcUrl, getErpcKey, getRpcProviderUrl, getThirdWebUrl, rpcProvidersSchema } from "./providers.js";
 import { replaceStorage } from "./replaceStorage.js";
@@ -25,4 +25,4 @@ import { claimDSToken, claimDSTokens, enableDSTokenBackDating } from "./securiti
 import "./types.js";
 import { ONCHAIN_EXECUTION_ID_ADDRESS, verifyTestnet } from "./verifyTestnet.js";
 import { makePendingWithdrawalsClaimable } from "./withdrawalUtils.js";
-export { AccountOpener, Create2Deployer, DEFAULT_CREATE2_SALT, EthCallSpy, NoAvailableTransportsError, ONCHAIN_EXECUTION_ID_ADDRESS, OpenTxRevertedError, PUBLIC_CREATE2_FACTORY, RevolverTransport, SUPPORTED_RPC_PROVIDERS, SelectionStrategy, anvilNodeInfo, calcLiquidatableLTs, claimDSToken, claimDSTokens, claimFromFaucet, createAnvilClient, createMinter, deployUsingPublicCreate2, detectChain, enableDSTokenBackDating, evmMineDetailed, extendAnvilClient, getAlchemyUrl, getAnkrUrl, getDrpcUrl, getErpcKey, getPublicCreate2Address, getRpcProviderUrl, getThirdWebUrl, greenlistMidasGateway, httpTransportOptionsSchema, iDegenNftv2Abi, iFaucetAbi, iOnchainExecutionIdAbi, iOwnableAbi, iaclTraitAbi, isAnvil, isDeployedUsingPublicCreate2, isOutOfSyncError, isRangeError, isRateLimitError, isTransientError, logSplitterTransport, makePendingWithdrawalsClaimable, migrateFaucet, providerConfigSchema, registerMidasInvestor, registerRWAInvestor, registerSecuritizeInvestor, replaceStorage, resilientTransport, resilientTransportOptionsSchema, revolverTransportConfigBaseSchema, revolverTransportConfigSchema, rpcProvidersSchema, setLTZero, setLTs, unpauseMidasIssuanceVault, verifyTestnet, writeAndWait };
+export { AccountOpener, Create2Deployer, DEFAULT_CREATE2_SALT, DEFAULT_MIDAS_ADMIN, EthCallSpy, NoAvailableTransportsError, ONCHAIN_EXECUTION_ID_ADDRESS, OpenTxRevertedError, PUBLIC_CREATE2_FACTORY, RevolverTransport, SUPPORTED_RPC_PROVIDERS, SelectionStrategy, anvilNodeInfo, calcLiquidatableLTs, claimDSToken, claimDSTokens, claimFromFaucet, createAnvilClient, createMinter, deployUsingPublicCreate2, detectChain, discoverMidasCreditSuites, discoverMidasGateways, discoverMidasMTokens, enableDSTokenBackDating, evmMineDetailed, extendAnvilClient, getAlchemyUrl, getAnkrUrl, getDrpcUrl, getErpcKey, getPublicCreate2Address, getRpcProviderUrl, getSecuritizeAdmin, getThirdWebUrl, greenlistMidasGateway, httpTransportOptionsSchema, iDegenNftv2Abi, iFaucetAbi, iOnchainExecutionIdAbi, iOwnableAbi, iaclTraitAbi, isAnvil, isDeployedUsingPublicCreate2, isOutOfSyncError, isRangeError, isRateLimitError, isTransientError, logSplitterTransport, makePendingWithdrawalsClaimable, migrateFaucet, providerConfigSchema, registerMidasInvestor, registerRWAInvestor, registerSecuritizeInvestor, replaceStorage, resilientTransport, resilientTransportOptionsSchema, revolverTransportConfigBaseSchema, revolverTransportConfigSchema, rpcProvidersSchema, setLTZero, setLTs, unpauseMidasIssuanceVault, verifyTestnet, writeContractSync };

package/dist/esm/dev/kycUtils.js

@@ -4,33 +4,52 @@ import { OnchainSDK } from "../onchain/OnchainSDK.js";
 import "../onchain/index.js";
 import { iDSRegistryServiceAbi } from "../abi/rwa/iDSRegistryService.js";
 import { iDSTokenAbi } from "../abi/rwa/iDSToken.js";
+import { discoverMidasCreditSuites, discoverMidasGateways } from "./midasUtils.js";
 import { midasGatewayAbi } from "./withdrawalAbi.js";
-import { isAddressEqual, parseAbi, parseEther, zeroAddress } from "viem";
-import { privateKeyToAccount } from "viem/accounts";
+import { getAddress, isAddressEqual, parseAbi, parseEther, slice, toHex, zeroAddress } from "viem";
 //#region src/dev/kycUtils.ts
+const iMockDSTokenAdminAbi = parseAbi(["function admin() view returns (address)"]);
 /**
-* Writes to a contract, mines a block and waits for the receipt
+* DS trust-service master of `token`: Ownable owner at storage slot 0 of the
+* trust service, same as periphery-v3 SecuritizeAttachHelper. MockDSToken
+* returns itself as the trust service, so `admin()` is used instead.
 */
-async function writeAndWait(anvil, params) {
-	const hash = await anvil.writeContract(params);
-	await anvil.mine({ blocks: 1 });
-	await anvil.waitForTransactionReceipt({
-		hash,
-		pollingInterval: 100
+async function getSecuritizeAdmin(anvil, token, logger) {
+	const trustServiceId = await anvil.readContract({
+		address: token,
+		abi: iDSTokenAbi,
+		functionName: "TRUST_SERVICE"
 	});
-	return hash;
+	const trustService = await anvil.readContract({
+		address: token,
+		abi: iDSTokenAbi,
+		functionName: "getDSService",
+		args: [trustServiceId]
+	});
+	if (isAddressEqual(trustService, token)) {
+		const admin = await anvil.readContract({
+			address: token,
+			abi: iMockDSTokenAdminAbi,
+			functionName: "admin"
+		});
+		logger?.debug(`securitize: found admin ${admin} for ${token} (token.admin)`);
+		return admin;
+	}
+	const word = await anvil.getStorageAt({
+		address: trustService,
+		slot: toHex(0, { size: 32 })
+	});
+	if (!word) throw new Error(`securitize: empty trust-service owner slot on ${trustService}`);
+	const admin = getAddress(slice(word, 12));
+	logger?.debug(`securitize: found admin ${admin} for ${token} (trust service ${trustService})`);
+	return admin;
 }
 /**
-* Resolves the account that performs the DS registry writes: either the admin
-* private key, or the admin address impersonated on the fork
+* Impersonates the DS trust-service admin of `token` on the fork
 */
 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");
+	const { anvil, token, logger } = props;
+	const admin = await getSecuritizeAdmin(anvil, token, logger);
 	await anvil.impersonateAccount({ address: admin });
 	await anvil.setBalance({
 		address: admin,
@@ -98,36 +117,39 @@ async function registerSecuritizeInvestor(props) {
 		const { account, release } = await useSecuritizeAdmin(props);
 		try {
 			if (!investorExists) {
-				await writeAndWait(anvil, {
+				await anvil.writeContractSync({
 					account,
 					chain: anvil.chain,
 					address: registryService,
 					abi: iDSRegistryServiceAbi,
 					functionName: "registerInvestor",
-					args: [investorId, investorId]
+					args: [investorId, investorId],
+					throwOnReceiptRevert: true
 				});
 				logger?.debug(`Registered investor "${investorId}"`);
 			}
-			await writeAndWait(anvil, {
+			await anvil.writeContractSync({
 				account,
 				chain: anvil.chain,
 				address: registryService,
 				abi: iDSRegistryServiceAbi,
 				functionName: "addWallet",
-				args: [investor, investorId]
+				args: [investor, investorId],
+				throwOnReceiptRevert: true
 			});
 			logger?.debug(`Added wallet ${investor} for investor "${investorId}"`);
 			try {
-				await writeAndWait(anvil, {
+				await anvil.writeContractSync({
 					account,
 					chain: anvil.chain,
 					address: registryService,
 					abi: iDSRegistryServiceAbi,
 					functionName: "setCountry",
-					args: [investorId, "US"]
+					args: [investorId, "US"],
+					throwOnReceiptRevert: true
 				});
 				logger?.debug(`Set country for investor "${investorId}" to "US"`);
-				await writeAndWait(anvil, {
+				await anvil.writeContractSync({
 					account,
 					chain: anvil.chain,
 					address: registryService,
@@ -139,7 +161,8 @@ async function registerSecuritizeInvestor(props) {
 						BigInt(APPROVED),
 						MAX_UINT256,
 						"fake proof"
-					]
+					],
+					throwOnReceiptRevert: true
 				});
 				logger?.debug(`Set attributes for investor "${investorId}"`);
 			} catch (e) {
@@ -241,13 +264,14 @@ async function greenlistMidasGateway(props) {
 				logger?.debug(`midas: ${account} already has role ${role}`);
 				continue;
 			}
-			await writeAndWait(anvil, {
+			await anvil.writeContractSync({
 				account: admin,
 				chain: anvil.chain,
 				address: accessControl,
 				abi: iMidasAccessControlAbi,
 				functionName: "grantRole",
-				args: [role, account]
+				args: [role, account],
+				throwOnReceiptRevert: true
 			});
 			logger?.debug(`midas: granted role ${role} to ${account}`);
 		}
@@ -265,9 +289,7 @@ async function greenlistMidasGateway(props) {
 	}
 }
 /**
-* Finds the Midas gateway that issues `token` by scanning the Midas gateway
-* adapters of all loaded credit managers, same as the foundry tests do with
-* `ICreditConfiguratorV3.allowedAdapters`
+* Finds the Midas gateway that issues `token` among the loaded credit managers.
 */
 async function findMidasGateway(props) {
 	const { anvil, token, marketConfigurators, logger } = props;
@@ -279,30 +301,18 @@ async function findMidasGateway(props) {
 		});
 		await sdk.attach({ marketConfigurators });
 	}
-	const candidates = collectMidasGateways(sdk);
-	if (candidates.length === 0) throw new Error("no midas gateway adapters found in loaded markets");
-	const index = (await anvil.multicall({
-		allowFailure: false,
-		contracts: candidates.map((address) => ({
-			address,
-			abi: midasGatewayAbi,
-			functionName: "mToken"
-		}))
-	})).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];
+	const suites = await discoverMidasCreditSuites(sdk);
+	if (suites.length === 0) throw new Error("no midas gateway adapters or midas degen NFTs found in loaded markets");
+	const suite = suites.find(({ mToken }) => isAddressEqual(mToken, token));
+	if (!suite) throw new Error(`no midas gateway found for token ${token}`);
+	logger?.debug(`midas: gateway for ${token} is ${suite.gateway}`);
+	return suite.gateway;
 }
 /**
-* Collects the target contracts of all Midas gateway adapters of the loaded
-* credit managers, same as the foundry tests do with
-* `ICreditConfiguratorV3.allowedAdapters`
+* Midas access control admin on mainnet. Holds the admin role of the greenlist
+* operator role.
 */
-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();
-}
+const DEFAULT_MIDAS_ADMIN = "0xd4195CF4df289a4748C1A7B6dDBE770e27bA1227";
 /**
 * Registers a wallet as an investor (fake KYC) in every Securitize DSToken and
 * every Midas gateway of the markets loaded by `sdk`.
@@ -311,17 +321,15 @@ function collectMidasGateways(sdk) {
 * result instead of aborting the whole run.
 */
 async function registerRWAInvestor(props) {
-	const { anvil, sdk, investor, adminPrivateKey, securitizeAdmin, midasAdmin = "0xd4195CF4df289a4748C1A7B6dDBE770e27bA1227", logger } = props;
+	const { anvil, sdk, investor, midasAdmin = DEFAULT_MIDAS_ADMIN, 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 {
+	for (const token of dsTokens) try {
 		await registerSecuritizeInvestor({
 			anvil,
 			investor,
-			adminPrivateKey,
-			admin: securitizeAdmin,
 			token,
 			logger
 		});
@@ -334,8 +342,7 @@ async function registerRWAInvestor(props) {
 			error: e
 		});
 	}
-	else if (dsTokens.size > 0) logger?.warn(`securitize: no registry admin, skipping ${dsTokens.size} DSToken(s)`);
-	const gateways = collectMidasGateways(sdk);
+	const gateways = await discoverMidasGateways(sdk);
 	for (const gateway of gateways) try {
 		await greenlistMidasGateway({
 			anvil,
@@ -361,4 +368,4 @@ async function registerRWAInvestor(props) {
 	};
 }
 //#endregion
-export { greenlistMidasGateway, registerMidasInvestor, registerRWAInvestor, registerSecuritizeInvestor, writeAndWait };
+export { DEFAULT_MIDAS_ADMIN, getSecuritizeAdmin, greenlistMidasGateway, registerMidasInvestor, registerRWAInvestor, registerSecuritizeInvestor };

package/dist/esm/dev/midasUtils.js

@@ -1,5 +1,8 @@
-import { writeAndWait } from "./kycUtils.js";
-import { parseAbi, parseEther } from "viem";
+import { AddressSet } from "../onchain/utils/AddressSet.js";
+import { MidasGatewayAdapterContract } from "../onchain/market/adapters/contracts/MidasGatewayAdapterContract.js";
+import { MidasDegenNFT } from "../onchain/market/rwa/midas/MidasDegenNFT.js";
+import "../onchain/index.js";
+import { parseAbi, parseEther, toFunctionSelector } from "viem";
 //#region src/dev/midasUtils.ts
 /**
 * Midas vaults inherit their own `Pausable`, whose global pause is guarded by
@@ -9,14 +12,24 @@ const iMidasPausableVaultAbi = parseAbi([
 	"function paused() external view returns (bool)",
 	"function pause() external",
 	"function unpause() external",
+	"function fnPaused(bytes4 fn) external view returns (bool)",
+	"function pauseFn(bytes4 fn) external",
+	"function unpauseFn(bytes4 fn) external",
 	"function pauseAdminRole() external view returns (bytes32)",
 	"function accessControl() external view returns (address)"
 ]);
 const iMidasAccessControlAbi = parseAbi(["function hasRole(bytes32 role, address account) external view returns (bool)", "function grantRole(bytes32 role, address account) external"]);
 /**
-* Unpauses a globally paused Midas issuance vault on an anvil fork, so that
-* `depositInstant` stops reverting with `Pausable: paused`, and returns a
-* callback that restores the original pause state.
+* Selector for `DepositVault.depositInstant(address,uint256,uint256,bytes32)`,
+* the 4-arg mint Gearbox adapters encode. Distinct from the custom-recipient
+* overload.
+*/
+const DEPOSIT_INSTANT_SELECTOR = toFunctionSelector("depositInstant(address,uint256,uint256,bytes32)");
+/**
+* Unpauses a Midas issuance vault on an anvil fork so that `depositInstant`
+* stops reverting with `Pausable: paused` (global) or `Pausable: fn paused`
+* (per-selector), and returns a callback that restores the original pause
+* state of each layer that was cleared.
 *
 * Impersonates `admin` and grants it `pauseAdminRole()` when missing, same as
 * `greenlistMidasGateway` does with the greenlist roles. The grant is not
@@ -24,11 +37,20 @@ const iMidasAccessControlAbi = parseAbi(["function hasRole(bytes32 role, address
 */
 async function unpauseMidasIssuanceVault(props) {
 	const { anvil, vault, admin, logger } = props;
-	if (!await anvil.readContract({
-		address: vault,
-		abi: iMidasPausableVaultAbi,
-		functionName: "paused"
-	})) {
+	const [paused, depositInstantPaused] = await anvil.multicall({
+		allowFailure: false,
+		contracts: [{
+			address: vault,
+			abi: iMidasPausableVaultAbi,
+			functionName: "paused"
+		}, {
+			address: vault,
+			abi: iMidasPausableVaultAbi,
+			functionName: "fnPaused",
+			args: [DEPOSIT_INSTANT_SELECTOR]
+		}]
+	});
+	if (!paused && !depositInstantPaused) {
 		logger?.debug(`midas: issuance vault ${vault} is not paused`);
 		return async () => {};
 	}
@@ -50,7 +72,7 @@ async function unpauseMidasIssuanceVault(props) {
 		functionName: "hasRole",
 		args: [pauseAdminRole, admin]
 	});
-	logger?.debug(`midas: unpausing issuance vault ${vault} as ${admin}, access control ${accessControl}, pause admin role ${pauseAdminRole}`);
+	logger?.debug(`midas: unpausing issuance vault ${vault} as ${admin}, access control ${accessControl}, pause admin role ${pauseAdminRole}` + (paused ? ", global" : "") + (depositInstantPaused ? ", depositInstant" : ""));
 	await anvil.impersonateAccount({ address: admin });
 	try {
 		await anvil.setBalance({
@@ -58,22 +80,33 @@ async function unpauseMidasIssuanceVault(props) {
 			value: parseEther("100")
 		});
 		if (!isPauseAdmin) {
-			await writeAndWait(anvil, {
+			await anvil.writeContractSync({
 				account: admin,
 				chain: anvil.chain,
 				address: accessControl,
 				abi: iMidasAccessControlAbi,
 				functionName: "grantRole",
-				args: [pauseAdminRole, admin]
+				args: [pauseAdminRole, admin],
+				throwOnReceiptRevert: true
 			});
 			logger?.debug(`midas: granted pause admin role to ${admin}`);
 		}
-		await writeAndWait(anvil, {
+		if (paused) await anvil.writeContractSync({
 			account: admin,
 			chain: anvil.chain,
 			address: vault,
 			abi: iMidasPausableVaultAbi,
-			functionName: "unpause"
+			functionName: "unpause",
+			throwOnReceiptRevert: true
+		});
+		if (depositInstantPaused) await anvil.writeContractSync({
+			account: admin,
+			chain: anvil.chain,
+			address: vault,
+			abi: iMidasPausableVaultAbi,
+			functionName: "unpauseFn",
+			args: [DEPOSIT_INSTANT_SELECTOR],
+			throwOnReceiptRevert: true
 		});
 	} finally {
 		await anvil.stopImpersonatingAccount({ address: admin });
@@ -89,12 +122,22 @@ async function unpauseMidasIssuanceVault(props) {
 				address: admin,
 				value: parseEther("100")
 			});
-			await writeAndWait(anvil, {
+			if (paused) await anvil.writeContractSync({
 				account: admin,
 				chain: anvil.chain,
 				address: vault,
 				abi: iMidasPausableVaultAbi,
-				functionName: "pause"
+				functionName: "pause",
+				throwOnReceiptRevert: true
+			});
+			if (depositInstantPaused) await anvil.writeContractSync({
+				account: admin,
+				chain: anvil.chain,
+				address: vault,
+				abi: iMidasPausableVaultAbi,
+				functionName: "pauseFn",
+				args: [DEPOSIT_INSTANT_SELECTOR],
+				throwOnReceiptRevert: true
 			});
 		} catch (e) {
 			logger?.warn(`midas: failed to pause issuance vault ${vault} back: ${e}`);
@@ -103,5 +146,56 @@ async function unpauseMidasIssuanceVault(props) {
 		}
 	};
 }
+/**
+* Midas credit suites of the loaded credit managers.
+*
+* A manager with a gateway adapter is a suite on its own, so its degen NFT
+* is not consulted. Suites that only have a Midas degen NFT read `mToken`
+* from the gateway.
+*/
+async function discoverMidasCreditSuites(sdk) {
+	const suites = [];
+	for (const cm of sdk.marketRegister.creditManagers) {
+		const creditManager = cm.creditManager.address;
+		let hasAdapter = false;
+		for (const adapter of cm.creditManager.adapters.values()) if (adapter instanceof MidasGatewayAdapterContract) {
+			hasAdapter = true;
+			suites.push({
+				creditManager,
+				gateway: adapter.gateway,
+				mToken: adapter.mToken
+			});
+		}
+		if (hasAdapter) continue;
+		const nft = await cm.degenNFT();
+		if (nft instanceof MidasDegenNFT) {
+			const [mToken] = await nft.getTokens();
+			suites.push({
+				creditManager,
+				gateway: nft.gateway,
+				mToken
+			});
+		}
+	}
+	return suites;
+}
+/**
+* Gateways of the Midas credit suites of the loaded credit managers.
+*/
+async function discoverMidasGateways(sdk) {
+	const suites = await discoverMidasCreditSuites(sdk);
+	return new AddressSet(suites.map((suite) => suite.gateway)).asArray();
+}
+/**
+* mTokens of the Midas credit suites of the loaded credit managers.
+*
+* A manager with a gateway adapter contributes that adapter's mToken, so its
+* degen NFT is not consulted. Suites that only have a Midas degen NFT
+* contribute the mToken read from the gateway.
+*/
+async function discoverMidasMTokens(sdk) {
+	const suites = await discoverMidasCreditSuites(sdk);
+	return new AddressSet(suites.map((suite) => suite.mToken)).asArray();
+}
 //#endregion
-export { unpauseMidasIssuanceVault };
+export { discoverMidasCreditSuites, discoverMidasGateways, discoverMidasMTokens, unpauseMidasIssuanceVault };