@gearbox-protocol/sdk 14.12.0-next.57 → 14.12.0-next.59

package/dist/esm/abi/IWithdrawalCompressorV313.js

@@ -75,6 +75,11 @@ const iWithdrawalCompressorV313Abi = [
 						internalType: "bytes"
 					}]
 				},
+				{
+					name: "redeemer",
+					type: "address",
+					internalType: "address"
+				},
 				{
 					name: "extraData",
 					type: "bytes",
@@ -123,6 +128,11 @@ const iWithdrawalCompressorV313Abi = [
 					type: "uint256",
 					internalType: "uint256"
 				},
+				{
+					name: "redeemer",
+					type: "address",
+					internalType: "address"
+				},
 				{
 					name: "extraData",
 					type: "bytes",
@@ -136,9 +146,9 @@ const iWithdrawalCompressorV313Abi = [
 		type: "function",
 		name: "getExternalAccountCurrentWithdrawals",
 		inputs: [{
-			name: "withdrawalToken",
-			type: "address",
-			internalType: "address"
+			name: "withdrawalTokens",
+			type: "address[]",
+			internalType: "address[]"
 		}, {
 			name: "account",
 			type: "address",
@@ -200,6 +210,11 @@ const iWithdrawalCompressorV313Abi = [
 						internalType: "bytes"
 					}]
 				},
+				{
+					name: "redeemer",
+					type: "address",
+					internalType: "address"
+				},
 				{
 					name: "extraData",
 					type: "bytes",
@@ -248,6 +263,11 @@ const iWithdrawalCompressorV313Abi = [
 					type: "uint256",
 					internalType: "uint256"
 				},
+				{
+					name: "redeemer",
+					type: "address",
+					internalType: "address"
+				},
 				{
 					name: "extraData",
 					type: "bytes",
@@ -261,9 +281,9 @@ const iWithdrawalCompressorV313Abi = [
 		type: "function",
 		name: "getExternalAccountCurrentWithdrawals",
 		inputs: [{
-			name: "withdrawalTokens",
-			type: "address[]",
-			internalType: "address[]"
+			name: "withdrawalToken",
+			type: "address",
+			internalType: "address"
 		}, {
 			name: "account",
 			type: "address",
@@ -325,6 +345,11 @@ const iWithdrawalCompressorV313Abi = [
 						internalType: "bytes"
 					}]
 				},
+				{
+					name: "redeemer",
+					type: "address",
+					internalType: "address"
+				},
 				{
 					name: "extraData",
 					type: "bytes",
@@ -373,6 +398,11 @@ const iWithdrawalCompressorV313Abi = [
 					type: "uint256",
 					internalType: "uint256"
 				},
+				{
+					name: "redeemer",
+					type: "address",
+					internalType: "address"
+				},
 				{
 					name: "extraData",
 					type: "bytes",
@@ -382,36 +412,6 @@ const iWithdrawalCompressorV313Abi = [
 		}],
 		stateMutability: "view"
 	},
-	{
-		type: "function",
-		name: "getWithdrawalStatus",
-		inputs: [{
-			name: "redeemer",
-			type: "address",
-			internalType: "address"
-		}],
-		outputs: [{
-			name: "",
-			type: "uint8",
-			internalType: "enum WithdrawalStatus"
-		}],
-		stateMutability: "view"
-	},
-	{
-		type: "function",
-		name: "getWithdrawalStatus",
-		inputs: [{
-			name: "redeemers",
-			type: "address[]",
-			internalType: "address[]"
-		}],
-		outputs: [{
-			name: "",
-			type: "uint8[]",
-			internalType: "enum WithdrawalStatus[]"
-		}],
-		stateMutability: "view"
-	},
 	{
 		type: "function",
 		name: "getWithdrawableAssets",
@@ -558,11 +558,6 @@ const iWithdrawalCompressorV313Abi = [
 				type: "address",
 				internalType: "address"
 			},
-			{
-				name: "withdrawalToken",
-				type: "address",
-				internalType: "address"
-			},
 			{
 				name: "amount",
 				type: "uint256",
@@ -643,6 +638,11 @@ const iWithdrawalCompressorV313Abi = [
 				type: "address",
 				internalType: "address"
 			},
+			{
+				name: "withdrawalToken",
+				type: "address",
+				internalType: "address"
+			},
 			{
 				name: "amount",
 				type: "uint256",
@@ -709,6 +709,36 @@ const iWithdrawalCompressorV313Abi = [
 		}],
 		stateMutability: "view"
 	},
+	{
+		type: "function",
+		name: "getWithdrawalStatus",
+		inputs: [{
+			name: "redeemers",
+			type: "address[]",
+			internalType: "address[]"
+		}],
+		outputs: [{
+			name: "",
+			type: "uint8[]",
+			internalType: "enum WithdrawalStatus[]"
+		}],
+		stateMutability: "view"
+	},
+	{
+		type: "function",
+		name: "getWithdrawalStatus",
+		inputs: [{
+			name: "redeemer",
+			type: "address",
+			internalType: "address"
+		}],
+		outputs: [{
+			name: "",
+			type: "uint8",
+			internalType: "enum WithdrawalStatus"
+		}],
+		stateMutability: "view"
+	},
 	{
 		type: "function",
 		name: "version",

package/dist/esm/dev/claimDSToken.js

@@ -2,9 +2,88 @@ import { OnchainSDK } from "../sdk/OnchainSDK.js";
 import "../sdk/index.js";
 import { iDSTokenAbi } from "../abi/rwa/iDSToken.js";
 import { registerSecuritizeInvestor, writeAndWait } from "./kycUtils.js";
-import { erc20Abi } from "viem";
+import { erc20Abi, isAddressEqual, parseAbi, zeroAddress } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 //#region src/dev/claimDSToken.ts
+/**
+* `COMPLIANCE_CONFIGURATION_SERVICE` id in the DS protocol service registry
+*/
+const COMPLIANCE_CONFIGURATION_SERVICE = 256n;
+const iDSComplianceConfigurationServiceAbi = parseAbi(["function getUSLockPeriod() external view returns (uint256)", "function getNonUSLockPeriod() external view returns (uint256)"]);
+/**
+* Returns issuance time that is old enough for the issued tokens to be past
+* both US and non-US compliance lock periods, or `undefined` when the token
+* has no compliance configuration service (e.g. MockDSToken)
+*/
+async function getUnlockedIssuanceTime({ anvil, token, logger }) {
+	try {
+		const complianceConfiguration = await anvil.readContract({
+			address: token,
+			abi: iDSTokenAbi,
+			functionName: "getDSService",
+			args: [COMPLIANCE_CONFIGURATION_SERVICE]
+		});
+		if (isAddressEqual(complianceConfiguration, zeroAddress)) return;
+		const [usLockPeriod, nonUSLockPeriod] = await anvil.multicall({
+			contracts: [{
+				address: complianceConfiguration,
+				abi: iDSComplianceConfigurationServiceAbi,
+				functionName: "getUSLockPeriod"
+			}, {
+				address: complianceConfiguration,
+				abi: iDSComplianceConfigurationServiceAbi,
+				functionName: "getNonUSLockPeriod"
+			}],
+			allowFailure: false
+		});
+		const lockPeriod = usLockPeriod > nonUSLockPeriod ? usLockPeriod : nonUSLockPeriod;
+		const { timestamp } = await anvil.getBlock();
+		logger?.debug(`Lock periods: US ${usLockPeriod}, non-US ${nonUSLockPeriod} (compliance configuration service ${complianceConfiguration})`);
+		return timestamp > lockPeriod ? timestamp - lockPeriod : 0n;
+	} catch (e) {
+		logger?.debug(`Failed to get compliance lock periods: ${e}`);
+		return;
+	}
+}
+/**
+* Issues tokens to investor via `issueTokensCustom` with issuance time that
+* bypasses compliance lock periods, falling back to plain `issueTokens` for
+* tokens that do not support it (e.g. MockDSToken)
+*
+* ACRED tokens do not have this lock, but STAC has
+*/
+async function issueDSTokens(props) {
+	const { anvil, account, token, investor, amount, logger } = props;
+	const issuanceTime = await getUnlockedIssuanceTime(props);
+	if (issuanceTime !== void 0) try {
+		return await writeAndWait(anvil, {
+			account,
+			chain: anvil.chain,
+			address: token,
+			abi: iDSTokenAbi,
+			functionName: "issueTokensCustom",
+			args: [
+				investor,
+				amount,
+				issuanceTime,
+				0n,
+				"",
+				0n
+			]
+		});
+	} catch (e) {
+		logger?.debug(`issueTokensCustom failed: ${e}`);
+	}
+	logger?.debug("Falling back to issueTokens");
+	return writeAndWait(anvil, {
+		account,
+		chain: anvil.chain,
+		address: token,
+		abi: iDSTokenAbi,
+		functionName: "issueTokens",
+		args: [investor, amount]
+	});
+}
 async function claimDSToken(props) {
 	const { anvil, investor, adminPrivateKey, token, marketConfigurators, rwaFactories, usdAmount: usdAmountProp = "100000" } = props;
 	const account = privateKeyToAccount(adminPrivateKey);
@@ -35,13 +114,13 @@ async function claimDSToken(props) {
 		logger
 	});
 	logger?.debug(`Issuing ${amount} tokens to ${investor}...`);
-	const mintHash = await writeAndWait(anvil, {
+	const mintHash = await issueDSTokens({
+		anvil,
 		account,
-		chain: anvil.chain,
-		address: token,
-		abi: iDSTokenAbi,
-		functionName: "issueTokens",
-		args: [investor, amount]
+		token,
+		investor,
+		amount,
+		logger
 	});
 	logger?.debug(`Done! tx: ${mintHash}`);
 	const balance = await anvil.readContract({

package/dist/esm/dev/withdrawalUtils.js

@@ -11,23 +11,56 @@ import { erc20Abi, hexToString, parseAbi, parseEther } from "viem";
 const MIDAS_VAULT_ADMIN = "0x2ACB4BdCbEf02f81BF713b696Ac26390d7f79A12";
 const iVersionAbi = parseAbi(["function contractType() external view returns (bytes32)"]);
 /**
+* Common part of Midas and Securitize redeemers
+*/
+const iRedeemerAbi = parseAbi(["function gateway() external view returns (address)"]);
+/**
 * Functions of external Midas redemption vault contract that are not declared
 * in integrations-v3's IMidasRedemptionVault interface
 */
 const iMidasRedemptionVaultExtAbi = parseAbi(["function requestRedeemer() external view returns (address)", "function safeApproveRequest(uint256 requestId, uint256 newMTokenRate) external"]);
 /**
-* Makes pending delayed withdrawals of a credit account claimable on an anvil fork.
+* Makes pending delayed withdrawals claimable on an anvil fork.
+*
+* Accepts either a credit account, in which case all its pending withdrawals are
+* fulfilled, or a single redeemer. The latter is the only way to reach redeemers
+* that were transferred away from a credit account during a liquidation: they are
+* dropped from the gateway's pending sets, so the compressor no longer reports them.
 *
 * Replicates the `_fulfillWithdrawal` logic from periphery-v3 Foundry tests
 * (WithdrawalCompressorMidasRWA.t.sol, WithdrawalCompressorSecuritize.t.sol)
 * using anvil cheatcodes. Assumes the version 313 of WithdrawalCompressor.
 *
 * @param anvil
-* @param creditAccount
-* @param logger
+* @param address credit account or redeemer
+* @param options
+*/
+async function makePendingWithdrawalsClaimable(anvil, address, options) {
+	const { logger } = options || {};
+	if (await getContractType(anvil, address) === "CREDIT_ACCOUNT") await fulfillCreditAccountWithdrawals(anvil, address, logger);
+	else await fulfillRedeemer(anvil, address, logger);
+}
+/**
+* Returns the decoded `contractType` of a contract, or `undefined` when it does
+* not implement it (redeemers, for example)
+*/
+async function getContractType(anvil, address) {
+	try {
+		const cType = await anvil.readContract({
+			address,
+			abi: iVersionAbi,
+			functionName: "contractType"
+		});
+		return hexToString(cType, { size: 32 });
+	} catch {
+		return;
+	}
+}
+/**
+* Fulfills all pending withdrawals of a credit account, as reported by the
+* withdrawal compressor
 */
-async function makePendingWithdrawalsClaimable(anvil, creditAccount, options) {
-	const { logger, timeWarp = false } = options || {};
+async function fulfillCreditAccountWithdrawals(anvil, creditAccount, logger) {
 	const compressor = getWithdrawalCompressorAddress(getNetworkType(anvil.chain.id));
 	if (!compressor) throw new Error(`no withdrawal compressor for chain ${anvil.chain.id}`);
 	if (compressor.version !== 313) logger?.warn(`withdrawal compressor version is ${compressor.version}, this helper assumes 313`);
@@ -39,19 +72,8 @@ async function makePendingWithdrawalsClaimable(anvil, creditAccount, options) {
 	});
 	logger?.debug(`found ${pending.length} pending withdrawals for credit account ${creditAccount}`);
 	if (pending.length === 0) return;
-	if (timeWarp) {
-		const maxClaimableAt = pending.reduce((max, p) => p.claimableAt > max ? p.claimableAt : max, 0n);
-		if (maxClaimableAt > 0n) {
-			logger?.debug(`warping time to ${maxClaimableAt + 1n}`);
-			await anvil.evmMineDetailed(maxClaimableAt + 1n);
-		}
-	}
 	for (const w of pending) {
-		const cType = hexToString(await anvil.readContract({
-			address: w.withdrawalPhantomToken,
-			abi: iVersionAbi,
-			functionName: "contractType"
-		}), { size: 32 });
+		const cType = await getContractType(anvil, w.withdrawalPhantomToken);
 		logger?.debug(`fulfilling withdrawal in phantom token ${w.withdrawalPhantomToken} with contract type ${cType}`);
 		switch (cType) {
 			case "PHANTOM_TOKEN::MIDAS_REDEMPTION":
@@ -60,7 +82,7 @@ async function makePendingWithdrawalsClaimable(anvil, creditAccount, options) {
 			case "PHANTOM_TOKEN::SECURITIZE_RD":
 				await fulfillSecuritizeWithdrawal(anvil, creditAccount, w.withdrawalPhantomToken, logger);
 				break;
-			default: logger?.warn(`unsupported withdrawal phantom token type ${cType}, only time warp was applied`);
+			default: logger?.warn(`unsupported withdrawal phantom token type ${cType}, skipping`);
 		}
 	}
 	const [claimableAfter, pendingAfter] = await anvil.readContract({
@@ -72,29 +94,72 @@ async function makePendingWithdrawalsClaimable(anvil, creditAccount, options) {
 	logger?.debug(`after fulfillment: ${claimableAfter.length} claimable, ${pendingAfter.length} still pending withdrawals`);
 }
 /**
-* Fulfills a Midas redemption request:
-* funds the vault's request redeemer with tokenOut and approves the request
-* on the Midas redemption vault on behalf of the vault admin
+* Fulfills the redemption request held by a single redeemer, dispatching on the
+* type of the gateway that deployed it
+*/
+async function fulfillRedeemer(anvil, redeemer, logger) {
+	const gateway = await anvil.readContract({
+		address: redeemer,
+		abi: iRedeemerAbi,
+		functionName: "gateway"
+	});
+	const cType = await getContractType(anvil, gateway);
+	logger?.debug(`fulfilling redeemer ${redeemer} of gateway ${gateway} with contract type ${cType}`);
+	switch (cType) {
+		case "GATEWAY::MIDAS":
+			await fulfillMidasRedeemer(anvil, redeemer, logger);
+			break;
+		case "GATEWAY::SECURITIZE_REDEMPTION":
+			await fulfillSecuritizeRedeemer(anvil, redeemer, logger);
+			break;
+		default: throw new Error(`unsupported gateway type ${cType} of redeemer ${redeemer}`);
+	}
+}
+/**
+* Fulfills all pending Midas redemption requests of a credit account
 */
 async function fulfillMidasWithdrawal(anvil, creditAccount, withdrawalPhantomToken, logger) {
-	const [gateway, tokenOut] = await anvil.multicall({
-		allowFailure: false,
-		contracts: [{
-			address: withdrawalPhantomToken,
-			abi: midasRedemptionVaultPhantomTokenAbi,
-			functionName: "gateway"
-		}, {
-			address: withdrawalPhantomToken,
-			abi: midasRedemptionVaultPhantomTokenAbi,
-			functionName: "underlying"
-		}]
+	const gateway = await anvil.readContract({
+		address: withdrawalPhantomToken,
+		abi: midasRedemptionVaultPhantomTokenAbi,
+		functionName: "gateway"
 	});
-	const midasRedemptionVault = await anvil.readContract({
+	const redeemers = await anvil.readContract({
 		address: gateway,
 		abi: midasGatewayAbi,
-		functionName: "midasRedemptionVault"
+		functionName: "pendingRedeemers",
+		args: [creditAccount]
+	});
+	logger?.debug(`midas: gateway ${gateway}, ${redeemers.length} pending redeemers`);
+	for (const redeemer of redeemers) await fulfillMidasRedeemer(anvil, redeemer, logger);
+}
+/**
+* Fulfills a single Midas redemption request:
+* funds the vault's request redeemer with tokenOut and approves the request
+* on the Midas redemption vault on behalf of the vault admin
+*/
+async function fulfillMidasRedeemer(anvil, redeemer, logger) {
+	const [midasRedemptionVault, tokenOut, requestId] = await anvil.multicall({
+		allowFailure: false,
+		contracts: [
+			{
+				address: redeemer,
+				abi: midasRedeemerAbi,
+				functionName: "midasRedemptionVault"
+			},
+			{
+				address: redeemer,
+				abi: midasRedeemerAbi,
+				functionName: "quoteToken"
+			},
+			{
+				address: redeemer,
+				abi: midasRedeemerAbi,
+				functionName: "requestId"
+			}
+		]
 	});
-	const [mTokenDataFeed, requestRedeemer, tokenOutDecimals, redeemers] = await anvil.multicall({
+	const [mTokenDataFeed, requestRedeemer, tokenOutDecimals] = await anvil.multicall({
 		allowFailure: false,
 		contracts: [
 			{
@@ -111,12 +176,6 @@ async function fulfillMidasWithdrawal(anvil, creditAccount, withdrawalPhantomTok
 				address: tokenOut,
 				abi: erc20Abi,
 				functionName: "decimals"
-			},
-			{
-				address: gateway,
-				abi: midasGatewayAbi,
-				functionName: "pendingRedeemers",
-				args: [creditAccount]
 			}
 		]
 	});
@@ -125,63 +184,48 @@ async function fulfillMidasWithdrawal(anvil, creditAccount, withdrawalPhantomTok
 		abi: iMidasDataFeedAbi,
 		functionName: "getDataInBase18"
 	});
-	logger?.debug(`midas: gateway ${gateway}, vault ${midasRedemptionVault}, tokenOut ${tokenOut}, mToken rate ${mTokenRate}, ${redeemers.length} pending redeemers`);
-	for (const redeemer of redeemers) {
-		const topUp = 1000000n * 10n ** BigInt(tokenOutDecimals);
-		const requestRedeemerBalance = await anvil.readContract({
-			address: tokenOut,
-			abi: erc20Abi,
-			functionName: "balanceOf",
-			args: [requestRedeemer]
-		});
-		logger?.debug(`midas: dealing ${topUp} of tokenOut ${tokenOut} to request redeemer ${requestRedeemer}`);
-		await anvil.deal({
-			erc20: tokenOut,
-			account: requestRedeemer,
-			amount: requestRedeemerBalance + topUp
-		});
-		const requestId = await anvil.readContract({
-			address: redeemer,
-			abi: midasRedeemerAbi,
-			functionName: "requestId"
-		});
-		logger?.debug(`midas: approving request ${requestId} of redeemer ${redeemer} as vault admin ${MIDAS_VAULT_ADMIN}`);
-		await anvil.impersonateAccount({ address: MIDAS_VAULT_ADMIN });
-		await anvil.setBalance({
-			address: MIDAS_VAULT_ADMIN,
-			value: parseEther("100")
-		});
-		const hash = await anvil.writeContract({
-			chain: anvil.chain,
-			address: midasRedemptionVault,
-			account: MIDAS_VAULT_ADMIN,
-			abi: iMidasRedemptionVaultExtAbi,
-			functionName: "safeApproveRequest",
-			args: [requestId, mTokenRate]
-		});
-		if ((await anvil.waitForTransactionReceipt({
-			hash,
-			pollingInterval: 100
-		})).status !== "success") throw new Error(`midas: safeApproveRequest tx ${hash} reverted`);
-		await anvil.stopImpersonatingAccount({ address: MIDAS_VAULT_ADMIN });
-	}
+	logger?.debug(`midas: redeemer ${redeemer}, vault ${midasRedemptionVault}, tokenOut ${tokenOut}, mToken rate ${mTokenRate}`);
+	const topUp = 1000000n * 10n ** BigInt(tokenOutDecimals);
+	const requestRedeemerBalance = await anvil.readContract({
+		address: tokenOut,
+		abi: erc20Abi,
+		functionName: "balanceOf",
+		args: [requestRedeemer]
+	});
+	logger?.debug(`midas: dealing ${topUp} of tokenOut ${tokenOut} to request redeemer ${requestRedeemer}`);
+	await anvil.deal({
+		erc20: tokenOut,
+		account: requestRedeemer,
+		amount: requestRedeemerBalance + topUp
+	});
+	logger?.debug(`midas: approving request ${requestId} of redeemer ${redeemer} as vault admin ${MIDAS_VAULT_ADMIN}`);
+	await anvil.impersonateAccount({ address: MIDAS_VAULT_ADMIN });
+	await anvil.setBalance({
+		address: MIDAS_VAULT_ADMIN,
+		value: parseEther("100")
+	});
+	const hash = await anvil.writeContract({
+		chain: anvil.chain,
+		address: midasRedemptionVault,
+		account: MIDAS_VAULT_ADMIN,
+		abi: iMidasRedemptionVaultExtAbi,
+		functionName: "safeApproveRequest",
+		args: [requestId, mTokenRate]
+	});
+	if ((await anvil.waitForTransactionReceipt({
+		hash,
+		pollingInterval: 100
+	})).status !== "success") throw new Error(`midas: safeApproveRequest tx ${hash} reverted`);
+	await anvil.stopImpersonatingAccount({ address: MIDAS_VAULT_ADMIN });
 }
 /**
-* Fulfills a Securitize redemption request:
-* funds the first redeemer of the credit account with stablecoins
+* Fulfills all unclaimed Securitize redemption requests of a credit account
 */
 async function fulfillSecuritizeWithdrawal(anvil, creditAccount, withdrawalPhantomToken, logger) {
-	const [redemptionGateway, stableCoinToken] = await anvil.multicall({
-		allowFailure: false,
-		contracts: [{
-			address: withdrawalPhantomToken,
-			abi: securitizeRedemptionPhantomTokenAbi,
-			functionName: "redemptionGateway"
-		}, {
-			address: withdrawalPhantomToken,
-			abi: securitizeRedemptionPhantomTokenAbi,
-			functionName: "stableCoinToken"
-		}]
+	const redemptionGateway = await anvil.readContract({
+		address: withdrawalPhantomToken,
+		abi: securitizeRedemptionPhantomTokenAbi,
+		functionName: "redemptionGateway"
 	});
 	const redeemers = await anvil.readContract({
 		address: redemptionGateway,
@@ -189,36 +233,46 @@ async function fulfillSecuritizeWithdrawal(anvil, creditAccount, withdrawalPhant
 		functionName: "getUnclaimedRedeemers",
 		args: [creditAccount]
 	});
-	logger?.debug(`securitize: gateway ${redemptionGateway}, stablecoin ${stableCoinToken}, ${redeemers.length} unclaimed redeemers`);
+	logger?.debug(`securitize: gateway ${redemptionGateway}, ${redeemers.length} unclaimed redeemers`);
 	if (redeemers.length === 0) {
 		logger?.warn(`securitize: no unclaimed redeemers found for credit account ${creditAccount}`);
 		return;
 	}
-	for (const redeemer of redeemers) {
-		const [redemptionValue, redeemerBalance] = await anvil.multicall({
-			allowFailure: false,
-			contracts: [{
-				address: redeemer,
-				abi: securitizeRedeemerAbi,
-				functionName: "getCurrentRedemptionValue"
-			}, {
-				address: stableCoinToken,
-				abi: erc20Abi,
-				functionName: "balanceOf",
-				args: [redeemer]
-			}]
-		});
-		if (redemptionValue === 0n) {
-			logger?.debug(`securitize: skipping redeemer ${redeemer} with zero redemption value`);
-			continue;
-		}
-		logger?.debug(`securitize: dealing ${redemptionValue} of stablecoin ${stableCoinToken} to redeemer ${redeemer}`);
-		await anvil.deal({
-			erc20: stableCoinToken,
-			account: redeemer,
-			amount: redeemerBalance + redemptionValue
-		});
+	for (const redeemer of redeemers) await fulfillSecuritizeRedeemer(anvil, redeemer, logger);
+}
+/**
+* Fulfills a single Securitize redemption request:
+* funds the redeemer with stablecoins
+*/
+async function fulfillSecuritizeRedeemer(anvil, redeemer, logger) {
+	const [stableCoinToken, redemptionValue] = await anvil.multicall({
+		allowFailure: false,
+		contracts: [{
+			address: redeemer,
+			abi: securitizeRedeemerAbi,
+			functionName: "stableCoinToken"
+		}, {
+			address: redeemer,
+			abi: securitizeRedeemerAbi,
+			functionName: "getCurrentRedemptionValue"
+		}]
+	});
+	if (redemptionValue === 0n) {
+		logger?.debug(`securitize: skipping redeemer ${redeemer} with zero redemption value`);
+		return;
 	}
+	const redeemerBalance = await anvil.readContract({
+		address: stableCoinToken,
+		abi: erc20Abi,
+		functionName: "balanceOf",
+		args: [redeemer]
+	});
+	logger?.debug(`securitize: dealing ${redemptionValue} of stablecoin ${stableCoinToken} to redeemer ${redeemer}`);
+	await anvil.deal({
+		erc20: stableCoinToken,
+		account: redeemer,
+		amount: redeemerBalance + redemptionValue
+	});
 }
 //#endregion
 export { makePendingWithdrawalsClaimable };