@gearbox-protocol/sdk 16.0.0-next.2 → 16.0.0-next.21

package/dist/cjs/onchain/pools/PoolService.js

@@ -0,0 +1,463 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_abi_iERC20 = require("../../abi/iERC20.js");
+const require_onchain_utils_AddressSet = require("../utils/AddressSet.js");
+require("../constants/addresses.js");
+const require_onchain_constants_math = require("../constants/math.js");
+require("../constants/index.js");
+const require_onchain_utils_hex = require("../utils/hex.js");
+require("../utils/index.js");
+const require_onchain_base_BaseContract = require("../base/BaseContract.js");
+const require_onchain_base_SDKConstruct = require("../base/SDKConstruct.js");
+const require_onchain_base_token_types = require("../base/token-types.js");
+require("../base/index.js");
+const require_onchain_market_math = require("../market/math.js");
+const require_onchain_market_zapper_IERC20ZapperContract = require("../market/zapper/IERC20ZapperContract.js");
+const require_onchain_market_zapper_IETHZapperContract = require("../market/zapper/IETHZapperContract.js");
+require("../market/index.js");
+//#region src/onchain/pools/PoolService.ts
+/**
+* Haircut on reported pool liquidity, so a withdrawal sized against the reported
+* figure is not defeated by rounding in the share conversion.
+*/
+const LIQUIDITY_SAFETY_NUM = 99999n;
+const LIQUIDITY_SAFETY_DENOM = 100000n;
+var PoolService = class extends require_onchain_base_SDKConstruct.SDKConstruct {
+	/**
+	* {@inheritDoc IPoolsService.getDepositTokensIn}
+	*/
+	getDepositTokensIn(pool) {
+		const underlying = this.#describeUnderlying(pool);
+		if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) switch (underlying.contractType) {
+			case require_onchain_base_token_types.RWA_UNDERLYING_DEFAULT: return this.#depositTokensIn(pool, false);
+			case require_onchain_base_token_types.RWA_UNDERLYING_ON_DEMAND: return [underlying.asset];
+		}
+		return this.#depositTokensIn(pool, true);
+	}
+	/**
+	* {@inheritDoc IPoolsService.getDepositTokensOut}
+	*/
+	getDepositTokensOut(pool, tokenIn) {
+		const underlying = this.#describeUnderlying(pool);
+		if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) switch (underlying.contractType) {
+			case require_onchain_base_token_types.RWA_UNDERLYING_DEFAULT: return this.#depositTokensOut(pool, tokenIn, false);
+			case require_onchain_base_token_types.RWA_UNDERLYING_ON_DEMAND: return [];
+		}
+		return this.#depositTokensOut(pool, tokenIn, true);
+	}
+	/**
+	* {@inheritDoc IPoolsService.getDepositMetadata}
+	*/
+	getDepositMetadata(pool, tokenIn, tokenOut) {
+		const underlying = this.#describeUnderlying(pool);
+		if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) switch (underlying.contractType) {
+			case require_onchain_base_token_types.RWA_UNDERLYING_DEFAULT: return this.#depositMetadata("rwa-default", pool, tokenIn, tokenOut, false);
+			case require_onchain_base_token_types.RWA_UNDERLYING_ON_DEMAND: return {
+				zapper: void 0,
+				approveTarget: underlying.liquidityProvider.addr,
+				permissible: false,
+				type: "rwa-on-demand"
+			};
+		}
+		return this.#depositMetadata("classic", pool, tokenIn, tokenOut, true);
+	}
+	/**
+	* {@inheritDoc IPoolsService.addLiquidity}
+	*/
+	addLiquidity(props) {
+		const { collateral, meta, permit, referralCode, pool, wallet } = props;
+		const underlying = this.#describeUnderlying(pool);
+		if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) {
+			if (underlying.contractType === "RWA_UNDERLYING::ON_DEMAND") return;
+		}
+		const { zapper } = meta;
+		if (zapper instanceof require_onchain_market_zapper_IETHZapperContract.IETHZapperContract) {
+			const tx = zapper.depositWithReferral(wallet, referralCode ?? 0n);
+			tx.value = collateral.balance.toString();
+			return {
+				tx,
+				calls: [{
+					target: zapper.baseParams.addr,
+					callData: tx.callData
+				}]
+			};
+		} else if (zapper instanceof require_onchain_market_zapper_IERC20ZapperContract.IERC20ZapperContract) {
+			const tx = permit ? zapper.depositWithReferralAndPermit(collateral.balance, wallet, referralCode ?? 0n, permit.deadline, permit.v, permit.r, permit.s) : zapper.depositWithReferral(collateral.balance, wallet, referralCode ?? 0n);
+			return {
+				tx,
+				calls: [{
+					target: zapper.baseParams.addr,
+					callData: tx.callData
+				}]
+			};
+		}
+		const tx = this.sdk.marketRegister.findByPool(pool).pool.pool.depositWithReferral(collateral.balance, wallet, referralCode ?? 0n);
+		return {
+			tx,
+			calls: [{
+				target: pool,
+				callData: tx.callData
+			}]
+		};
+	}
+	/**
+	* {@inheritDoc IPoolsService.getWithdrawalTokensIn}
+	*/
+	getWithdrawalTokensIn(pool) {
+		const underlying = this.#describeUnderlying(pool);
+		if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) switch (underlying.contractType) {
+			case require_onchain_base_token_types.RWA_UNDERLYING_DEFAULT: return this.#withdrawalTokensIn(pool, false);
+			case require_onchain_base_token_types.RWA_UNDERLYING_ON_DEMAND: return [];
+		}
+		return this.#withdrawalTokensIn(pool, true);
+	}
+	/**
+	* {@inheritDoc IPoolsService.getWithdrawalTokensOut}
+	*/
+	getWithdrawalTokensOut(pool, tokenIn) {
+		const underlying = this.#describeUnderlying(pool);
+		if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) switch (underlying.contractType) {
+			case require_onchain_base_token_types.RWA_UNDERLYING_DEFAULT: return this.#withdrawalTokensOut(pool, tokenIn, false);
+			case require_onchain_base_token_types.RWA_UNDERLYING_ON_DEMAND: return [underlying.asset];
+		}
+		return this.#withdrawalTokensOut(pool, tokenIn, true);
+	}
+	/**
+	* {@inheritDoc IPoolsService.simulateDeposit}
+	*/
+	simulateDeposit(props) {
+		const { pool: poolAddr, amount } = props;
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const tokenIn = props.tokenIn ?? pool.underlying;
+		const tokenOut = this.#resolveTokenOut(props.tokenOut, () => this.getDepositTokensOut(poolAddr, tokenIn), {
+			poolAddr,
+			tokenIn,
+			operation: "deposit"
+		});
+		const { zapper } = this.getDepositMetadata(poolAddr, tokenIn, tokenOut);
+		return {
+			tokenIn: {
+				token: tokenIn,
+				balance: amount
+			},
+			tokenOut: {
+				token: tokenOut,
+				balance: toShares(pool.pool, amount)
+			},
+			zapper: zapper?.baseParams.addr
+		};
+	}
+	/**
+	* {@inheritDoc IPoolsService.simulateWithdraw}
+	*/
+	simulateWithdraw(props) {
+		const { pool: poolAddr, amount } = props;
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const tokenIn = props.tokenIn ?? poolAddr;
+		const tokenOut = this.#resolveTokenOut(props.tokenOut, () => this.getWithdrawalTokensOut(poolAddr, tokenIn), {
+			poolAddr,
+			tokenIn,
+			operation: "withdrawal"
+		});
+		const { zapper } = this.getWithdrawalMetadata(poolAddr, tokenIn, tokenOut);
+		return {
+			tokenIn: {
+				token: tokenIn,
+				balance: toSharesUp(pool.pool, amount)
+			},
+			tokenOut: {
+				token: tokenOut,
+				balance: amount
+			},
+			zapper: zapper?.baseParams.addr,
+			availableLiquidity: pool.pool.availableLiquidity * LIQUIDITY_SAFETY_NUM / LIQUIDITY_SAFETY_DENOM
+		};
+	}
+	/**
+	* {@inheritDoc IPoolsService.simulateRedeem}
+	*/
+	simulateRedeem(props) {
+		const { pool: poolAddr, amount } = props;
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const tokenIn = props.tokenIn ?? poolAddr;
+		const tokenOut = this.#resolveTokenOut(props.tokenOut, () => this.getWithdrawalTokensOut(poolAddr, tokenIn), {
+			poolAddr,
+			tokenIn,
+			operation: "withdrawal"
+		});
+		const { zapper } = this.getWithdrawalMetadata(poolAddr, tokenIn, tokenOut);
+		return {
+			tokenIn: {
+				token: tokenIn,
+				balance: amount
+			},
+			tokenOut: {
+				token: tokenOut,
+				balance: toAssets(pool.pool, amount)
+			},
+			zapper: zapper?.baseParams.addr,
+			availableLiquidity: pool.pool.availableLiquidity * LIQUIDITY_SAFETY_NUM / LIQUIDITY_SAFETY_DENOM
+		};
+	}
+	/**
+	* {@inheritDoc IPoolsService.removeLiquidity}
+	*/
+	removeLiquidity(props) {
+		const { pool, amount, meta, wallet, permit, mode = "withdraw" } = props;
+		const underlying = this.#describeUnderlying(pool);
+		if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) {
+			if (underlying.contractType === "RWA_UNDERLYING::ON_DEMAND") {
+				const tx = new require_onchain_base_BaseContract.BaseContract(this.sdk, {
+					addr: underlying.asset,
+					abi: require_abi_iERC20.ierc20Abi,
+					name: "ERC20"
+				}).createRawTx({
+					functionName: "approve",
+					args: [underlying.liquidityProvider.addr, 0n]
+				});
+				return {
+					tx,
+					calls: [{
+						target: underlying.asset,
+						callData: tx.callData
+					}]
+				};
+			}
+		}
+		const poolContract = this.sdk.marketRegister.findByPool(pool).pool.pool;
+		if (meta.zapper instanceof require_onchain_market_zapper_IETHZapperContract.IETHZapperContract || meta.zapper instanceof require_onchain_market_zapper_IERC20ZapperContract.IERC20ZapperContract) {
+			const shares = mode === "withdraw" ? toSharesUp(poolContract, amount) : amount;
+			const tx = permit ? meta.zapper.redeemWithPermit(shares, wallet, permit.deadline, permit.v, permit.r, permit.s) : meta.zapper.redeem(shares, wallet);
+			return {
+				tx,
+				calls: [{
+					target: meta.zapper.baseParams.addr,
+					callData: tx.callData
+				}]
+			};
+		}
+		const tx = mode === "withdraw" ? poolContract.withdraw(amount, wallet, wallet) : poolContract.redeem(amount, wallet, wallet);
+		return {
+			tx,
+			calls: [{
+				target: pool,
+				callData: tx.callData
+			}]
+		};
+	}
+	/**
+	* {@inheritDoc IPoolsService.getWithdrawalMetadata}
+	*/
+	getWithdrawalMetadata(pool, tokenIn, tokenOut) {
+		const underlying = this.#describeUnderlying(pool);
+		if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) switch (underlying.contractType) {
+			case require_onchain_base_token_types.RWA_UNDERLYING_DEFAULT: return this.#withdrawalMetadata("rwa-default", pool, tokenIn, tokenOut, false);
+			case require_onchain_base_token_types.RWA_UNDERLYING_ON_DEMAND: return {
+				zapper: void 0,
+				approveTarget: void 0,
+				permissible: false,
+				type: "rwa-on-demand"
+			};
+		}
+		return this.#withdrawalMetadata("classic", pool, tokenIn, tokenOut, true);
+	}
+	/**
+	* {@inheritDoc IPoolsService.listPositions}
+	*/
+	async listPositions(props) {
+		const { markets } = this.sdk.marketRegister;
+		if (markets.length === 0) return [];
+		const balances = await this.client.multicall({
+			contracts: markets.map((market) => ({
+				address: market.pool.pool.address,
+				abi: require_abi_iERC20.ierc20Abi,
+				functionName: "balanceOf",
+				args: [props.wallet]
+			})),
+			allowFailure: false,
+			batchSize: 0,
+			blockNumber: props.blockNumber
+		});
+		return markets.flatMap((market, i) => {
+			const shares = balances[i] ?? 0n;
+			return shares > 0n ? [this.#poolPosition(market, shares)] : [];
+		});
+	}
+	/**
+	* Returns non-migration zappers available for the pool.
+	*/
+	#getDepositZappers(poolAddr) {
+		return this.sdk.marketRegister.poolZappers(poolAddr).filter((z) => z.type !== "migration");
+	}
+	/**
+	* Returns all supported deposit input tokens for a pool.
+	*
+	* Includes:
+	* - zapper `tokenIn` where zapper output is pool diesel token
+	* - pool underlying token when direct deposit is enabled
+	*/
+	#depositTokensIn(poolAddr, allowDirectDeposit) {
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const result = new require_onchain_utils_AddressSet.AddressSet();
+		if (allowDirectDeposit) result.add(pool.underlying);
+		const zappers = this.#getDepositZappers(poolAddr);
+		for (const z of zappers) if (require_onchain_utils_hex.hexEq(z.tokenOut.addr, poolAddr)) result.add(z.tokenIn.addr);
+		if (result.size === 0) throw new Error(`No tokensIn found for pool ${this.labelAddress(poolAddr)}`);
+		return result.asArray();
+	}
+	/**
+	* Returns all supported withdrawal input tokens for a pool.
+	*
+	* Includes:
+	* - pool diesel token when direct withdrawal is enabled
+	* - all zapper that can be redeemed from the pool
+	*/
+	#withdrawalTokensIn(poolAddr, allowDirectDeposit) {
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const result = new require_onchain_utils_AddressSet.AddressSet();
+		if (allowDirectDeposit && pool) result.add(poolAddr);
+		const zappers = this.#getDepositZappers(poolAddr);
+		for (const z of zappers) result.add(z.tokenOut.addr);
+		if (result.size === 0) throw new Error(`No tokensIn found for pool ${this.labelAddress(poolAddr)}`);
+		return result.asArray();
+	}
+	/**
+	* Returns possible deposit outputs for a given input token.
+	*
+	* Includes:
+	* - zapper `tokenOut` for `z.tokenIn` matching `tokenIn`
+	* - pool diesel token for direct underlying deposit when enabled
+	*/
+	#depositTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
+		const result = new require_onchain_utils_AddressSet.AddressSet();
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const zappers = this.#getDepositZappers(poolAddr);
+		for (const z of zappers) if (require_onchain_utils_hex.hexEq(z.tokenIn.addr, tokenIn)) result.add(z.tokenOut.addr);
+		if (allowDirectDeposit && require_onchain_utils_hex.hexEq(tokenIn, pool.underlying)) result.add(poolAddr);
+		if (result.size === 0) throw new Error(`No tokensOut found for tokenIn ${this.labelAddress(tokenIn)} on pool ${this.labelAddress(poolAddr)}`);
+		return result.asArray();
+	}
+	/**
+	* Returns possible withdrawal outputs for a given input token.
+	*
+	* Includes:
+	* - zapper `tokenIn` where zapper `z.tokenOut` matches requested `tokenIn`
+	* - pool underlying token for direct diesel-token redemption when enabled
+	*/
+	#withdrawalTokensOut(poolAddr, tokenIn, allowDirectDeposit) {
+		const result = new require_onchain_utils_AddressSet.AddressSet();
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const zappers = this.#getDepositZappers(poolAddr);
+		for (const z of zappers) if (require_onchain_utils_hex.hexEq(z.tokenOut.addr, tokenIn)) result.add(z.tokenIn.addr);
+		if (allowDirectDeposit && require_onchain_utils_hex.hexEq(tokenIn, poolAddr)) result.add(pool.underlying);
+		if (result.size === 0) throw new Error(`No tokensOut found for tokenIn ${this.labelAddress(tokenIn)} on pool ${this.labelAddress(poolAddr)}`);
+		return result.asArray();
+	}
+	/**
+	* Returns a single non-migration zapper route for the given token pair.
+	*
+	* Throws when multiple matching zappers exist to keep call construction deterministic.
+	*/
+	#getDepositZapper(poolAddr, tokenIn, tokenOut) {
+		const zappers = this.sdk.marketRegister.getZapper(poolAddr, tokenIn, tokenOut)?.filter((z) => z.type !== "migration");
+		if (zappers && zappers.length > 1) throw new Error(`Multiple zappers found for tokenIn ${this.labelAddress(tokenIn)} and tokenOut ${this.labelAddress(tokenOut)} on pool ${this.labelAddress(poolAddr)}`);
+		return zappers?.[0];
+	}
+	/**
+	* Builds metadata required to execute a deposit operation.
+	*
+	* Includes selected zapper route (if any), approve target, and permit support flag.
+	*/
+	#depositMetadata(type, poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
+		if (!tokenOut) throw new Error("tokenOut is required for classic pool deposit");
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const zapper = this.#getDepositZapper(poolAddr, tokenIn, tokenOut);
+		if (!zapper && !allowDirectDeposit) throw new Error(`No zapper found for tokenIn ${this.labelAddress(tokenIn)} and tokenOut ${this.labelAddress(tokenOut)} on pool ${this.labelAddress(poolAddr)}`);
+		return {
+			zapper,
+			approveTarget: zapper?.baseParams.addr ?? pool.pool.address,
+			permissible: !!zapper && !require_onchain_utils_hex.hexEq(tokenIn, "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"),
+			type
+		};
+	}
+	/**
+	* Builds metadata required to execute a withdrawal operation.
+	*
+	* Includes selected zapper route (if any), approve target, and permit support flag.
+	*/
+	#withdrawalMetadata(type, poolAddr, tokenIn, tokenOut, allowDirectDeposit) {
+		if (!tokenOut) throw new Error("tokenOut is required for classic pool deposit");
+		const zapper = this.#getDepositZapper(poolAddr, tokenOut, tokenIn);
+		if (!zapper && !allowDirectDeposit) throw new Error(`No zapper found for tokenIn ${this.labelAddress(tokenOut)} and tokenOut ${this.labelAddress(tokenIn)} on pool ${this.labelAddress(poolAddr)}`);
+		return {
+			zapper,
+			approveTarget: zapper?.baseParams.addr,
+			permissible: !!zapper,
+			type
+		};
+	}
+	/**
+	* Picks the route output when the caller left it open.
+	*
+	* Only an unambiguous single route can be defaulted: with several outputs the
+	* choice is the caller's, and with none there is no route to preview.
+	*/
+	#resolveTokenOut(requested, candidates, ctx) {
+		if (requested) return requested;
+		const options = candidates();
+		if (options.length !== 1) throw new Error(`tokenOut is required: ${options.length} ${ctx.operation} routes from ${this.labelAddress(ctx.tokenIn)} on pool ${this.labelAddress(ctx.poolAddr)}`);
+		return options[0];
+	}
+	#describeUnderlying(pool) {
+		const market = this.sdk.marketRegister.findByPool(pool);
+		return this.sdk.tokensMeta.mustGet(market.underlying);
+	}
+	#poolPosition(market, shares) {
+		const { pool } = market.pool;
+		return {
+			kind: "pool",
+			name: this.sdk.tokensMeta.mustGetToken(pool.address).name,
+			chainId: this.chainId,
+			pool: pool.address,
+			underlyingToken: market.underlyingToken,
+			netValue: {
+				token: this.sdk.tokensMeta.mustGetToken(market.unwrappedUnderlying),
+				...market.priceOracle.toAmount(market.underlying, shares * pool.dieselRate / require_onchain_constants_math.RAY)
+			},
+			apy: { organicApy: require_onchain_market_math.rayToBps(pool.supplyRate) }
+		};
+	}
+};
+/**
+* Shares minted for `assets`, as `previewDeposit` would report them.
+*
+* Both directions convert through the diesel rate — underlying per RAY of
+* shares — because that is the rate the pool itself divides by, and the only
+* exact one the SDK holds: `totalAssets` is this rate multiplied out, so
+* converting back through it costs a wei on large amounts. Rounds down, as
+* minting does.
+*/
+function toShares(pool, assets) {
+	const { dieselRate } = pool;
+	return dieselRate === 0n ? assets : assets * require_onchain_constants_math.RAY / dieselRate;
+}
+/**
+* Shares a withdrawal of `assets` burns, as `previewWithdraw` would report
+* them: {@link toShares} rounded the other way, since the burn has to cover
+* the payout the caller asked for.
+*/
+function toSharesUp(pool, assets) {
+	const { dieselRate } = pool;
+	return dieselRate === 0n ? assets : (assets * require_onchain_constants_math.RAY + dieselRate - 1n) / dieselRate;
+}
+/**
+* Underlying paid out for `shares`, as `previewRedeem` would report it:
+* {@link toShares} run backwards, less the pool's withdrawal fee.
+*/
+function toAssets(pool, shares) {
+	const { dieselRate, withdrawFee } = pool;
+	return (dieselRate === 0n ? shares : shares * dieselRate / require_onchain_constants_math.RAY) * (require_onchain_constants_math.PERCENTAGE_FACTOR - withdrawFee) / require_onchain_constants_math.PERCENTAGE_FACTOR;
+}
+//#endregion
+exports.PoolService = PoolService;
+exports.toShares = toShares;
+exports.toSharesUp = toSharesUp;

package/dist/cjs/onchain/pools/index.js

@@ -0,0 +1,6 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_pools_PoolService = require("./PoolService.js");
+require("./types.js");
+exports.PoolService = require_onchain_pools_PoolService.PoolService;
+exports.toShares = require_onchain_pools_PoolService.toShares;
+exports.toSharesUp = require_onchain_pools_PoolService.toSharesUp;

package/dist/cjs/onchain/positions/MultichainPositionsService.js

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_base_MultichainConstruct = require("../base/MultichainConstruct.js");
+require("../base/index.js");
+//#region src/onchain/positions/MultichainPositionsService.ts
+/**
+* Cross-chain counterpart of {@link PositionsService}.
+*
+* @typeParam Plugins - Map of attached plugin types.
+**/
+var MultichainPositionsService = class extends require_onchain_base_MultichainConstruct.MultichainConstruct {
+	/**
+	* Positions of a wallet on all queried chains, see
+	* {@link PositionsService.list}.
+	**/
+	async list(props) {
+		return this.queryChains({
+			chainIds: props.filter?.chainIds,
+			label: "list positions",
+			block: "latest",
+			run: (sdk, block) => sdk.positions.list({
+				...props,
+				blockNumber: block.blockNumber
+			})
+		});
+	}
+};
+//#endregion
+exports.MultichainPositionsService = MultichainPositionsService;