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

package/dist/cjs/dev/withdrawalUtils.js

@@ -12,23 +12,56 @@ let viem = require("viem");
 const MIDAS_VAULT_ADMIN = "0x2ACB4BdCbEf02f81BF713b696Ac26390d7f79A12";
 const iVersionAbi = (0, viem.parseAbi)(["function contractType() external view returns (bytes32)"]);
 /**
+* Common part of Midas and Securitize redeemers
+*/
+const iRedeemerAbi = (0, viem.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 = (0, viem.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 (0, viem.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 = require_sdk_accounts_withdrawal_compressor_addresses.getWithdrawalCompressorAddress(require_sdk_chain_chains.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`);
@@ -40,19 +73,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 = (0, viem.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":
@@ -61,7 +83,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({
@@ -73,29 +95,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: require_dev_withdrawalAbi.midasRedemptionVaultPhantomTokenAbi,
-			functionName: "gateway"
-		}, {
-			address: withdrawalPhantomToken,
-			abi: require_dev_withdrawalAbi.midasRedemptionVaultPhantomTokenAbi,
-			functionName: "underlying"
-		}]
+	const gateway = await anvil.readContract({
+		address: withdrawalPhantomToken,
+		abi: require_dev_withdrawalAbi.midasRedemptionVaultPhantomTokenAbi,
+		functionName: "gateway"
 	});
-	const midasRedemptionVault = await anvil.readContract({
+	const redeemers = await anvil.readContract({
 		address: gateway,
 		abi: require_dev_withdrawalAbi.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: require_dev_withdrawalAbi.midasRedeemerAbi,
+				functionName: "midasRedemptionVault"
+			},
+			{
+				address: redeemer,
+				abi: require_dev_withdrawalAbi.midasRedeemerAbi,
+				functionName: "quoteToken"
+			},
+			{
+				address: redeemer,
+				abi: require_dev_withdrawalAbi.midasRedeemerAbi,
+				functionName: "requestId"
+			}
+		]
 	});
-	const [mTokenDataFeed, requestRedeemer, tokenOutDecimals, redeemers] = await anvil.multicall({
+	const [mTokenDataFeed, requestRedeemer, tokenOutDecimals] = await anvil.multicall({
 		allowFailure: false,
 		contracts: [
 			{
@@ -112,12 +177,6 @@ async function fulfillMidasWithdrawal(anvil, creditAccount, withdrawalPhantomTok
 				address: tokenOut,
 				abi: viem.erc20Abi,
 				functionName: "decimals"
-			},
-			{
-				address: gateway,
-				abi: require_dev_withdrawalAbi.midasGatewayAbi,
-				functionName: "pendingRedeemers",
-				args: [creditAccount]
 			}
 		]
 	});
@@ -126,63 +185,48 @@ async function fulfillMidasWithdrawal(anvil, creditAccount, withdrawalPhantomTok
 		abi: require_dev_withdrawalAbi.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: viem.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: require_dev_withdrawalAbi.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: (0, viem.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: viem.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: (0, viem.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: require_dev_withdrawalAbi.securitizeRedemptionPhantomTokenAbi,
-			functionName: "redemptionGateway"
-		}, {
-			address: withdrawalPhantomToken,
-			abi: require_dev_withdrawalAbi.securitizeRedemptionPhantomTokenAbi,
-			functionName: "stableCoinToken"
-		}]
+	const redemptionGateway = await anvil.readContract({
+		address: withdrawalPhantomToken,
+		abi: require_dev_withdrawalAbi.securitizeRedemptionPhantomTokenAbi,
+		functionName: "redemptionGateway"
 	});
 	const redeemers = await anvil.readContract({
 		address: redemptionGateway,
@@ -190,36 +234,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: require_dev_withdrawalAbi.securitizeRedeemerAbi,
-				functionName: "getCurrentRedemptionValue"
-			}, {
-				address: stableCoinToken,
-				abi: viem.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: require_dev_withdrawalAbi.securitizeRedeemerAbi,
+			functionName: "stableCoinToken"
+		}, {
+			address: redeemer,
+			abi: require_dev_withdrawalAbi.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: viem.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
 exports.makePendingWithdrawalsClaimable = makePendingWithdrawalsClaimable;

package/dist/cjs/sdk/accounts/liquidations/LiquidationsService.js

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_abi_ILiquidationCompressorV313 = require("../../../abi/ILiquidationCompressorV313.js");
-const require_abi_iPhantomToken = require("../../../abi/iPhantomToken.js");
 const require_sdk_utils_AddressSet = require("../../utils/AddressSet.js");
+const require_sdk_utils_bytes32ToString = require("../../utils/bytes32ToString.js");
 const require_sdk_constants_addresses = require("../../constants/addresses.js");
 const require_sdk_constants_math = require("../../constants/math.js");
 require("../../constants/index.js");
@@ -16,7 +16,6 @@ const require_sdk_market_rwa_securitize_constants = require("../../market/rwa/se
 const require_sdk_market_rwa_securitize_SecuritizeLiquidatorContract = require("../../market/rwa/securitize/SecuritizeLiquidatorContract.js");
 require("../../market/rwa/securitize/index.js");
 const require_sdk_accounts_liquidations_constants = require("./constants.js");
-const require_abi_rwa_iRWAGateway = require("../../../abi/rwa/iRWAGateway.js");
 const require_sdk_accounts_liquidations_helpers = require("./helpers.js");
 //#region src/sdk/accounts/liquidations/LiquidationsService.ts
 /**
@@ -66,20 +65,21 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 		return {
 			...account,
 			repaymentAmount: {
-				token: account.totalValue.token,
-				balance: data.requiredUnderlyingAmount
+				token: require_sdk_utils_hex.hexEq(data.requiredToken, "0x0000000000000000000000000000000000000000") ? account.totalValue.token : data.requiredToken,
+				balance: data.requiredAmount
 			},
 			isDelayed: data.expectedOutputs.some((o) => o.delayed),
 			receivedAssets: require_sdk_accounts_liquidations_helpers.toReceivedAssets(data.expectedOutputs),
 			isLiquidatorEligible: data.isLiquidatorEligible,
+			isCreditAccountFrozen: data.isCreditAccountFrozen,
 			kycProtocol: data.kycProtocol || void 0,
 			kycToken: require_sdk_utils_hex.hexEq(data.kycToken, "0x0000000000000000000000000000000000000000") ? void 0 : data.kycToken,
 			approve: require_sdk_accounts_liquidations_helpers.toLiquidationApproval({
 				target: data.liquidationCall.target,
 				creditFacade: suite.creditFacade.address,
 				creditManager: ca.creditManager,
-				token: suite.underlying,
-				amount: data.requiredUnderlyingAmount
+				token: data.requiredToken,
+				amount: data.requiredAmount
 			})
 		};
 	}
@@ -107,56 +107,39 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 	* {@inheritDoc ILiquidationsService.loadRWALiquidators}
 	**/
 	async loadRWALiquidators() {
-		await this.sdk.tokensMeta.loadTokenData();
-		const phantomTokens = [];
-		for (const meta of this.sdk.tokensMeta.phantomTokens.values()) switch (meta.contractType) {
-			case require_sdk_market_rwa_securitize_constants.PHANTOM_TOKEN_SECURITIZE_REDEMPTION:
-			case require_sdk_market_rwa_midas_constants.PHANTOM_TOKEN_MIDAS_REDEMPTION: phantomTokens.push(meta);
-		}
-		if (phantomTokens.length === 0) return;
-		const ptResp = await this.client.multicall({
-			contracts: phantomTokens.map(({ addr }) => ({
-				address: addr,
-				abi: require_abi_iPhantomToken.iPhantomTokenAbi,
-				functionName: "getPhantomTokenInfo"
-			})),
-			allowFailure: false,
-			batchSize: 0
-		});
-		const gateways = phantomTokens.map(({ contractType }, i) => ({
-			gateway: ptResp[i][0],
-			contractType
-		}));
-		const gwResp = await this.client.multicall({
-			contracts: gateways.map(({ gateway }) => ({
-				address: gateway,
-				abi: require_abi_rwa_iRWAGateway.iRWAGatewayAbi,
-				functionName: "transferMaster"
+		const configurators = this.sdk.marketRegister.marketConfigurators;
+		if (configurators.length === 0) return;
+		const resp = await this.client.multicall({
+			contracts: configurators.map((mc) => ({
+				address: require_sdk_accounts_liquidations_constants.LIQUIDATION_COMPRESSOR_V313_ADDRESS,
+				abi: require_abi_ILiquidationCompressorV313.iLiquidationCompressorV313Abi,
+				functionName: "getRWALiquidators",
+				args: [mc.address]
 			})),
 			allowFailure: false,
 			batchSize: 0
 		});
-		const refs = gateways.map(({ contractType }, i) => ({
-			liquidator: gwResp[i],
-			contractType
-		}));
-		for (const ref of refs) this.#createRWALiquidator(ref);
+		for (const info of resp.flat()) this.#createRWALiquidator(info);
 	}
 	/**
 	* Instantiates the liquidator contract, which registers it and labels its
 	* address (see `BaseContract`).
 	*
-	* @param ref - Discovered liquidator address and its phantom token type
+	* @param info - Liquidator discovered by the compressor. The same gateway
+	* can be configured in several credit managers, so duplicates are expected
+	* and skipped.
 	**/
-	#createRWALiquidator(ref) {
-		const { liquidator, contractType } = ref;
+	#createRWALiquidator(info) {
+		const liquidator = info.liquidatorAddress;
 		if (this.sdk.getContract(liquidator)) return;
-		switch (contractType) {
-			case require_sdk_market_rwa_securitize_constants.PHANTOM_TOKEN_SECURITIZE_REDEMPTION:
+		switch (require_sdk_utils_bytes32ToString.bytes32ToString(info.contractType)) {
+			case require_sdk_market_rwa_securitize_constants.RWA_LIQUIDATOR_SECURITIZE:
 				new require_sdk_market_rwa_securitize_SecuritizeLiquidatorContract.SecuritizeLiquidatorContract(this.sdk, liquidator);
+				this.logger?.debug(`registered Securitize liquidator ${liquidator}`);
 				return;
-			case require_sdk_market_rwa_midas_constants.PHANTOM_TOKEN_MIDAS_REDEMPTION:
+			case require_sdk_market_rwa_midas_constants.RWA_LIQUIDATOR_MIDAS:
 				new require_sdk_market_rwa_midas_MidasLiquidatorContract.MidasLiquidatorContract(this.sdk, liquidator);
+				this.logger?.debug(`registered Midas liquidator ${liquidator}`);
 				return;
 		}
 	}
@@ -251,7 +234,8 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 				token: unwrappedUnderlying,
 				balance: require_sdk_accounts_liquidations_helpers.calcEstimatedProfit(ca.totalValue, liquidationDiscount)
 			},
-			isDelayed: ca.tokens.some((t) => t.balance > 10n && !!compressor?.getWithdrawalSourceToken(t.token))
+			isDelayed: ca.tokens.some((t) => t.balance > 10n && !!compressor?.getWithdrawalSourceToken(t.token)),
+			paused: suite.creditFacade.isPaused
 		};
 	}
 };

package/dist/cjs/sdk/accounts/liquidations/constants.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/sdk/accounts/liquidations/constants.ts
-const LIQUIDATION_COMPRESSOR_V313_ADDRESS = "0x04c5c47c3b9e29ce98fdd27103fbb6a0815b1712";
+const LIQUIDATION_COMPRESSOR_V313_ADDRESS = "0xB70C4500a0afF02107eB983a348F22492fB6dC94";
 //#endregion
 exports.LIQUIDATION_COMPRESSOR_V313_ADDRESS = LIQUIDATION_COMPRESSOR_V313_ADDRESS;

package/dist/cjs/sdk/accounts/liquidations/helpers.js

@@ -76,14 +76,16 @@ function toLiquidatorWithdrawals(current, network) {
 		network,
 		sourceToken: w.token,
 		token: o.token,
-		amount: o.amount
+		amount: o.amount,
+		redeemer: w.redeemer
 	});
 	for (const w of current.pending) for (const o of w.expectedOutputs) rows.push({
 		network,
 		sourceToken: w.token,
 		token: o.token,
 		amount: o.amount,
-		claimableAt: w.claimableAt
+		claimableAt: w.claimableAt,
+		redeemer: w.redeemer
 	});
 	return rows;
 }

package/dist/cjs/sdk/accounts/withdrawal-compressor/AbstractWithdrawalCompressorContract.js

@@ -1,5 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sdk_utils_AddressMap = require("../../utils/AddressMap.js");
+require("../../constants/addresses.js");
+require("../../constants/index.js");
+const require_sdk_utils_hex = require("../../utils/hex.js");
 require("../../utils/index.js");
 const require_sdk_base_BaseContract = require("../../base/BaseContract.js");
 require("../../base/index.js");
@@ -201,6 +204,13 @@ function toRequestableWithdrawal(resp) {
 	};
 }
 /**
+* Normalizes the redeemer of a withdrawal: legacy compressors do not report
+* one, and v313+ uses the zero address for "not applicable".
+**/
+function toRedeemer(redeemer) {
+	return !redeemer || require_sdk_utils_hex.hexEq(redeemer, "0x0000000000000000000000000000000000000000") ? void 0 : redeemer;
+}
+/**
 * Normalizes a claimable withdrawal. The intent is decoded from `extraData`
 * only when `creditManager` is provided (it is required to build
 * {@link DelayedIntentExtended} and is only meaningful for credit account
@@ -218,6 +228,7 @@ function toClaimableWithdrawal(w, creditManager) {
 		withdrawalTokenSpent: w.withdrawalTokenSpent,
 		outputs: [...w.outputs],
 		claimCalls: [...w.claimCalls],
+		redeemer: toRedeemer(w.redeemer),
 		intent
 	};
 }
@@ -236,6 +247,7 @@ function toPendingWithdrawal(w, creditManager) {
 		withdrawalPhantomToken: w.withdrawalPhantomToken,
 		expectedOutputs: [...w.expectedOutputs],
 		claimableAt: w.claimableAt,
+		redeemer: toRedeemer(w.redeemer),
 		intent
 	};
 }

package/dist/cjs/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV313Contract.js

@@ -79,6 +79,11 @@ const iExternalWithdrawalsBatchAbi = [{
 					internalType: "bytes"
 				}]
 			},
+			{
+				name: "redeemer",
+				type: "address",
+				internalType: "address"
+			},
 			{
 				name: "extraData",
 				type: "bytes",
@@ -127,6 +132,11 @@ const iExternalWithdrawalsBatchAbi = [{
 				type: "uint256",
 				internalType: "uint256"
 			},
+			{
+				name: "redeemer",
+				type: "address",
+				internalType: "address"
+			},
 			{
 				name: "extraData",
 				type: "bytes",

package/dist/cjs/sdk/accounts/withdrawal-compressor/addresses.js

@@ -2,7 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/sdk/accounts/withdrawal-compressor/addresses.ts
 const WITHDRAWAL_COMPRESSORS = {
 	Mainnet: {
-		address: "0x5c80d7e7b18eCb00Cc9FAd57c59eEC4eF7516597",
+		address: "0x6FA0c5404C31D0161bb39Cc1311aac998A38ecD5",
 		version: 313
 	},
 	Monad: {

package/dist/esm/abi/ILiquidationCompressorV313.js

@@ -46,7 +46,12 @@ const iLiquidationCompressorV313Abi = [
 			internalType: "struct LiquidationData",
 			components: [
 				{
-					name: "requiredUnderlyingAmount",
+					name: "requiredToken",
+					type: "address",
+					internalType: "address"
+				},
+				{
+					name: "requiredAmount",
 					type: "uint256",
 					internalType: "uint256"
 				},
@@ -101,6 +106,11 @@ const iLiquidationCompressorV313Abi = [
 					type: "bool",
 					internalType: "bool"
 				},
+				{
+					name: "isCreditAccountFrozen",
+					type: "bool",
+					internalType: "bool"
+				},
 				{
 					name: "kycProtocol",
 					type: "string",
@@ -115,6 +125,38 @@ const iLiquidationCompressorV313Abi = [
 		}],
 		stateMutability: "nonpayable"
 	},
+	{
+		type: "function",
+		name: "getRWALiquidators",
+		inputs: [{
+			name: "marketConfigurator",
+			type: "address",
+			internalType: "address"
+		}],
+		outputs: [{
+			name: "",
+			type: "tuple[]",
+			internalType: "struct RWALiquidatorInfo[]",
+			components: [
+				{
+					name: "gateway",
+					type: "address",
+					internalType: "address"
+				},
+				{
+					name: "liquidatorAddress",
+					type: "address",
+					internalType: "address"
+				},
+				{
+					name: "contractType",
+					type: "bytes32",
+					internalType: "bytes32"
+				}
+			]
+		}],
+		stateMutability: "view"
+	},
 	{
 		type: "function",
 		name: "version",