@gearbox-protocol/sdk 16.3.0-next.3 → 16.3.0-next.4

package/dist/esm/model/index.js

@@ -7,8 +7,8 @@ import { FILTER_ALL, isFilterSet } from "./filters.js";
 import { booleanParamSchema, encodeFlag, filterAllSchema, filterable } from "./filters.schema.js";
 import { curatorNameSchema, curatorSchema } from "./curators.schema.js";
 import { delayedReceivedAssetSchema, instantReceivedAssetSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionSchema, receivedAssetSchema } from "./liquidations.schema.js";
-import { KYC_PROTOCOLS, KYC_REGISTRATION_LINKS, RWA_FACTORY_SECURITIZE, RWA_FACTORY_TYPES, SECURITIZE_REGISTER_VAULT_TYPES } from "./rwa.js";
-import { kycProtocolSchema, kycRequirementSchema } from "./rwa.schema.js";
+import { KYC_REGISTRATION_LINKS, RWA_FACTORY_SECURITIZE, RWA_FACTORY_TYPES, RWA_PROTOCOLS, SECURITIZE_REGISTER_VAULT_TYPES } from "./rwa.js";
+import { kycRequirementSchema, rwaProtocolSchema } from "./rwa.schema.js";
 import { apyBreakdownSchema, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pointRewardsSchema, pointsProgramSchema, poolOpportunityDetailSchema, poolOpportunityKeySchema, poolOpportunitySchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, rewardsSchema, strategyOpportunityDetailSchema, strategyOpportunityKeySchema, strategyOpportunitySchema, tokenRewardsSchema } from "./opportunities.schema.js";
 import { borrowRateBreakdownSchema, pnlBreakdownSchema, pointsProgramPnLSchema, pointsRewardsPnLSchema, poolPositionKeySchema, poolPositionSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionKeySchema, positionKindSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionsTotalsSchema, rewardsPnLSchema, strategyPositionKeySchema, strategyPositionSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema } from "./positions.schema.js";
 import { ANALYTICS_POSITIONS_DEFAULT_LIMIT, ANALYTICS_POSITIONS_MAX_LIMIT, analyticsChartQueryOptionsSchema, analyticsChartQueryParamsSchema, analyticsChartQuerySchema, analyticsPositionListOptionsSchema, analyticsPositionListQueryParamsSchema, analyticsPositionListQuerySchema, analyticsPositionPageSchema, analyticsPositionSchema, analyticsPositionSortFieldSchema, analyticsSortDirectionSchema } from "./analytics.schema.js";
@@ -32,4 +32,4 @@ import { chainFailedSchema, chainMetadataSchema, chainSucceededSchema, dataSourc
 import { safeValue, sdkErr, sdkOk } from "./result.js";
 import "./withdrawals.js";
 import { positionClaimableWithdrawalSchema, positionPendingWithdrawalSchema, positionWithdrawalsSchema, withdrawalOutputAmountSchema } from "./withdrawals.schema.js";
-export { ANALYTICS_POSITIONS_DEFAULT_LIMIT, ANALYTICS_POSITIONS_MAX_LIMIT, CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, FILTER_ALL, KYC_PROTOCOLS, KYC_REGISTRATION_LINKS, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, PROTOCOL_CHART_METRICS, RWA_FACTORY_SECURITIZE, RWA_FACTORY_TYPES, SECURITIZE_REGISTER_VAULT_TYPES, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, STRATEGY_POSITION_COLLATERAL_ERROR, amountSchema, analyticsChartQueryOptionsSchema, analyticsChartQueryParamsSchema, analyticsChartQuerySchema, analyticsPositionListOptionsSchema, analyticsPositionListQueryParamsSchema, analyticsPositionListQuerySchema, analyticsPositionPageSchema, analyticsPositionSchema, analyticsPositionSortFieldSchema, analyticsSortDirectionSchema, apyBreakdownSchema, asEstimated, assetTypeSchema, backendPreferred, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, creditAccountFrozen, creditAccountNotEmpty, creditAccountNotFound, creditManagerPaused, curatorNameSchema, curatorSchema, dataSourceSchema, debtOutOfRange, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, forbiddenToken, instantReceivedAssetSchema, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, isFilterSet, kycProtocolSchema, kycRequirementSchema, leverageOutOfRange, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, liquidatorNotEligible, malformedTransaction, marketExpired, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, notEmergencyLiquidator, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPaused, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, poolSunset, positionClaimableWithdrawalSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionPendingWithdrawalSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionWithdrawalsSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, protocolChartMetricSchema, quotaAssetSchema, quotaCountExceeded, quotaLimitReached, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, rwaOpenRequirementsNotMet, safeValue, sdkErr, sdkOk, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema, underlyingTokenSchema, unexpectedFailure, unpriceableTokenError, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress, withdrawalOutputAmountSchema };
+export { ANALYTICS_POSITIONS_DEFAULT_LIMIT, ANALYTICS_POSITIONS_MAX_LIMIT, CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, FILTER_ALL, KYC_REGISTRATION_LINKS, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, PROTOCOL_CHART_METRICS, RWA_FACTORY_SECURITIZE, RWA_FACTORY_TYPES, RWA_PROTOCOLS, SECURITIZE_REGISTER_VAULT_TYPES, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, STRATEGY_POSITION_COLLATERAL_ERROR, amountSchema, analyticsChartQueryOptionsSchema, analyticsChartQueryParamsSchema, analyticsChartQuerySchema, analyticsPositionListOptionsSchema, analyticsPositionListQueryParamsSchema, analyticsPositionListQuerySchema, analyticsPositionPageSchema, analyticsPositionSchema, analyticsPositionSortFieldSchema, analyticsSortDirectionSchema, apyBreakdownSchema, asEstimated, assetTypeSchema, backendPreferred, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, creditAccountFrozen, creditAccountNotEmpty, creditAccountNotFound, creditManagerPaused, curatorNameSchema, curatorSchema, dataSourceSchema, debtOutOfRange, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, forbiddenToken, instantReceivedAssetSchema, insufficientAllowance, insufficientBalance, insufficientCollateral, insufficientPoolLiquidity, isFilterSet, kycRequirementSchema, leverageOutOfRange, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, liquidatorNotEligible, malformedTransaction, marketExpired, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, multipleDelayedWithdrawals, noDelayedRoute, noRecordedIntent, noStrategyTargetCollateral, notEmergencyLiquidator, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPaused, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, poolSunset, positionClaimableWithdrawalSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionPendingWithdrawalSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionWithdrawalsSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, protocolChartMetricSchema, quotaAssetSchema, quotaCountExceeded, quotaLimitReached, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, rwaOpenRequirementsNotMet, rwaProtocolSchema, safeValue, sdkErr, sdkOk, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema, underlyingTokenSchema, unexpectedFailure, unpriceableTokenError, unsupportedCollateralToken, unsupportedTokenPair, withdrawalInProgress, withdrawalOutputAmountSchema };

package/dist/esm/model/rwa.js

@@ -34,15 +34,15 @@ const SECURITIZE_REGISTER_VAULT_TYPES = { RegisterVault: [
 	}
 ] };
 /**
-* KYC providers a strategy may be gated by
+* RWA protocols that require dedicated flows
 **/
-const KYC_PROTOCOLS = ["securitize", "midas"];
+const RWA_PROTOCOLS = ["securitize", "midas"];
 /**
-* Hardcoded registration URLs for each {@link KycProtocol}.
+* Hardcoded registration URLs for each {@link RWAProtocol}.
 **/
 const KYC_REGISTRATION_LINKS = {
 	securitize: "https://securitize.io/",
 	midas: "https://form.typeform.com/to/DqZaw6kr"
 };
 //#endregion
-export { KYC_PROTOCOLS, KYC_REGISTRATION_LINKS, RWA_FACTORY_SECURITIZE, RWA_FACTORY_TYPES, SECURITIZE_REGISTER_VAULT_TYPES };
+export { KYC_REGISTRATION_LINKS, RWA_FACTORY_SECURITIZE, RWA_FACTORY_TYPES, RWA_PROTOCOLS, SECURITIZE_REGISTER_VAULT_TYPES };

package/dist/esm/model/rwa.schema.js

@@ -1,18 +1,18 @@
 import { tokenSchema } from "./primitives.schema.js";
-import { KYC_PROTOCOLS } from "./rwa.js";
+import { RWA_PROTOCOLS } from "./rwa.js";
 import { z } from "zod/v4";
 //#region src/model/rwa.schema.ts
 /**
-* {@link ./rwa.js#KycProtocol}
+* {@link ./rwa.js#RWAProtocol}
 **/
-const kycProtocolSchema = z.enum(KYC_PROTOCOLS);
+const rwaProtocolSchema = z.enum(RWA_PROTOCOLS);
 /**
 * {@link ./rwa.js#KycRequirement}
 **/
 const kycRequirementSchema = z.object({
-	protocol: kycProtocolSchema,
+	protocol: rwaProtocolSchema,
 	token: tokenSchema.optional(),
 	registrationLink: z.string()
 });
 //#endregion
-export { kycProtocolSchema, kycRequirementSchema };
+export { kycRequirementSchema, rwaProtocolSchema };

package/dist/esm/offchain/opportunities/OffchainOpportunities.js

@@ -35,7 +35,7 @@ var OffchainOpportunities = class extends AbstractOffchainNamespace {
 	/**
 	* {@inheritDoc IOffchainOpportunities.getStrategy}
 	**/
-	async getStrategy(key, _wallet) {
+	async getStrategy(key) {
 		return this.get({
 			path: this.#strategyPath(key),
 			schema: strategyOpportunityDetailSchema

package/dist/esm/onchain/accounts/CreditAccountsServiceV310.js

@@ -188,9 +188,7 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 	* {@inheritDoc ICreditAccountsService.getOpenAccountRequirements}
 	*/
 	async getOpenAccountRequirements(borrower, creditManager, props) {
-		const { rwaFactory } = this.sdk.marketRegister.findCreditManager(creditManager);
-		if (!rwaFactory) return;
-		return rwaFactory.getOpenAccountRequirements(borrower, props);
+		return (await this.sdk.marketRegister.findCreditManager(creditManager).degenNFT())?.getOpenAccountRequirements(borrower, props);
 	}
 	/**
 	* {@inheritDoc ICreditAccountsService.openCA}

package/dist/esm/onchain/accounts/liquidations/LiquidationsService.js

@@ -9,9 +9,9 @@ import "../../utils/index.js";
 import { SDKConstruct } from "../../base/SDKConstruct.js";
 import "../../base/index.js";
 import { usdToNumber } from "../../market/math.js";
+import { RWA_LIQUIDATOR_MIDAS } from "../../market/rwa/midas/constants.js";
 import { matchesLiquidatableAccountFilter } from "../../../model/liquidations.js";
 import "../../../model/index.js";
-import { RWA_LIQUIDATOR_MIDAS } from "../../market/rwa/midas/constants.js";
 import { RWA_LIQUIDATOR_SECURITIZE } from "../../market/rwa/securitize/constants.js";
 import { dominantCollateral } from "../../market/credit/collateralUtils.js";
 import { MidasLiquidatorContract } from "../../market/rwa/midas/MidasLiquidatorContract.js";

package/dist/esm/onchain/market/credit/CreditSuite.js

@@ -7,8 +7,6 @@ import "../../utils/index.js";
 import { SDKConstruct } from "../../base/SDKConstruct.js";
 import "../../base/index.js";
 import { calcBorrowApy, calcQuotaRate, minSeizedAmount, optimalHFForPartialLiquidation, optimalRepaidAmount } from "../math.js";
-import { KYC_REGISTRATION_LINKS } from "../../../model/rwa.js";
-import "../../../model/index.js";
 import { createDegenNFT } from "../rwa/createDegenNFT.js";
 import { strategyName } from "../strategyName.js";
 import { dominantCollateral, isStrategyCollateral, pickStrategyTargetCollateral } from "./collateralUtils.js";
@@ -125,25 +123,37 @@ var CreditSuite = class extends SDKConstruct {
 	degenNFT() {
 		const address = this.creditFacade.degenNFT;
 		if (isAddressEqual(address, "0x0000000000000000000000000000000000000000")) return Promise.resolve(void 0);
+		const factoryNft = this.rwaFactory?.degenNFT;
+		if (factoryNft && isAddressEqual(factoryNft.address, address)) return Promise.resolve(factoryNft);
 		if (!this.#degenNFT) this.#degenNFT = createDegenNFT(this.sdk, address);
 		return this.#degenNFT;
 	}
 	/**
-	* What `wallet` still has to do before the facade lets it open an account;
-	* `null` when nothing (no degen NFT, not a KYC gate, or already eligible).
+	* The KYC gate of this suite's strategy; `null` when there is none.
+	* Wallet-independent.
 	*/
-	async kycRequirement(wallet, targetCollateral) {
+	async kycRequirement(targetCollateral) {
 		const nft = await this.degenNFT();
 		if (!nft) return null;
-		const { eligible, token } = await nft.checkKyc(wallet, targetCollateral);
-		if (eligible) return null;
+		const tokens = await nft.getTokens();
+		const token = tokens.find((t) => isAddressEqual(t, targetCollateral)) ?? tokens[0];
 		return {
 			protocol: nft.protocol,
-			token: this.tokensMeta.getToken(token),
-			registrationLink: KYC_REGISTRATION_LINKS[nft.protocol]
+			token: token ? this.tokensMeta.getToken(token) : void 0,
+			registrationLink: nft.registrationLink
 		};
 	}
 	/**
+	* Whether `wallet` may open this suite's strategy today; `true` when there
+	* is no KYC gate.
+	*/
+	async isEligibleForStrategy(wallet, targetCollateral) {
+		const nft = await this.degenNFT();
+		if (!nft) return true;
+		const requirements = await nft.getOpenAccountRequirements(wallet, { tokenOutAddress: targetCollateral });
+		return nft.isRegistered(requirements);
+	}
+	/**
 	* Builds a transaction that executes a multicall on one of this suite's
 	* credit accounts.
 	*

package/dist/esm/onchain/market/rwa/midas/MidasDegenNFT.js

@@ -5,14 +5,23 @@ import "../../adapters/abi/index.js";
 import { iMidasDegenNFTAbi } from "../../../../abi/rwa/iMidasDegenNFT.js";
 import "./constants.js";
 import { iMidasAccessControlAbi } from "../../../../abi/rwa/iMidasAccessControl.js";
+import { KYC_REGISTRATION_LINKS } from "../../../../model/rwa.js";
+import "../../../../model/index.js";
 import { decodeAbiParameters } from "viem";
 //#region src/onchain/market/rwa/midas/MidasDegenNFT.ts
 const abi = iMidasDegenNFTAbi;
+/**
+* Midas is an RWA protocol without a factory: accounts open through the plain
+* facade. Only a Permissioned-mode gateway deploys a degen NFT, so a Midas
+* strategy that does not require KYC has no NFT at all.
+*/
 var MidasDegenNFT = class extends BaseContract {
 	protocol = "midas";
+	registrationLink = KYC_REGISTRATION_LINKS.midas;
 	gateway;
 	accessControl;
 	greenlistedRole;
+	#mToken;
 	constructor(sdk, baseParams) {
 		super(sdk, {
 			...baseParams,
@@ -30,9 +39,26 @@ var MidasDegenNFT = class extends BaseContract {
 		this.accessControl = accessControl;
 		this.greenlistedRole = greenlistedRole;
 	}
-	/** Same predicate `MidasDegenNFT.burn` reverts on; the mToken rides along in the batch. */
-	async checkKyc(wallet, _targetCollateral) {
-		const [eligible, token] = await this.client.multicall({
+	async getTokens() {
+		return [await this.#mTokenAddress()];
+	}
+	/**
+	* Same predicate `MidasDegenNFT.burn` reverts on; the mToken rides along in
+	* the batch until it is cached.
+	*/
+	async getOpenAccountRequirements(wallet, _props) {
+		const token = this.#mToken;
+		if (token !== void 0) return {
+			protocol: "midas",
+			token,
+			greenlisted: await this.client.readContract({
+				abi: iMidasAccessControlAbi,
+				address: this.accessControl,
+				functionName: "hasRole",
+				args: [this.greenlistedRole, wallet]
+			})
+		};
+		const [greenlisted, mToken] = await this.client.multicall({
 			allowFailure: false,
 			contracts: [{
 				abi: iMidasAccessControlAbi,
@@ -45,11 +71,25 @@ var MidasDegenNFT = class extends BaseContract {
 				functionName: "mToken"
 			}]
 		});
+		this.#mToken = mToken;
 		return {
-			eligible,
-			token
+			protocol: "midas",
+			token: mToken,
+			greenlisted
 		};
 	}
+	isRegistered(requirements) {
+		return requirements.greenlisted;
+	}
+	getMissingRequirements() {}
+	async #mTokenAddress() {
+		if (this.#mToken === void 0) this.#mToken = await this.client.readContract({
+			abi: iMidasGatewayV311Abi,
+			address: this.gateway,
+			functionName: "mToken"
+		});
+		return this.#mToken;
+	}
 };
 //#endregion
 export { MidasDegenNFT };

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

@@ -1,13 +1,23 @@
+import { AddressSet } from "../../../utils/AddressSet.js";
+import "../../../utils/index.js";
 import { BaseContract } from "../../../base/BaseContract.js";
 import "../../../base/index.js";
+import { KYC_REGISTRATION_LINKS } from "../../../../model/rwa.js";
+import "../../../../model/index.js";
 import { DEGEN_NFT_SECURITIZE } from "./constants.js";
 import { iSecuritizeDegenNFTAbi } from "../../../../abi/rwa/iSecuritizeDegenNFT.js";
-import { isAddressEqual } from "viem";
 //#region src/onchain/market/rwa/securitize/SecuritizeDegenNFT.ts
 const abi = iSecuritizeDegenNFTAbi;
+/**
+* Securitize always has a factory, which deploys this NFT. DS-token data,
+* registrars and cached signatures live here; the factory only builds txs
+* and looks up investor/wallet addresses.
+*/
 var SecuritizeDegenNFT = class extends BaseContract {
 	protocol = "securitize";
+	registrationLink = KYC_REGISTRATION_LINKS.securitize;
 	factory;
+	#sdk;
 	constructor(sdk, address, factory) {
 		super(sdk, {
 			addr: address,
@@ -16,19 +26,54 @@ var SecuritizeDegenNFT = class extends BaseContract {
 			name: "SecuritizeDegenNFT",
 			abi
 		});
+		this.#sdk = sdk;
 		this.factory = factory;
 	}
-	/** Registration on Securitize is the only KYC step; pending EIP-712 signatures are not. */
-	async checkKyc(wallet, targetCollateral) {
-		const { factory } = this;
-		if (!factory.getTokens().some((t) => isAddressEqual(t, targetCollateral))) return {
-			eligible: true,
-			token: targetCollateral
+	async getTokens() {
+		return this.factory.getTokens();
+	}
+	/**
+	* Registration on Securitize is the protocol-side KYC step; pending
+	* EIP-712 signatures are tx-side leftover, not KYC.
+	*/
+	async getOpenAccountRequirements(wallet, props) {
+		const tokensToRegister = new AddressSet(this.factory.getTokens()).has(props.tokenOutAddress) ? new AddressSet([props.tokenOutAddress]) : new AddressSet();
+		if (tokensToRegister.size === 0) return {
+			protocol: "securitize",
+			factory: this.factory.address,
+			securitizeTokensToRegister: [],
+			tokensToRegister: [],
+			requiredSignatures: []
+		};
+		const [investorData] = await this.#sdk.rwa.getInvestorData(wallet, [this.factory.address]);
+		const registredTokens = new AddressSet(investorData.registeredTokens);
+		const signedTokens = new AddressSet(investorData.cachedSignatures.map((s) => s.token));
+		const unsignedTokens = tokensToRegister.difference(signedTokens);
+		const securitizeTokensToRegister = tokensToRegister.difference(registredTokens);
+		const requiredSignatures = investorData.registerVaultMessages.filter((m) => unsignedTokens.has(m.message.token));
+		return {
+			protocol: "securitize",
+			factory: this.factory.address,
+			securitizeTokensToRegister: Array.from(securitizeTokensToRegister),
+			tokensToRegister: Array.from(tokensToRegister),
+			requiredSignatures
 		};
-		const req = await factory.getOpenAccountRequirements(wallet, { tokenOutAddress: targetCollateral });
+	}
+	isRegistered(requirements) {
+		return requirements.securitizeTokensToRegister.length === 0;
+	}
+	/**
+	* A required signature is omitted when `providedArgs.signaturesToCache`
+	* already carries a signature for the same token: the transaction caches it
+	* on-chain as part of the operation.
+	*/
+	getMissingRequirements(requirements, providedArgs) {
+		const providedTokens = new AddressSet((providedArgs?.signaturesToCache ?? []).map((s) => s.token));
+		const requiredSignatures = requirements.requiredSignatures.filter((message) => !providedTokens.has(message.message.token));
+		if (requiredSignatures.length === 0) return;
 		return {
-			eligible: !req || req.securitizeTokensToRegister.length === 0,
-			token: req?.securitizeTokensToRegister[0] ?? targetCollateral
+			protocol: "securitize",
+			requiredSignatures
 		};
 	}
 };

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

@@ -1,5 +1,4 @@
 import { AddressMap } from "../../../utils/AddressMap.js";
-import { AddressSet } from "../../../utils/AddressSet.js";
 import "../../../utils/index.js";
 import { BaseContract } from "../../../base/BaseContract.js";
 import "../../../base/index.js";
@@ -11,7 +10,6 @@ import { decodeAbiParameters } from "viem";
 //#region src/onchain/market/rwa/securitize/SecuritizeRWAFactory.ts
 const abi = iSecuritizeRWAFactoryAbi;
 var SecuritizeRWAFactory = class extends BaseContract {
-	#sdk;
 	#investorCache = new AddressMap();
 	degenNFT;
 	owner;
@@ -23,7 +21,6 @@ var SecuritizeRWAFactory = class extends BaseContract {
 			name: "SecuritizeRWAFactory",
 			abi
 		});
-		this.#sdk = sdk;
 		const decoded = decodeAbiParameters([
 			{
 				name: "owner",
@@ -184,40 +181,6 @@ var SecuritizeRWAFactory = class extends BaseContract {
 		});
 	}
 	/**
-	* {@inheritDoc IRWAFactory.getOpenAccountRequirements}
-	*/
-	async getOpenAccountRequirements(investor, props) {
-		const [investorData] = await this.#sdk.rwa.getInvestorData(investor, [this.address]);
-		const tokensToRegister = new AddressSet([props.tokenOutAddress]);
-		const registredTokens = new AddressSet(investorData.registeredTokens);
-		const signedTokens = new AddressSet(investorData.cachedSignatures.map((s) => s.token));
-		const unsignedTokens = tokensToRegister.difference(signedTokens);
-		const securitizeTokensToRegister = tokensToRegister.difference(registredTokens);
-		const requiredSignatures = investorData.registerVaultMessages.filter((m) => unsignedTokens.has(m.message.token));
-		return {
-			type: RWA_FACTORY_SECURITIZE,
-			securitizeTokensToRegister: Array.from(securitizeTokensToRegister),
-			tokensToRegister: Array.from(tokensToRegister),
-			requiredSignatures
-		};
-	}
-	/**
-	* {@inheritDoc IRWAFactory.getMissingRequirements}
-	*
-	* A required signature is omitted when `providedArgs.signaturesToCache`
-	* already carries a signature for the same token: the transaction caches it
-	* on-chain as part of the operation.
-	*/
-	getMissingRequirements(requirements, providedArgs) {
-		const providedTokens = new AddressSet((providedArgs?.signaturesToCache ?? []).map((s) => s.token));
-		const requiredSignatures = requirements.requiredSignatures.filter((message) => !providedTokens.has(message.message.token));
-		if (requiredSignatures.length === 0) return;
-		return {
-			type: RWA_FACTORY_SECURITIZE,
-			requiredSignatures
-		};
-	}
-	/**
 	* {@inheritDoc IRWAFactory.openCreditAccount}
 	*/
 	openCreditAccount(creditManager, calls, args) {

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

@@ -37,12 +37,18 @@ var MultichainOpportunitiesService = class extends MultichainConstruct {
 	*
 	* See {@link MultichainOpportunitiesService.getPool}.
 	**/
-	async getStrategy(key, wallet) {
+	async getStrategy(key) {
 		return this.queryChain({
 			network: key.chainId,
-			run: (sdk) => sdk.opportunities.getStrategy(key, wallet)
+			run: (sdk) => sdk.opportunities.getStrategy(key)
 		});
 	}
+	/**
+	* {@inheritDoc OpportunitiesService.isEligibleForStrategy}
+	**/
+	async isEligibleForStrategy(key, wallet) {
+		return this.sdk.chain(key.chainId).opportunities.isEligibleForStrategy(key, wallet);
+	}
 };
 //#endregion
 export { MultichainOpportunitiesService };

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

@@ -36,22 +36,34 @@ var OpportunitiesService = class extends SDKConstruct {
 	* A single strategy opportunity plus the rate curve of the pool it borrows
 	* from and the price feeds its liquidation price depends on.
 	*
-	* @param wallet - When given, `kyc` says whether this wallet must register
-	* with the strategy's KYC provider first; `null` otherwise.
+	* `kyc` is the strategy's KYC gate, independent of any wallet.
 	*
 	* @throws If the credit manager is unknown, or does not currently offer a
 	* strategy.
 	**/
-	async getStrategy(key, wallet) {
+	async getStrategy(key) {
 		const suite = this.sdk.marketRegister.findCreditManager(key.creditManager);
 		const detail = suite.strategyOpportunityDetail();
 		if (!detail) throw new Error(`credit manager ${key.creditManager} does not currently offer a strategy`);
-		const kyc = wallet ? await suite.kycRequirement(wallet, detail.targetCollateral.address) : null;
+		const kyc = await suite.kycRequirement(detail.targetCollateral.address);
 		return {
 			...detail,
 			kyc
 		};
 	}
+	/**
+	* Whether `wallet` may open this strategy today: `true` when it is not
+	* KYC-gated or the wallet already passed the gate.
+	*
+	* @throws If the credit manager is unknown, or does not currently offer a
+	* strategy.
+	**/
+	async isEligibleForStrategy(key, wallet) {
+		const suite = this.sdk.marketRegister.findCreditManager(key.creditManager);
+		const opportunity = suite.strategyOpportunity();
+		if (!opportunity) throw new Error(`credit manager ${key.creditManager} does not currently offer a strategy`);
+		return suite.isEligibleForStrategy(wallet, opportunity.targetCollateral.address);
+	}
 };
 //#endregion
 export { OpportunitiesService };

package/dist/esm/onchain/preview/parse/parseRWAFactoryOperationCalldata.js

@@ -1,7 +1,7 @@
 import { hexEq } from "../../utils/hex.js";
 import { AbstractAdapterContract } from "../../market/adapters/contracts/AbstractAdapter.js";
 import { CreditFacadeV310Contract } from "../../market/credit/CreditFacadeV310Contract.js";
-import { RWA_FACTORY_SECURITIZE } from "../../../model/rwa.js";
+import "../../../model/rwa.js";
 import "../../../model/index.js";
 import { isRWAFactory } from "../../market/rwa/types.js";
 import { classifyInnerOperations } from "./classifyInnerOperations.js";
@@ -32,7 +32,7 @@ function parseSecuritizeOperationCalldata(sdk, factory, calldata) {
 	const { rawArgs } = parsed;
 	const innerCalls = rawArgs.calls ?? [];
 	const args = {
-		type: RWA_FACTORY_SECURITIZE,
+		protocol: "securitize",
 		tokensToRegister: [...rawArgs.tokensToRegister ?? []],
 		signaturesToCache: [...rawArgs.signaturesToCache ?? []]
 	};

package/dist/esm/onchain/validation/bundles/checkCreditOperation.js

@@ -50,7 +50,7 @@ async function checkCreditOperation(args) {
 		preview,
 		sender,
 		blockNumber
-	}), preview.operation === "RWAOpenCreditAccount" ? checkRWAOpening({
+	}), preview.operation === "OpenCreditAccount" || preview.operation === "RWAOpenCreditAccount" ? checkRWAOpening({
 		sdk,
 		preview,
 		sender

package/dist/esm/onchain/validation/bundles/checkRWAOpenRequirements.js

@@ -5,24 +5,24 @@ import { toToken } from "../helpers/token.js";
 import "../helpers/index.js";
 //#region src/onchain/validation/bundles/checkRWAOpenRequirements.ts
 /**
-* The RWA factory is satisfied that `wallet` may open on `token` with the
+* The degen NFT is satisfied that `wallet` may open on `token` with the
 * registration args already on the transaction.
 */
 async function checkRWAOpenRequirements(input) {
 	const { sdk, wallet, creditManager, token, providedArgs } = input;
 	try {
-		const requirements = await sdk.accounts.getOpenAccountRequirements(wallet, creditManager, { tokenOutAddress: token });
-		if (!requirements) return [];
-		const { rwaFactory } = sdk.marketRegister.findByCreditManager(creditManager);
-		if (!rwaFactory) throw new Error(`no RWA factory for credit manager ${creditManager}`);
-		const missing = rwaFactory.getMissingRequirements(requirements, providedArgs);
-		if (!missing && requirements.securitizeTokensToRegister.length === 0) return [];
+		const nft = await sdk.marketRegister.findCreditManager(creditManager).degenNFT();
+		if (!nft) return [];
+		const requirements = await nft.getOpenAccountRequirements(wallet, { tokenOutAddress: token });
+		const missing = nft.getMissingRequirements(requirements, providedArgs);
+		if (!missing && nft.isRegistered(requirements)) return [];
 		return [rwaOpenRequirementsNotMet({
 			token: toToken(sdk, token),
 			creditManager,
-			factory: rwaFactory.address,
+			protocol: nft.protocol,
+			registrationLink: nft.registrationLink,
 			requirements,
-			...missing === void 0 ? {} : { missing }
+			missing
 		})];
 	} catch (cause) {
 		return [unexpectedFailure(cause, "read the RWA opening requirements")];

package/dist/esm/onchain/validation/bundles/checkRWAOpening.js

@@ -2,21 +2,22 @@ import { AddressSet } from "../../utils/AddressSet.js";
 import { checkRWAOpenRequirements } from "./checkRWAOpenRequirements.js";
 //#region src/onchain/validation/bundles/checkRWAOpening.ts
 /**
-* Per factory-gated token among `collateralAdded ∪ quotas`, whether the
+* Per KYC-gated token among `collateralAdded ∪ quotas`, whether the
 * borrower still has to register or sign before this opening can land.
 */
 async function checkRWAOpening(input) {
 	const { sdk, preview, sender } = input;
-	const { rwaFactory } = sdk.marketRegister.findByCreditManager(preview.creditManager);
-	if (!rwaFactory) return [];
-	const gated = new AddressSet(rwaFactory.getTokens());
+	const nft = await sdk.marketRegister.findCreditManager(preview.creditManager).degenNFT();
+	if (!nft) return [];
+	const gated = new AddressSet(await nft.getTokens());
 	const candidates = new AddressSet([...preview.collateralAdded.map((a) => a.token.address), ...preview.quotas.map((q) => q.token.address)]);
+	const providedArgs = preview.operation === "RWAOpenCreditAccount" ? preview.rwaArgs : void 0;
 	return (await Promise.all([...candidates].filter((token) => gated.has(token)).map((token) => checkRWAOpenRequirements({
 		sdk,
 		wallet: sender,
 		creditManager: preview.creditManager,
 		token,
-		providedArgs: preview.rwaArgs
+		providedArgs
 	})))).flat();
 }
 //#endregion

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

@@ -73,9 +73,9 @@ async function openTx(sdk, request) {
 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;
+	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/types/model/errors/operation-errors.d.ts

@@ -1,6 +1,6 @@
 import { Bps, Token, TokenAmount } from "../primitives.js";
 import { IGearboxError } from "./base.js";
-import { RWAMissingOpenAccountRequirements, RWAOpenAccountRequirements } from "../rwa.js";
+import { RWAMissingOpenAccountRequirements, RWAOpenAccountRequirements, RWAProtocol } from "../rwa.js";
 import { MaxBorrowAmount } from "../../onchain/market/credit/types.js";
 import "../../onchain/index.js";
 import { Address } from "viem";
@@ -201,17 +201,19 @@ interface InsufficientAllowanceError extends IGearboxError {
 /** {@inheritDoc InsufficientAllowanceError} */
 declare function insufficientAllowance(args: Omit<InsufficientAllowanceError, "code" | "message">): InsufficientAllowanceError;
 /**
- * The RWA factory still wants something from the borrower before this token
+ * The RWA protocol still wants something from the borrower before this token
  * can be opened on.
  **/
 interface RWAOpenRequirementsError extends IGearboxError {
   code: "rwaOpenRequirementsNotMet";
   token: Token;
   creditManager: Address;
-  factory: Address;
+  protocol: RWAProtocol;
+  /** Where the wallet completes registration with {@link protocol}. */
+  registrationLink: string;
   /** Always present on the error. */
   requirements: RWAOpenAccountRequirements;
-  /** Absent when only issuer-side registration is pending. */
+  /** Absent when only issuer-side registration is pending (or Midas greenlist). */
   missing?: RWAMissingOpenAccountRequirements;
 }
 /** {@inheritDoc RWAOpenRequirementsError} */