@gearbox-protocol/sdk 16.0.0-next.9 → 16.0.0

package/dist/esm/onchain/market/oracle/PriceOracleBaseContract.js

@@ -1,5 +1,6 @@
 import { AddressMap } from "../../utils/AddressMap.js";
 import { AddressSet } from "../../utils/AddressSet.js";
+import { BigIntMath } from "../../utils/bigint-math.js";
 import { AP_PRICE_FEED_COMPRESSOR, AP_WETH_TOKEN } from "../../constants/address-provider.js";
 import { NATIVE_ADDRESS } from "../../constants/addresses.js";
 import "../../constants/math.js";
@@ -10,10 +11,13 @@ import "../../utils/index.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
 import { usdToNumber } from "../math.js";
+import { safeValue } from "../../../model/result.js";
+import "../../../model/index.js";
 import { priceFeedCompressorAbi } from "../../../abi/compressors/priceFeedCompressor.js";
 import { PriceFeedRef } from "../pricefeeds/PriceFeedRef.js";
 import { getRawPriceUpdates } from "../pricefeeds/getRawPriceUpdates.js";
 import "../pricefeeds/index.js";
+import { unpriceableTokenError } from "./errors.js";
 import PriceFeedAnswerMap from "./PriceFeedAnswerMap.js";
 import { isAddressEqual, stringToHex } from "viem";
 import { format, formatDistanceToNow } from "date-fns";
@@ -108,7 +112,7 @@ var PriceOracleBaseContract = class extends BaseContract {
 	* {@inheritDoc IPriceOracleContract.convert}
 	**/
 	convert(from, to, amount, reserve = false) {
-		if (from === to) return amount;
+		if (isAddressEqual(from, to)) return amount;
 		const fromToken = this.#priceableToken(from);
 		const toToken = this.#priceableToken(to);
 		const fromPrice = reserve ? this.reservePrice(fromToken) : this.mainPrice(fromToken);
@@ -141,10 +145,13 @@ var PriceOracleBaseContract = class extends BaseContract {
 	**/
 	safeConvert(from, to, amount) {
 		try {
-			return this.convert(from, to, amount);
-		} catch (e) {
-			this.logger?.debug(`cannot convert ${this.labelAddress(from)} to ${this.labelAddress(to)}: ${e}`);
-			return null;
+			return { value: this.convert(from, to, amount) };
+		} catch {
+			try {
+				return { value: this.convert(from, to, amount, true) };
+			} catch {
+				return safeValue(0n, unpriceableTokenError(from));
+			}
 		}
 	}
 	/**
@@ -152,26 +159,72 @@ var PriceOracleBaseContract = class extends BaseContract {
 	**/
 	safeConvertToUSD(token, amount) {
 		try {
-			return this.convertToUSD(token, amount);
-		} catch (e) {
-			this.logger?.debug(`cannot price ${this.labelAddress(token)}: ${e}`);
-			return null;
+			return { value: this.convertToUSD(token, amount) };
+		} catch {
+			try {
+				return { value: this.convertToUSD(token, amount, true) };
+			} catch {
+				return safeValue(0n, unpriceableTokenError(token));
+			}
+		}
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.safeConvertMinUSD}
+	**/
+	safeConvertMinUSD(token, amount) {
+		let main;
+		try {
+			main = this.convertToUSD(token, amount);
+		} catch {
+			return safeValue(0n, unpriceableTokenError(token));
+		}
+		let feedToken = token;
+		if (isAddressEqual(token, "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE")) try {
+			feedToken = this.sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0);
+		} catch {}
+		if (!this.reservePriceFeeds.has(feedToken)) return { value: 0n };
+		try {
+			return { value: BigIntMath.min(main, this.convertToUSD(token, amount, true)) };
+		} catch {
+			return safeValue(0n, unpriceableTokenError(token));
+		}
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.safeConvertFromUSD}
+	**/
+	safeConvertFromUSD(token, amount) {
+		try {
+			return { value: this.convertFromUSD(token, amount) };
+		} catch {
+			try {
+				return { value: this.convertFromUSD(token, amount, true) };
+			} catch {
+				return safeValue(0n, unpriceableTokenError(token));
+			}
 		}
 	}
 	/**
-	* {@inheritDoc IPriceOracleContract.safeUsdValue}
+	* {@inheritDoc IPriceOracleContract.safeConvertAssets}
 	**/
-	safeUsdValue(token, amount) {
-		const usd = this.safeConvertToUSD(token, amount);
-		return usd === null ? null : usdToNumber(usd);
+	safeConvertAssets(assets, to) {
+		let value = 0n;
+		let error;
+		for (const { token, balance } of assets) {
+			if (balance <= 10n) continue;
+			const converted = this.safeConvert(token, to, balance);
+			value += converted.value;
+			error ??= converted.error;
+		}
+		return safeValue(value, error);
 	}
 	/**
 	* {@inheritDoc IPriceOracleContract.toAmount}
 	**/
 	toAmount = (token, value) => {
+		const priced = this.safeConvertToUSD(token, value);
 		return {
 			value,
-			valueUsd: this.safeUsdValue(token, value)
+			valueUsd: priced.error ? null : usdToNumber(priced.value)
 		};
 	};
 	/**

package/dist/esm/onchain/market/oracle/TestPriceOracle.mock.js

@@ -0,0 +1,213 @@
+import { iPriceOracleV310Abi } from "../../../abi/310/generated.js";
+import { getChain } from "../../chain/chains.js";
+import "../../chain/index.js";
+import "../../constants/address-provider.js";
+import "../../constants/math.js";
+import "../../constants/index.js";
+import { toBN } from "../../utils/formatter.js";
+import "../../utils/index.js";
+import { ChainContractsRegister } from "../../base/ChainContractsRegister.js";
+import "../../base/index.js";
+import { PriceFeedRef } from "../pricefeeds/PriceFeedRef.js";
+import "../pricefeeds/index.js";
+import { PriceOracleBaseContract } from "./PriceOracleBaseContract.js";
+import { bytesToHex, createPublicClient, custom, getAddress, hexToBytes } from "viem";
+//#region src/onchain/market/oracle/TestPriceOracle.mock.ts
+/**
+* Well-known mainnet tokens for tests. The oracle prefills their metadata;
+* a seed can then be as small as `{ price: 2000 }`.
+**/
+const MockTokens = {
+	WETH: getAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+	USDC: getAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+	DAI: getAddress("0x6B175474E89094C44Da98b954EedeAC495271d0F"),
+	cbETH: getAddress("0xBe9895146f7AF43049ca1c1AE358B0541Ea49704"),
+	dcUSDC: getAddress("0x50A9C808cd114E8fEA72f03aE2B1A8825677D56D"),
+	ACRED: getAddress("0x17418038ecF73BA4026c4f428547BF099706F27B"),
+	srpACRED_USDC: getAddress("0xe4a38b653B2580C9D72a50F190Ddd6E2d2D2a412")
+};
+const MOCK_TOKEN_META = {
+	[MockTokens.WETH]: {
+		decimals: 18,
+		symbol: "WETH",
+		name: "Wrapped Ether"
+	},
+	[MockTokens.USDC]: {
+		decimals: 6,
+		symbol: "USDC",
+		name: "USD Coin"
+	},
+	[MockTokens.DAI]: {
+		decimals: 18,
+		symbol: "DAI",
+		name: "Dai Stablecoin"
+	},
+	[MockTokens.cbETH]: {
+		decimals: 18,
+		symbol: "cbETH",
+		name: "Coinbase Wrapped Staked ETH"
+	},
+	[MockTokens.dcUSDC]: {
+		decimals: 6,
+		symbol: "dcUSDC",
+		name: "Default compliant USD Coin"
+	},
+	[MockTokens.ACRED]: {
+		decimals: 6,
+		symbol: "ACRED",
+		name: "Apollo Diversified Credit Securitize Fund"
+	},
+	[MockTokens.srpACRED_USDC]: {
+		decimals: 6,
+		symbol: "srpACRED_USDC",
+		name: "Securitize pending redemption Apollo Diversified Credit Securitize Fund to USD Coin"
+	}
+};
+const TEST_ORACLE_ADDRESS = getAddress("0x040ac1e000000000000000000000000000000310");
+const FAILED_ANSWER = {
+	price: 0n,
+	success: false,
+	updatedAt: 0n
+};
+/**
+* Register whose client rejects any RPC request: the oracle never talks to a
+* node. `addressProvider.getAddress` answers `AP_WETH_TOKEN` with mainnet WETH
+* so `#priceableToken` and `safeConvertMinUSD` exercise their real native
+* branches.
+**/
+var TestOracleSdk = class extends ChainContractsRegister {
+	addressProvider = { getAddress: (contract, version) => {
+		if (contract === "WETH_TOKEN") return MockTokens.WETH;
+		throw new Error(`Address ${contract}, version: ${version} not found`);
+	} };
+	priceFeeds = { generatePriceFeedsUpdateTxs: () => {
+		throw new Error("TestPriceOracle: no priceFeeds");
+	} };
+};
+/**
+* A real {@link PriceOracleBaseContract} seeded from plain records, for tests.
+*
+* Conversion, safe-price fallback, and native-through-WETH all run the
+* production code. Feed-tree methods (`priceFeedData`, `priceUpdatesFor*`, …)
+* are not wired and throw if touched.
+**/
+var TestPriceOracle = class extends PriceOracleBaseContract {
+	constructor(tokens = {}) {
+		const register = new TestOracleSdk(createPublicClient({
+			chain: getChain("Mainnet"),
+			transport: custom({ request: async () => {
+				throw new Error("not implemented");
+			} })
+		}));
+		super(register, {
+			abi: iPriceOracleV310Abi,
+			addr: TEST_ORACLE_ADDRESS,
+			name: "TestPriceOracle"
+		}, {
+			priceFeedMap: [],
+			priceFeedTree: []
+		});
+		for (const [token, meta] of Object.entries(MOCK_TOKEN_META)) {
+			const addr = getAddress(token);
+			this.register.tokensMeta.upsert(addr, {
+				addr,
+				...meta
+			});
+		}
+		for (const [token, cfg] of Object.entries(tokens)) this.addToken(token, cfg);
+	}
+	/**
+	* Registers token meta and optional feed answers. Chainable, like all
+	* modifiers.
+	**/
+	addToken(token, cfg) {
+		const addr = getAddress(token);
+		const known = MOCK_TOKEN_META[addr];
+		const symbol = cfg.symbol ?? known?.symbol ?? `T_${addr.slice(2, 8)}`;
+		this.register.tokensMeta.upsert(addr, {
+			addr,
+			symbol,
+			name: cfg.name ?? known?.name ?? symbol,
+			decimals: cfg.decimals ?? known?.decimals ?? 18
+		});
+		if (cfg.price !== void 0) this.setMainPrice(addr, cfg.price);
+		if (cfg.reservePrice !== void 0) this.setReservePrice(addr, cfg.reservePrice);
+		return this;
+	}
+	setMainPrice(token, price) {
+		this.#setAnswer(token, "main", rawPrice(price));
+		return this;
+	}
+	setReservePrice(token, price) {
+		this.#setAnswer(token, "reserve", rawPrice(price));
+		return this;
+	}
+	/**
+	* Feed stays configured, its answer failed — {@link PriceFeedAnswerMap.price}
+	* throws. Distinct from {@link removeMainFeed}.
+	**/
+	failMainAnswer(token) {
+		this.#failAnswer(token, "main");
+		return this;
+	}
+	/**
+	* Feed stays configured, its answer failed. Distinct from
+	* {@link removeReserveFeed}: `safeConvertMinUSD` treats a present-but-failed
+	* reserve feed as an error, and a missing one as an untrusted 0.
+	**/
+	failReserveAnswer(token) {
+		this.#failAnswer(token, "reserve");
+		return this;
+	}
+	/**
+	* No main feed at all: distinct from a failed answer.
+	**/
+	removeMainFeed(token) {
+		this.mainPriceFeeds.delete(token);
+		this.mainPrices.delete(token);
+		return this;
+	}
+	/**
+	* No reserve feed at all: distinct from a failed answer, and what
+	* `safeConvertMinUSD` treats as an untrusted token (value 0, no error).
+	**/
+	removeReserveFeed(token) {
+		this.reservePriceFeeds.delete(token);
+		this.reservePrices.delete(token);
+		return this;
+	}
+	async updateAndConvert(_from, _to, _amount) {
+		throw new Error("TestPriceOracle: updateAndConvert needs a node");
+	}
+	#setAnswer(token, kind, price) {
+		this.#ensureFeed(token, kind);
+		this.#answers(kind).upsert(token, {
+			price,
+			success: true,
+			updatedAt: 0n
+		});
+	}
+	#failAnswer(token, kind) {
+		this.#ensureFeed(token, kind);
+		this.#answers(kind).upsert(token, FAILED_ANSWER);
+	}
+	#ensureFeed(token, kind) {
+		const feeds = kind === "main" ? this.mainPriceFeeds : this.reservePriceFeeds;
+		if (!feeds.has(token)) feeds.upsert(token, new PriceFeedRef(this.register, feedAddr(token, kind), 0));
+	}
+	#answers(kind) {
+		return kind === "main" ? this.mainPrices : this.reservePrices;
+	}
+};
+/** Human USD → 8-decimal fixed point; bigint passes through. */
+function rawPrice(price) {
+	return typeof price === "bigint" ? price : toBN(String(price), 8);
+}
+/** Deterministic unused address per token feed; never resolved. */
+function feedAddr(token, kind) {
+	const bytes = hexToBytes(getAddress(token));
+	bytes[0] = kind === "main" ? 254 : 253;
+	return getAddress(bytesToHex(bytes));
+}
+//#endregion
+export { MockTokens, TEST_ORACLE_ADDRESS, TestPriceOracle };

package/dist/esm/onchain/market/oracle/collateralPriceInUnderlying.js

@@ -0,0 +1,26 @@
+import { PRICE_DECIMALS } from "../../constants/math.js";
+//#region src/onchain/market/oracle/collateralPriceInUnderlying.ts
+/**
+* What one unit of `collateral` costs in `underlying` right now, in the
+* oracle's 8-decimal (`PRICE_DECIMALS`) fixed point — the scale and the
+* denomination `calcLiquidationPrice` answers in, so the two figures are read
+* as a pair.
+*
+* Both sides come from the oracle's **main** feeds: this is the price the
+* market quotes, not the conservative one a hand-over is weighed at.
+*
+* `null` when the oracle cannot answer for either token, or prices the
+* underlying at zero — a screen shows a gap rather than a number derived from
+* a missing feed.
+**/
+function collateralPriceInUnderlying(oracle, collateral, underlying) {
+	try {
+		const underlyingPrice = oracle.mainPrice(underlying);
+		if (underlyingPrice <= 0n) return null;
+		return oracle.mainPrice(collateral) * PRICE_DECIMALS / underlyingPrice;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { collateralPriceInUnderlying };

package/dist/esm/onchain/market/oracle/errors.js

@@ -0,0 +1,13 @@
+//#region src/onchain/market/oracle/errors.ts
+/**
+* Builds an {@link UnpriceableTokenError} for `token`.
+**/
+function unpriceableTokenError(token) {
+	return {
+		code: "unpriceableToken",
+		message: `cannot price token ${token}`,
+		token
+	};
+}
+//#endregion
+export { unpriceableTokenError };

package/dist/esm/onchain/market/oracle/index.js

@@ -1,4 +1,6 @@
+import { collateralPriceInUnderlying } from "./collateralPriceInUnderlying.js";
+import { unpriceableTokenError } from "./errors.js";
 import { PriceOracleV310Contract } from "./PriceOracleV310Contract.js";
 import { createPriceOracle } from "./createPriceOracle.js";
 import "./types.js";
-export { PriceOracleV310Contract, createPriceOracle };
+export { PriceOracleV310Contract, collateralPriceInUnderlying, createPriceOracle, unpriceableTokenError };

package/dist/esm/onchain/market/pool/PoolV310Contract.js

@@ -50,6 +50,31 @@ var PoolV310Contract = class extends BaseContract {
 		return this.totalSupply * this.dieselRate / RAY;
 	}
 	/**
+	* {@inheritDoc IPoolContract.getShareBalance}
+	*/
+	async getShareBalance(wallet, blockNumber) {
+		return this.client.readContract({
+			address: this.address,
+			abi: this.abi,
+			functionName: "balanceOf",
+			args: [wallet],
+			blockNumber
+		});
+	}
+	/**
+	* {@inheritDoc IPoolContract.sharesToUnderlying}
+	*/
+	sharesToUnderlying(shares) {
+		return this.dieselRate === 0n ? shares : shares * this.dieselRate / RAY;
+	}
+	/**
+	* {@inheritDoc IPoolContract.underlyingToShares}
+	*/
+	underlyingToShares(underlying, roundUp = false) {
+		if (this.dieselRate === 0n) return underlying;
+		return roundUp ? (underlying * RAY + this.dieselRate - 1n) / this.dieselRate : underlying * RAY / this.dieselRate;
+	}
+	/**
 	* {@inheritDoc IPoolContract.unwrappedUnderlying}
 	*/
 	get unwrappedUnderlying() {

package/dist/esm/onchain/market/rwa/securitize/SecuritizeRWAFactory.js

@@ -148,9 +148,10 @@ var SecuritizeRWAFactory = class extends BaseContract {
 	/**
 	* {@inheritDoc IRWAFactory.getInvestor}
 	*/
-	async getInvestor(creditAccount, fromCache) {
+	async getInvestor(creditAccount, options) {
+		const { fromCache, blockNumber } = options ?? {};
 		if (fromCache && this.#investorCache.has(creditAccount)) return this.#investorCache.mustGet(creditAccount);
-		const investor = await this.contract.read.getInvestor([creditAccount]);
+		const investor = await this.contract.read.getInvestor([creditAccount], { blockNumber });
 		if (fromCache) this.#investorCache.upsert(creditAccount, investor);
 		return investor;
 	}

package/dist/esm/onchain/market/zapper/ZapperContract.js

@@ -1,7 +1,8 @@
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
+import { sdkErr, sdkOk } from "../../../model/result.js";
+import "../../../model/index.js";
 import { iZapperAbi } from "../../../abi/iZapper.js";
-import { UnsupportedZapperFunctionError } from "./errors.js";
 //#region src/onchain/market/zapper/ZapperContract.ts
 /**
 * Base contract for every Gearbox zapper. Specialized zappers (e.g.
@@ -32,8 +33,9 @@ var ZapperContract = class extends BaseContract {
 		this.tokenOut = data.tokenOut;
 	}
 	/**
-	* Decodes zapper calldata into {@link ParsedZapperOperation}.
-	* Throws {@link UnsupportedZapperFunctionError} for unknown selectors.
+	* Decodes zapper calldata into {@link ParsedZapperOperation} behind `ok`,
+	* or refuses with {@link UnsupportedZapperFunctionError} for unknown
+	* selectors.
 	*/
 	parseOperation(calldata, value) {
 		const parsed = this.parseFunctionDataV2(calldata);
@@ -42,7 +44,7 @@ var ZapperContract = class extends BaseContract {
 		const zapper = this.address;
 		const underlying = this.sdk.marketRegister.findByPool(pool).underlying;
 		const receiver = rawArgs.receiver;
-		if (parsed.functionName.startsWith("deposit")) return {
+		if (parsed.functionName.startsWith("deposit")) return sdkOk({
 			operation: "Deposit",
 			pool,
 			zapper,
@@ -50,16 +52,21 @@ var ZapperContract = class extends BaseContract {
 			assets: rawArgs.tokenInAmount ?? value ?? 0n,
 			underlying,
 			referralCode: rawArgs.referralCode
-		};
-		if (parsed.functionName.startsWith("redeem")) return {
+		});
+		if (parsed.functionName.startsWith("redeem")) return sdkOk({
 			operation: "Redeem",
 			pool,
 			zapper,
 			receiver,
 			shares: rawArgs.tokenOutAmount,
 			underlying
-		};
-		throw new UnsupportedZapperFunctionError(zapper, parsed.functionName);
+		});
+		return sdkErr({
+			code: "unsupportedZapperFunction",
+			message: `unsupported zapper function "${parsed.functionName}" on ${zapper}`,
+			zapper,
+			functionName: parsed.functionName
+		});
 	}
 	/**
 	* Redeems pool shares (diesel tokens) for the underlying asset via this zapper.

package/dist/esm/onchain/market/zapper/errors.js

@@ -1,17 +1 @@
-//#region src/onchain/market/zapper/errors.ts
-/**
-* Thrown when a zapper call uses a function other than a known
-* `deposit`/`redeem` variant.
-*/
-var UnsupportedZapperFunctionError = class extends Error {
-	zapper;
-	functionName;
-	constructor(zapper, functionName) {
-		super(`unsupported zapper function "${functionName}" on ${zapper}`);
-		this.name = "UnsupportedZapperFunctionError";
-		this.zapper = zapper;
-		this.functionName = functionName;
-	}
-};
-//#endregion
-export { UnsupportedZapperFunctionError };
+export {};

package/dist/esm/onchain/market/zapper/index.js

@@ -1,7 +1,7 @@
-import { UnsupportedZapperFunctionError } from "./errors.js";
 import { ZapperContract } from "./ZapperContract.js";
 import { IERC20ZapperContract } from "./IERC20ZapperContract.js";
 import { IETHZapperContract } from "./IETHZapperContract.js";
 import { createZapper } from "./createZapper.js";
+import "./errors.js";
 import "./types.js";
-export { IERC20ZapperContract, IETHZapperContract, UnsupportedZapperFunctionError, ZapperContract, createZapper };
+export { IERC20ZapperContract, IETHZapperContract, ZapperContract, createZapper };

package/dist/esm/onchain/opportunities/index.js

@@ -1,3 +1,4 @@
 import { MultichainOpportunitiesService } from "./MultichainOpportunitiesService.js";
 import { OpportunitiesService } from "./OpportunitiesService.js";
+import "./types.js";
 export { MultichainOpportunitiesService, OpportunitiesService };