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

package/dist/esm/sdk/execute/ExecuteApi.js

@@ -16,6 +16,8 @@ var ExecuteApi = class {
 		switch (request.kind) {
 			case "pool": return poolTx(sdk, request);
 			case "open": return openTx(sdk, request);
+			case "openEmpty": return openEmptyTx(sdk, request);
+			case "borrow": return borrowTx(sdk, request);
 			case "account": return accountTx(sdk, request);
 		}
 	}
@@ -62,20 +64,78 @@ async function openTx(sdk, request) {
 		reopenCreditAccount: state.creditAccount,
 		permits: {},
 		referralCode: 0n,
-		rwaOptions: await openRwaOptions(sdk, request)
+		rwaOptions: await openRwaOptions(sdk, request, request.targetToken)
+	});
+}
+/**
+* The opening with nothing in it: no debt to draw, no collateral to take, no
+* path to run and no quota to buy, so `openCA` is left with the price updates
+* the market demands and the facade's own `openCreditAccount`.
+*
+* Nothing is read off the preparation because there is nothing on it. The
+* account holds no token, so an RWA market has none to gate on either.
+**/
+function openEmptyTx(sdk, request) {
+	return sdk.accounts.openCA({
+		creditManager: request.creditManager,
+		to: request.wallet,
+		collateral: [],
+		ethAmount: 0n,
+		debt: 0n,
+		calls: [],
+		averageQuota: [],
+		minQuota: [],
+		permits: {},
+		referralCode: 0n
+	});
+}
+/**
+* A loan is an opening whose debt leaves again, so it is the same `openCA`
+* with `withdrawToken` set: the facade draws the debt, takes the collateral,
+* runs whatever path buys the payout, and sweeps that payout to the wallet.
+*
+* Both quota branches are the one the state carries. An opening has two
+* because the balances it lands on are a router quote; here the account is
+* left holding the collateral the caller named, and a named amount has no
+* floor to differ from.
+**/
+async function borrowTx(sdk, request) {
+	const { creditManager, wallet, ethAmount, sim } = request;
+	const { state } = sim.data;
+	const collateral = {
+		token: state.collateral.token.address,
+		balance: state.collateral.value
+	};
+	return sdk.accounts.openCA({
+		creditManager,
+		to: wallet,
+		collateral: [collateral],
+		ethAmount,
+		debt: state.totalDebt.value,
+		calls: state.calls,
+		withdrawToken: state.borrowed.token.address,
+		averageQuota: state.quotaIncrease,
+		minQuota: state.quotaIncrease,
+		reopenCreditAccount: state.creditAccount,
+		permits: {},
+		referralCode: 0n,
+		rwaOptions: await openRwaOptions(sdk, request, collateral.token)
 	});
 }
 /**
 * The documented `openCA` contract: ask the market for its open requirements
 * and hand them back as operation args, with the caller's cached signatures
-* attached. `undefined` on non-RWA markets and when no target token is named.
+* attached. `undefined` on non-RWA markets and when no token is named.
+*
+* `token` is the one the account ends up holding, which is what an RWA market
+* gates on: the opening's target, and the borrow's collateral.
 **/
-async function openRwaOptions(sdk, request) {
-	if (!request.targetToken) return;
-	const requirements = await sdk.accounts.getOpenAccountRequirements(request.wallet, request.creditManager, { tokenOutAddress: request.targetToken });
-	if (!requirements) return;
+async function openRwaOptions(sdk, request, token) {
+	if (!token) return;
+	const requirements = await sdk.accounts.getOpenAccountRequirements(request.wallet, request.creditManager, { tokenOutAddress: token });
+	if (requirements?.protocol !== "securitize") return;
 	return {
-		type: requirements.type,
+		protocol: "securitize",
 		tokensToRegister: requirements.tokensToRegister,
 		signaturesToCache: request.signaturesToCache ?? []
 	};

package/dist/esm/sdk/opportunities/OpportunitiesNamespace.js

@@ -70,15 +70,21 @@ var OpportunitiesNamespace = class extends AbstractNamespace {
 	/**
 	* {@inheritDoc IOpportunitiesBase.getStrategy}
 	**/
-	async getStrategy(key, wallet) {
+	async getStrategy(key) {
 		return this.merged("get strategy opportunity", {
 			chainIds: [key.chainId],
-			fromChain: (source) => source.getStrategy(key, wallet),
-			fromBackend: (source) => source.getStrategy(key, wallet),
+			fromChain: (source) => source.getStrategy(key),
+			fromBackend: (source) => source.getStrategy(key),
 			merge: this.merge.strategy
 		});
 	}
 	/**
+	* {@inheritDoc IOpportunitiesOnchainOnly.isEligibleForStrategy}
+	**/
+	async isEligibleForStrategy(key, wallet) {
+		return this.onchain.isEligibleForStrategy(key, wallet);
+	}
+	/**
 	* {@inheritDoc IOpportunitiesBase.filter}
 	**/
 	filter(response, filter) {

package/dist/esm/sdk/prepare/PrepareApi.js

@@ -55,7 +55,7 @@ var PrepareApi = class extends MultichainConstruct {
 			const at = stateBlock(sdk);
 			const intent = resumable(params.intent ?? params.claimable.intent);
 			if (!intent) return sdkErr(noRecordedIntent());
-			const creditAccount = await slice(sdk, position.creditAccount);
+			const creditAccount = await slice$1(sdk, position.creditAccount);
 			if (!creditAccount) return sdkErr(creditAccountNotFound(position.creditAccount));
 			return finalized(await service(sdk).finishIntent({
 				intent,
@@ -195,26 +195,33 @@ var PrepareApi = class extends MultichainConstruct {
 		}
 	}
 	/**
+	* {@inheritDoc IOpportunitiesPrepare.openEmptyCreditAccount}
+	**/
+	async openEmptyCreditAccount(strategy) {
+		try {
+			const sdk = await this.#chain(strategy.chainId);
+			const at = stateBlock(sdk);
+			const result = await service(sdk).openEmptyAccountIntent({
+				sdk,
+				creditManager: strategy.creditManager
+			});
+			return result.ok ? sdkOk(at) : methodError(result);
+		} catch (e) {
+			return sdkErr(unexpectedFailure(e));
+		}
+	}
+	/**
 	* {@inheritDoc IOpportunitiesPrepare.openNewStrategy}
 	**/
 	async openNewStrategy(strategy, params) {
 		try {
 			const sdk = await this.#chain(strategy.chainId);
 			const at = stateBlock(sdk);
-			if (params.empty) return opened(await service(sdk).openStrategyIntent({
-				sdk,
-				creditManager: strategy.creditManager,
-				empty: true
-			}), at);
 			const targetToken = params.targetToken ?? sdk.marketRegister.findCreditManager(strategy.creditManager).strategyTargetCollateral;
 			if (!targetToken) return sdkErr(noStrategyTargetCollateral(strategy.creditManager));
-			let creditAccount;
-			if (params.creditAccount) {
-				const reused = await slice(sdk, params.creditAccount);
-				if (!reused || !isAddressEqual(reused.creditManager, strategy.creditManager)) return sdkErr(creditAccountNotFound(params.creditAccount));
-				if (reused.totalDebt > 0n || reused.tokens.some((t) => t.quota > 0n)) return sdkErr(creditAccountNotEmpty(params.creditAccount));
-				creditAccount = reused;
-			}
+			const reused = await reusable(sdk, strategy, params.creditAccount);
+			if (reused && "error" in reused) return reused;
+			const creditAccount = reused?.account;
 			return opened(await service(sdk).openStrategyIntent({
 				sdk,
 				creditManager: strategy.creditManager,
@@ -231,6 +238,30 @@ var PrepareApi = class extends MultichainConstruct {
 		}
 	}
 	/**
+	* {@inheritDoc IOpportunitiesPrepare.borrow}
+	**/
+	async borrow(strategy, params) {
+		try {
+			const sdk = await this.#chain(strategy.chainId);
+			const at = stateBlock(sdk);
+			const reused = await reusable(sdk, strategy, params.creditAccount);
+			if (reused && "error" in reused) return reused;
+			return borrowed(await service(sdk).borrowIntent({
+				sdk,
+				creditManager: strategy.creditManager,
+				collateralToken: params.collateralToken,
+				collateralAmount: params.collateralAmount,
+				borrowToken: params.borrowToken,
+				borrowAmount: params.borrowAmount,
+				slippage: params.slippage,
+				quotaReserve: params.quotaReserve,
+				creditAccount: reused?.account
+			}), at);
+		} catch (e) {
+			return sdkErr(unexpectedFailure(e));
+		}
+	}
+	/**
 	* {@inheritDoc IOpportunitiesPrepare.depositStrategy}
 	**/
 	async depositStrategy(position, params) {
@@ -258,12 +289,13 @@ var PrepareApi = class extends MultichainConstruct {
 	/**
 	* {@inheritDoc IOpportunitiesPrepare.maxWithdraw}
 	**/
-	async maxWithdraw(position) {
+	async maxWithdraw(position, sourceToken) {
 		const sdk = await this.#chain(position.chainId);
 		const creditAccount = await this.#account(sdk, position);
 		return service(sdk).maxWithdraw({
 			creditAccount,
-			sdk
+			sdk,
+			sourceToken
 		});
 	}
 	/**
@@ -352,12 +384,27 @@ var PrepareApi = class extends MultichainConstruct {
 		});
 	}
 	/**
+	* {@inheritDoc IOpportunitiesPrepare.maxBorrow}
+	**/
+	maxBorrow(strategy, params) {
+		const sdk = this.sdk.chain(strategy.chainId);
+		return service(sdk).maxBorrow({
+			sdk,
+			creditManager: strategy.creditManager,
+			collateralToken: params.collateralToken,
+			collateralAmount: params.collateralAmount,
+			borrowToken: params.borrowToken,
+			targetHF: params.targetHF,
+			quotaReserve: params.quotaReserve
+		});
+	}
+	/**
 	* The account a bare `max*` read weighs. These reads answer a number, not
 	* an envelope, so an account the markets do not hold is thrown rather than
 	* described, see {@link IOpportunitiesPrepare.maxWithdraw}.
 	**/
 	async #account(sdk, position) {
-		const creditAccount = await slice(sdk, position.creditAccount);
+		const creditAccount = await slice$1(sdk, position.creditAccount);
 		if (!creditAccount) throw new Error(creditAccountNotFound(position.creditAccount).message);
 		return creditAccount;
 	}
@@ -374,7 +421,7 @@ var PrepareApi = class extends MultichainConstruct {
 		try {
 			const sdk = await this.#chain(position.chainId);
 			const at = stateBlock(sdk);
-			const creditAccount = await slice(sdk, position.creditAccount);
+			const creditAccount = await slice$1(sdk, position.creditAccount);
 			if (!creditAccount) return neitherRoute(creditAccountNotFound(position.creditAccount));
 			return routed(await service(sdk).intentRoutes({
 				intent,
@@ -400,7 +447,7 @@ var PrepareApi = class extends MultichainConstruct {
 		try {
 			const sdk = await this.#chain(position.chainId);
 			const at = stateBlock(sdk);
-			const creditAccount = await slice(sdk, position.creditAccount);
+			const creditAccount = await slice$1(sdk, position.creditAccount);
 			if (!creditAccount) return sdkErr(creditAccountNotFound(position.creditAccount));
 			return planned(await service(sdk).startIntent({
 				intent,
@@ -432,11 +479,30 @@ function stateBlock(sdk) {
 * connected to hold no such account — closed since it was listed, or named on
 * the wrong chain. Read rather than thrown, so the caller gets a code for it.
 **/
-async function slice(sdk, creditAccount) {
+async function slice$1(sdk, creditAccount) {
 	const data = await sdk.accounts.getCreditAccountData(creditAccount);
 	return data && toCreditAccountSlice(data);
 }
 /**
+* The pre-opened account a request asks to be run on, held to what "pre-opened"
+* means: this manager's, owing nothing and holding no quota.
+*
+* Shared by the two flows that put something on a fresh account — an opening
+* and a borrow — so both hold a reused one to the same terms. Whatever
+* balances sit on it are left to the flow: an opening routes them, a borrow
+* leaves them where they are.
+*
+* @returns Nothing when the request named no account, the refusal to answer
+* with when it named one that does not qualify, and the slice otherwise
+**/
+async function reusable(sdk, strategy, creditAccount) {
+	if (!creditAccount) return;
+	const account = await slice$1(sdk, creditAccount);
+	if (!account || !isAddressEqual(account.creditManager, strategy.creditManager)) return sdkErr(creditAccountNotFound(creditAccount));
+	if (account.totalDebt > 0n || account.tokens.some((t) => t.quota > 0n)) return sdkErr(creditAccountNotEmpty(creditAccount));
+	return { account };
+}
+/**
 * The operation a claim resumes, or `undefined` when there is none to resume:
 * a withdrawal requested without an intent, or one read through a compressor
 * too old to report it. Every intent the engine records can be finished,
@@ -536,6 +602,15 @@ function opened(result, at) {
 }
 /**
 * {@inheritDoc planned}
+**/
+function borrowed(result, at) {
+	return result.ok ? sdkOk({
+		state: result.state,
+		...at
+	}) : methodError(result);
+}
+/**
+* {@inheritDoc planned}
 *
 * Both routes are payload, error and all: `errors` says why a missing one is
 * missing, and it stays on the error when neither route answered, since that is

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

@@ -108,11 +108,7 @@ declare const iFaucetAbi: readonly [{
       readonly internalType: "uint256";
     }];
   }];
-  readonly outputs: readonly [{
-    readonly name: "";
-    readonly type: "bool";
-    readonly internalType: "bool";
-  }];
+  readonly outputs: readonly [];
   readonly stateMutability: "nonpayable";
 }, {
   readonly type: "function";
@@ -126,11 +122,7 @@ declare const iFaucetAbi: readonly [{
     readonly type: "uint256";
     readonly internalType: "uint256";
   }];
-  readonly outputs: readonly [{
-    readonly name: "";
-    readonly type: "bool";
-    readonly internalType: "bool";
-  }];
+  readonly outputs: readonly [];
   readonly stateMutability: "nonpayable";
 }, {
   readonly type: "function";
@@ -140,11 +132,7 @@ declare const iFaucetAbi: readonly [{
     readonly type: "address";
     readonly internalType: "address";
   }];
-  readonly outputs: readonly [{
-    readonly name: "";
-    readonly type: "bool";
-    readonly internalType: "bool";
-  }];
+  readonly outputs: readonly [];
   readonly stateMutability: "nonpayable";
 }, {
   readonly type: "function";
@@ -207,6 +195,16 @@ declare const iFaucetAbi: readonly [{
     readonly internalType: "uint256";
   }];
   readonly stateMutability: "view";
+}, {
+  readonly type: "function";
+  readonly name: "owner";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "address";
+    readonly internalType: "address";
+  }];
+  readonly stateMutability: "view";
 }, {
   readonly type: "function";
   readonly name: "prices";

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

@@ -24,7 +24,6 @@ interface ClaimFromFaucetOptions {
   amount?: TokenClaim[] | bigint | ((minAmountUSD: bigint) => bigint);
   gasMultiplier?: bigint;
   logger?: ILogger;
-  sync?: boolean;
 }
 declare function claimFromFaucet(opts: ClaimFromFaucetOptions): Promise<void>;
 //#endregion

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

@@ -1,4 +1,4 @@
-import { Account, Address, Block, Chain, Client, Hex, Prettify, PublicClient, TestActions, TestRpcSchema, Transport, WalletClient } from "viem";
+import { Abi, Account, Address, Block, Chain, Client, ContractFunctionArgs, ContractFunctionName, Hex, Prettify, PublicClient, TestActions, TestRpcSchema, Transport, WalletClient, WriteContractSyncParameters, WriteContractSyncReturnType } from "viem";
 //#region src/dev/createAnvilClient.d.ts
 interface AnvilNodeInfo {
   currentBlockNumber: string;
@@ -67,7 +67,7 @@ interface AnvilClientConfig<transport extends Transport = Transport, chain exten
 /**
  * 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.
@@ -93,5 +93,12 @@ declare function anvilNodeInfo(client: Client<any, any, any, AnvilRPCSchema, any
  * @returns
  */
 declare function evmMineDetailed(client: Client<any, any, any, AnvilRPCSchema, any>, timestamp: bigint | number): Promise<Block<Hex> | undefined>;
+/**
+ * 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.
+ */
+declare function writeContractSync<chain extends Chain | undefined, account extends Account | undefined, const abi extends Abi | readonly unknown[], functionName extends ContractFunctionName<abi, "nonpayable" | "payable">, args extends ContractFunctionArgs<abi, "nonpayable" | "payable", functionName>, chainOverride extends Chain | undefined>(client: Client<Transport, chain, account>, parameters: WriteContractSyncParameters<abi, functionName, args, chain, account, chainOverride>): Promise<WriteContractSyncReturnType<chain>>;
 //#endregion
-export { AnvilActions, AnvilClient, AnvilClientConfig, AnvilDealParameters, AnvilNodeInfo, AnvilRPCSchema, anvilNodeInfo, createAnvilClient, evmMineDetailed, extendAnvilClient, isAnvil };
+export { AnvilActions, AnvilClient, AnvilClientConfig, AnvilDealParameters, AnvilNodeInfo, AnvilRPCSchema, anvilNodeInfo, createAnvilClient, evmMineDetailed, extendAnvilClient, isAnvil, writeContractSync };

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

@@ -6,15 +6,15 @@ import { iDegenNftv2Abi, iFaucetAbi, iOnchainExecutionIdAbi, iOwnableAbi, iaclTr
 import { calcLiquidatableLTs } from "./calcLiquidatableLTs.js";
 import { claimFromFaucet } from "./claimFromFaucet.js";
 import { Create2Deployer, Create2Parameters, DEFAULT_CREATE2_SALT, EnsureExistsUsingPublicCreate2ReturnType, GetCreate2AddressParameters, PUBLIC_CREATE2_FACTORY, deployUsingPublicCreate2, getPublicCreate2Address, isDeployedUsingPublicCreate2 } from "./create2.js";
-import { AnvilActions, AnvilClient, AnvilClientConfig, AnvilDealParameters, AnvilNodeInfo, AnvilRPCSchema, anvilNodeInfo, createAnvilClient, evmMineDetailed, extendAnvilClient, isAnvil } from "./createAnvilClient.js";
+import { AnvilActions, AnvilClient, AnvilClientConfig, AnvilDealParameters, AnvilNodeInfo, AnvilRPCSchema, anvilNodeInfo, createAnvilClient, evmMineDetailed, extendAnvilClient, isAnvil, writeContractSync } from "./createAnvilClient.js";
 import { detectChain } from "./detectChain.js";
 import { isOutOfSyncError } from "./isOutOfSyncError.js";
 import { isRateLimitError } from "./isRateLimitError.js";
 import { isTransientError } from "./isTransientError.js";
-import { GreenlistMidasGatewayProps, RWAKycFailure, RegisterMidasInvestorProps, RegisterRWAInvestorProps, RegisterRWAInvestorResult, RegisterSecuritizeInvestorProps, greenlistMidasGateway, registerMidasInvestor, registerRWAInvestor, registerSecuritizeInvestor, writeAndWait } from "./kycUtils.js";
+import { DEFAULT_MIDAS_ADMIN, GreenlistMidasGatewayProps, RWAKycFailure, RegisterMidasInvestorProps, RegisterRWAInvestorProps, RegisterRWAInvestorResult, RegisterSecuritizeInvestorProps, getSecuritizeAdmin, greenlistMidasGateway, registerMidasInvestor, registerRWAInvestor, registerSecuritizeInvestor } from "./kycUtils.js";
 import { LogSplitterTransportOptions, isRangeError, logSplitterTransport } from "./logSplitterTransport.js";
 import { setLTZero, setLTs } from "./ltUtils.js";
-import { RestoreMidasIssuanceVaultPause, UnpauseMidasIssuanceVaultProps, unpauseMidasIssuanceVault } from "./midasUtils.js";
+import { MidasCreditSuite, RestoreMidasIssuanceVaultPause, UnpauseMidasIssuanceVaultProps, discoverMidasCreditSuites, discoverMidasGateways, discoverMidasMTokens, unpauseMidasIssuanceVault } from "./midasUtils.js";
 import { migrateFaucet } from "./migrateFaucet.js";
 import { IMinter } from "./mint/types.js";
 import { createMinter } from "./mint/factory.js";
@@ -26,4 +26,4 @@ import { EnableDSTokenBackDatingProps, RestoreDSTokenBackDating, claimDSToken, c
 import { httpTransportOptionsSchema } from "./transports.js";
 import { ONCHAIN_EXECUTION_ID_ADDRESS, VerifyTestnetParams, verifyTestnet } from "./verifyTestnet.js";
 import { MakePendingWithdrawalsClaimableOptions, makePendingWithdrawalsClaimable } from "./withdrawalUtils.js";
-export { AccountOpener, AccountOpenerOptions, AnvilActions, AnvilClient, AnvilClientConfig, AnvilDealParameters, AnvilNodeInfo, AnvilRPCSchema, CheckMulticallFn, Create2Deployer, Create2Parameters, DEFAULT_CREATE2_SALT, DetectedCall, EnableDSTokenBackDatingProps, EnsureExistsUsingPublicCreate2ReturnType, EthCallMethod, EthCallRequest, EthCallSpy, GetCreate2AddressParameters, GreenlistMidasGatewayProps, IMinter, type LogSplitterTransportOptions, MakePendingWithdrawalsClaimableOptions, NoAvailableTransportsError, ONCHAIN_EXECUTION_ID_ADDRESS, OpenAccountHumanizedPreview, OpenAccountResult, OpenAccountsResult, OpenTxRevertedError, PUBLIC_CREATE2_FACTORY, PoolDepositResult, ProviderConfig, ProviderStatus, RWAKycFailure, RegisterMidasInvestorProps, RegisterRWAInvestorProps, RegisterRWAInvestorResult, RegisterSecuritizeInvestorProps, ReplaceStorageParams, ResilientTransportOptions, RestoreDSTokenBackDating, RestoreMidasIssuanceVaultPause, RevolverTransport, RevolverTransportConfig, RevolverTransportValue, RpcErrorResult, RpcProvider, RpcResponse, RpcSuccessResult, SUPPORTED_RPC_PROVIDERS, SelectionStrategy, TargetAccount, UnpauseMidasIssuanceVaultProps, VerifyTestnetParams, 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, AccountOpenerOptions, AnvilActions, AnvilClient, AnvilClientConfig, AnvilDealParameters, AnvilNodeInfo, AnvilRPCSchema, CheckMulticallFn, Create2Deployer, Create2Parameters, DEFAULT_CREATE2_SALT, DEFAULT_MIDAS_ADMIN, DetectedCall, EnableDSTokenBackDatingProps, EnsureExistsUsingPublicCreate2ReturnType, EthCallMethod, EthCallRequest, EthCallSpy, GetCreate2AddressParameters, GreenlistMidasGatewayProps, IMinter, type LogSplitterTransportOptions, MakePendingWithdrawalsClaimableOptions, MidasCreditSuite, NoAvailableTransportsError, ONCHAIN_EXECUTION_ID_ADDRESS, OpenAccountHumanizedPreview, OpenAccountResult, OpenAccountsResult, OpenTxRevertedError, PUBLIC_CREATE2_FACTORY, PoolDepositResult, ProviderConfig, ProviderStatus, RWAKycFailure, RegisterMidasInvestorProps, RegisterRWAInvestorProps, RegisterRWAInvestorResult, RegisterSecuritizeInvestorProps, ReplaceStorageParams, ResilientTransportOptions, RestoreDSTokenBackDating, RestoreMidasIssuanceVaultPause, RevolverTransport, RevolverTransportConfig, RevolverTransportValue, RpcErrorResult, RpcProvider, RpcResponse, RpcSuccessResult, SUPPORTED_RPC_PROVIDERS, SelectionStrategy, TargetAccount, UnpauseMidasIssuanceVaultProps, VerifyTestnetParams, 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/types/dev/kycUtils.d.ts

@@ -2,32 +2,26 @@ import { ILogger } from "../onchain/types/logger.js";
 import { OnchainSDK } from "../onchain/OnchainSDK.js";
 import "../onchain/index.js";
 import { AnvilClient } from "./createAnvilClient.js";
-import { Address, Hex } from "viem";
+import { Address } from "viem";
 //#region src/dev/kycUtils.d.ts
-/**
- * Writes to a contract, mines a block and waits for the receipt
- */
-declare function writeAndWait(anvil: AnvilClient, params: Parameters<AnvilClient["writeContract"]>[0]): Promise<Hex>;
 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;
 }
+/**
+ * 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.
+ */
+declare function getSecuritizeAdmin(anvil: AnvilClient, token: Address, logger?: ILogger): Promise<Address>;
 /**
  * Registers a wallet as a Securitize investor (fake KYC) in the DS registry
  * service of a DSToken.
@@ -86,6 +80,11 @@ interface GreenlistMidasGatewayProps {
  * Greenlists an investor in the access control of a single Midas gateway
  */
 declare function greenlistMidasGateway(props: GreenlistMidasGatewayProps): Promise<void>;
+/**
+ * Midas access control admin on mainnet. Holds the admin role of the greenlist
+ * operator role.
+ */
+declare const DEFAULT_MIDAS_ADMIN: Address;
 interface RegisterRWAInvestorProps {
   anvil: AnvilClient;
   /**
@@ -97,16 +96,8 @@ interface RegisterRWAInvestorProps {
    */
   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;
-  /**
-   * Override midas access control admin address
+   * Midas access control admin, impersonated on the fork.
+   * Defaults to {@link DEFAULT_MIDAS_ADMIN}.
    */
   midasAdmin?: Address;
   logger?: ILogger;
@@ -138,4 +129,4 @@ interface RegisterRWAInvestorResult {
  */
 declare function registerRWAInvestor(props: RegisterRWAInvestorProps): Promise<RegisterRWAInvestorResult>;
 //#endregion
-export { GreenlistMidasGatewayProps, RWAKycFailure, RegisterMidasInvestorProps, RegisterRWAInvestorProps, RegisterRWAInvestorResult, RegisterSecuritizeInvestorProps, greenlistMidasGateway, registerMidasInvestor, registerRWAInvestor, registerSecuritizeInvestor, writeAndWait };
+export { DEFAULT_MIDAS_ADMIN, GreenlistMidasGatewayProps, RWAKycFailure, RegisterMidasInvestorProps, RegisterRWAInvestorProps, RegisterRWAInvestorResult, RegisterSecuritizeInvestorProps, getSecuritizeAdmin, greenlistMidasGateway, registerMidasInvestor, registerRWAInvestor, registerSecuritizeInvestor };

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

@@ -1,4 +1,5 @@
 import { ILogger } from "../onchain/types/logger.js";
+import { OnchainSDK } from "../onchain/OnchainSDK.js";
 import "../onchain/index.js";
 import { AnvilClient } from "./createAnvilClient.js";
 import { Address } from "viem";
@@ -22,14 +23,44 @@ interface UnpauseMidasIssuanceVaultProps {
  */
 type RestoreMidasIssuanceVaultPause = () => Promise<void>;
 /**
- * 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.
+ * 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
  * reverted by the callback, only the pause state is.
  */
 declare function unpauseMidasIssuanceVault(props: UnpauseMidasIssuanceVaultProps): Promise<RestoreMidasIssuanceVaultPause>;
+/**
+ * One Midas credit suite: a credit manager with a Midas gateway adapter,
+ * or with a Midas degen NFT when it has no such adapter.
+ */
+interface MidasCreditSuite {
+  creditManager: Address;
+  gateway: Address;
+  mToken: Address;
+}
+/**
+ * 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.
+ */
+declare function discoverMidasCreditSuites(sdk: OnchainSDK): Promise<MidasCreditSuite[]>;
+/**
+ * Gateways of the Midas credit suites of the loaded credit managers.
+ */
+declare function discoverMidasGateways(sdk: OnchainSDK): Promise<Address[]>;
+/**
+ * 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.
+ */
+declare function discoverMidasMTokens(sdk: OnchainSDK): Promise<Address[]>;
 //#endregion
-export { RestoreMidasIssuanceVaultPause, UnpauseMidasIssuanceVaultProps, unpauseMidasIssuanceVault };
+export { MidasCreditSuite, RestoreMidasIssuanceVaultPause, UnpauseMidasIssuanceVaultProps, discoverMidasCreditSuites, discoverMidasGateways, discoverMidasMTokens, unpauseMidasIssuanceVault };

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

@@ -1,12 +1,11 @@
 import { ILogger } from "../onchain/types/logger.js";
 import "../onchain/index.js";
 import { AnvilClient } from "./createAnvilClient.js";
-import { Address, Hex } from "viem";
+import { Address } from "viem";
 //#region src/dev/securitizeUtils.d.ts
 interface ClaimDSTokenProps {
   anvil: AnvilClient;
   investor: Address;
-  adminPrivateKey: Hex;
   /**
    * DSToken addresses
    */
@@ -24,11 +23,6 @@ type ClaimDSTokensProps = Omit<ClaimDSTokenProps, "token"> & {
 };
 interface EnableDSTokenBackDatingProps {
   anvil: AnvilClient;
-  /**
-   * Securitize DS admin with sufficient trust to call compliance setters
-   * (same key used for issueTokens / registerInvestor)
-   */
-  adminPrivateKey: Hex;
   /**
    * DSToken addresses whose compliance configuration should allow back-dating
    */
@@ -46,8 +40,8 @@ type RestoreDSTokenBackDating = () => Promise<void>;
  * honoured: DS protocol silently replaces it with `block.timestamp` otherwise,
  * and freshly minted tokens stay under lock-up.
  *
- * Must be signed by a DS admin with sufficient trust (same key as
- * `issueTokens` / registerInvestor); Ownable `owner()` alone is not enough.
+ * Impersonates the DS trust-service admin of each token. Ownable `owner()` of
+ * the compliance configuration service alone is not enough.
  *
  * The flag is only read while tokens are issued, so restoring it does not
  * re-lock tokens minted in the meantime.

package/dist/types/model/errors/index.d.ts

@@ -1,7 +1,7 @@
 import { IGearboxError } from "./base.js";
 import { CreditAccountFrozenError, LiquidatorNotEligibleError, NotEmergencyLiquidatorError, creditAccountFrozen, liquidatorNotEligible, notEmergencyLiquidator } from "./liquidation-errors.js";
-import { BorrowLimitCause, CreditManagerPausedError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientAllowanceError, InsufficientBalanceError, InsufficientCollateralError, InsufficientPoolLiquidityError, LeverageOutOfRangeError, MarketExpiredError, PoolPausedError, PoolSunsetError, QuotaCountExceededError, QuotaLimitReachedError, RWAOpenRequirementsError, creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, marketExpired, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, rwaOpenRequirementsNotMet } from "./operation-errors.js";
+import { AccountNotMidasGreenlistedError, BorrowLimitCause, CreditManagerPausedError, DebtOutOfRangeError, ForbiddenTokenError, InsufficientAllowanceError, InsufficientBalanceError, InsufficientCollateralError, InsufficientPoolLiquidityError, LeverageOutOfRangeError, MarketExpiredError, PoolPausedError, PoolSunsetError, QuotaCountExceededError, QuotaLimitReachedError, RWAOpenRequirementsError, ReservePriceLimitedError, accountNotMidasGreenlisted, creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, marketExpired, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, reservePriceLimited, rwaOpenRequirementsNotMet } from "./operation-errors.js";
 import { UnpriceableTokenError, unpriceableTokenError } from "./oracle-errors.js";
 import { CreditAccountNotEmptyError, CreditAccountNotFoundError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, UnexpectedFailureError, UnsupportedCollateralTokenError, UnsupportedTokenPairError, WithdrawalInProgressError, creditAccountNotEmpty, creditAccountNotFound, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, unexpectedFailure, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress } from "./prepare-errors.js";
 import { InvalidDelayedIntentError, MalformedTransactionError, PoolOperationPreviewError, UnsupportedOperationError, UnsupportedPoolFunctionError, UnsupportedTargetError, UnsupportedZapperFunctionError, malformedTransaction } from "./preview-errors.js";
-export { BorrowLimitCause, CreditAccountFrozenError, CreditAccountNotEmptyError, CreditAccountNotFoundError, CreditManagerPausedError, DebtOutOfRangeError, ForbiddenTokenError, IGearboxError, InsufficientAllowanceError, InsufficientBalanceError, InsufficientCollateralError, InsufficientPoolLiquidityError, InvalidDelayedIntentError, LeverageOutOfRangeError, LiquidatorNotEligibleError, MalformedTransactionError, MarketExpiredError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, NotEmergencyLiquidatorError, PoolOperationPreviewError, PoolPausedError, PoolSunsetError, QuotaCountExceededError, QuotaLimitReachedError, RWAOpenRequirementsError, UnexpectedFailureError, UnpriceableTokenError, UnsupportedCollateralTokenError, UnsupportedOperationError, UnsupportedPoolFunctionError, UnsupportedTargetError, UnsupportedTokenPairError, UnsupportedZapperFunctionError, WithdrawalInProgressError, creditAccountFrozen, creditAccountNotEmpty, creditAccountNotFound, creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, liquidatorNotEligible, malformedTransaction, marketExpired, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, notEmergencyLiquidator, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, rwaOpenRequirementsNotMet, unexpectedFailure, unpriceableTokenError, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress };
+export { AccountNotMidasGreenlistedError, BorrowLimitCause, CreditAccountFrozenError, CreditAccountNotEmptyError, CreditAccountNotFoundError, CreditManagerPausedError, DebtOutOfRangeError, ForbiddenTokenError, IGearboxError, InsufficientAllowanceError, InsufficientBalanceError, InsufficientCollateralError, InsufficientPoolLiquidityError, InvalidDelayedIntentError, LeverageOutOfRangeError, LiquidatorNotEligibleError, MalformedTransactionError, MarketExpiredError, MultipleDelayedWithdrawalsError, NoDelayedRouteError, NoRecordedIntentError, NoStrategyTargetCollateralError, NotEmergencyLiquidatorError, PoolOperationPreviewError, PoolPausedError, PoolSunsetError, QuotaCountExceededError, QuotaLimitReachedError, RWAOpenRequirementsError, ReservePriceLimitedError, UnexpectedFailureError, UnpriceableTokenError, UnsupportedCollateralTokenError, UnsupportedOperationError, UnsupportedPoolFunctionError, UnsupportedTargetError, UnsupportedTokenPairError, UnsupportedZapperFunctionError, WithdrawalInProgressError, accountNotMidasGreenlisted, creditAccountFrozen, creditAccountNotEmpty, creditAccountNotFound, creditManagerPaused, debtOutOfRange, forbiddenToken, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, leverageOutOfRange, liquidatorNotEligible, malformedTransaction, marketExpired, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, notEmergencyLiquidator, poolPaused, poolSunset, quotaCountExceeded, quotaLimitReached, reservePriceLimited, rwaOpenRequirementsNotMet, unexpectedFailure, unpriceableTokenError, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress };