@gearbox-protocol/sdk 17.10.1 → 17.11.0

package/dist/esm/permissionless/api/chains/ChainsNamespace.js

@@ -0,0 +1,179 @@
+import { getChain } from "../../../onchain/chain/chains.js";
+import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
+import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError } from "../errors.js";
+import { chainListSchema, chainSummaryListSchema } from "./schemas.js";
+import { createPublicClient, fallback, http } from "viem";
+//#region src/permissionless/api/chains/ChainsNamespace.ts
+/**
+* The chains the permissionless stack runs on, and the viem clients that
+* reach them.
+*
+* Both halves live here because they answer the same question. Which chains
+* exist is the backend's to decide — it holds rows for chains it does not
+* serve, and those must not be reachable — so the list is also the only
+* honest basis for deciding which clients to build. Nothing is passed in: a
+* caller that had to name the chains could name one the backend does not
+* serve, or miss one it does.
+*
+* The list is fetched once, by {@link attach}, and kept for the client's
+* lifetime:
+*
+* ```ts
+* await permissionless.attach();
+* const chains = permissionless.chains.list();
+* ```
+*
+* Every read before that throws {@link PermissionlessNotAttachedError} rather
+* than answering with an empty list, which would be indistinguishable from a
+* backend that serves nothing.
+*
+* What {@link attach} reads is only what identifies a chain. The counters a
+* list renders next to one are {@link summary}, a second read, because they
+* aggregate over every market the backend knows and nothing should wait on
+* that to start.
+**/
+var ChainsNamespace = class extends AbstractOffchainNamespace {
+	#clients = /* @__PURE__ */ new Map();
+	#chains;
+	#attaching;
+	/** The scope {@link attach} settled on, which {@link summary} follows. */
+	#scope;
+	constructor(options) {
+		super("ChainsNamespace", {
+			...options,
+			chainIds: []
+		});
+	}
+	/**
+	* Reads the chain list off the backend and builds a client for each chain
+	* it names.
+	*
+	* Idempotent, and joins a call already in flight, so a double invocation —
+	* React's StrictMode, two components mounting at once — costs one request.
+	* A second call with a different `scope` is a no-op: the list is decided
+	* once.
+	**/
+	async attach({ scope } = {}) {
+		if (this.#chains) return;
+		this.#attaching ??= this.#load(scope).finally(() => {
+			this.#attaching = void 0;
+		});
+		return this.#attaching;
+	}
+	/**
+	* Whether {@link attach} has completed.
+	**/
+	get isAttached() {
+		return this.#chains !== void 0;
+	}
+	/**
+	* Every chain the backend serves, in the order it listed them.
+	**/
+	list() {
+		if (!this.#chains) throw new PermissionlessNotAttachedError();
+		return this.#chains;
+	}
+	/**
+	* One chain by id, or nothing when the backend does not serve it.
+	*
+	* Reads the attached list rather than a route of its own, which is also
+	* what makes "not served" and "not activated" distinguishable: the first is
+	* absence here, the second is {@link PermissionlessChain.isActivated}.
+	**/
+	find(chainId) {
+		return this.list().find((chain) => chain.chainId === chainId);
+	}
+	/**
+	* The same chains, with the counters a list renders next to them.
+	*
+	* A read of its own, and not part of {@link attach}: the counters aggregate
+	* over every market configurator and market the backend knows, which is
+	* slow enough that waiting on it would hold up the whole client. A list
+	* renders off {@link list} and fills the numbers in when this resolves.
+	*
+	* Nothing is cached — each call is a request — so a caller that renders
+	* this should hold it in whatever already owns its async state.
+	*
+	* Covers the scope {@link attach} settled on unless one is named here, so
+	* the counters describe the list that is already on screen rather than a
+	* different set of chains.
+	*
+	* ```ts
+	* await permissionless.attach();
+	* const chains = permissionless.chains.list();
+	* const withCounters = await permissionless.chains.summary();
+	* ```
+	**/
+	async summary({ scope } = {}) {
+		return this.getData({
+			path: "/chain/summary",
+			query: { scope: scope ?? this.#scope },
+			schema: chainSummaryListSchema
+		});
+	}
+	/**
+	* Chains a client could be built for. A subset of {@link list} — see
+	* {@link client}.
+	**/
+	get chainIds() {
+		if (!this.#chains) throw new PermissionlessNotAttachedError();
+		return [...this.#clients.keys()];
+	}
+	/**
+	* The client for one chain.
+	*
+	* @throws {@link PermissionlessChainUnreachableError} when the backend does
+	* not serve the chain, or serves one this SDK carries no definition for.
+	**/
+	client(chainId) {
+		if (!this.#chains) throw new PermissionlessNotAttachedError();
+		const client = this.#clients.get(chainId);
+		if (!client) throw new PermissionlessChainUnreachableError(chainId);
+		return client;
+	}
+	async #load(scope) {
+		const chains = await this.getData({
+			path: "/chain/list",
+			query: { scope },
+			schema: chainListSchema
+		});
+		this.#scope = scope;
+		this.#clients.clear();
+		for (const { chainId } of chains) {
+			const client = this.#client(chainId);
+			if (client) this.#clients.set(chainId, client);
+		}
+		this.#chains = chains;
+	}
+	/**
+	* A client over the chain's own public endpoints, or nothing when this SDK
+	* has no definition for it.
+	*
+	* The backend will not hand over its endpoints — they carry provider keys —
+	* so the chain definition is all there is to go on. A chain the SDK does
+	* not know stays in {@link list}, because the backend serves it and its
+	* rows are readable through the backend; only the calls that have to reach
+	* it directly fail, and they say which chain they could not reach.
+	**/
+	#client(chainId) {
+		let chain;
+		try {
+			chain = getChain(chainId);
+		} catch {
+			this.logger?.warn(`no chain definition for ${chainId}: it will be listed, but nothing can be read off it directly`);
+			return;
+		}
+		const urls = chain.rpcUrls.default.http;
+		if (urls.length === 0) {
+			this.logger?.warn(`no public endpoint for chain ${chainId}`);
+			return;
+		}
+		const transports = urls.map((url) => http(url));
+		return createPublicClient({
+			chain,
+			transport: transports.length > 1 ? fallback(transports) : transports[0]
+		});
+	}
+};
+//#endregion
+export { ChainsNamespace };

package/dist/esm/permissionless/api/chains/index.js

@@ -0,0 +1,3 @@
+import { ChainsNamespace } from "./ChainsNamespace.js";
+import "./types.js";
+export { ChainsNamespace };

package/dist/esm/permissionless/api/chains/schemas.js

@@ -0,0 +1,30 @@
+import { z } from "zod/v4";
+//#region src/permissionless/api/chains/schemas.ts
+/**
+* Runtime schema for {@link PermissionlessChain}.
+**/
+const chainSchema = z.looseObject({
+	chainId: z.number(),
+	name: z.string(),
+	isPublic: z.boolean(),
+	isActivated: z.boolean(),
+	explorerUrl: z.string()
+});
+/** What `GET /chain/list` answers with. */
+const chainListSchema = z.array(chainSchema);
+/**
+* Runtime schema for {@link PermissionlessChainSummary}.
+*
+* Strict about the two counters on purpose: they are the only reason this
+* read exists, and a backend that answered without them would render as
+* dashes where the numbers belong — a skew worth failing on rather than
+* displaying.
+**/
+const chainSummarySchema = chainSchema.extend({
+	riskCuratorsQty: z.number(),
+	marketsQty: z.number()
+});
+/** What `GET /chain/summary` answers with. */
+const chainSummaryListSchema = z.array(chainSummarySchema);
+//#endregion
+export { chainListSchema, chainSchema, chainSummaryListSchema, chainSummarySchema };

package/dist/esm/permissionless/api/chains/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/permissionless/api/deploy/PermissionlessDeploy.js

@@ -0,0 +1,149 @@
+import { PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "../errors.js";
+import { deriveEffectiveStalenessPeriod } from "./effective-staleness.js";
+import { BytecodeRepositoryContract } from "../../bindings/bytecode-repository.js";
+import { PriceFeedStoreContract } from "../../bindings/price-feed-store.js";
+import "../../deployment/addresses.js";
+import { encodeFunctionParams } from "../../utils/abi-encoder.js";
+import { keccak256, stringToHex, toHex } from "viem";
+//#region src/permissionless/api/deploy/PermissionlessDeploy.ts
+/**
+* Contract type whose first leg needs a bound this client reads off the chain,
+* see {@link PermissionlessDeploy.priceFeed}.
+**/
+const COMPOSITE = "PRICE_FEED::COMPOSITE";
+/** Label the composite's first leg arrives under. */
+const COMPOSITE_FIRST_LEG = "underlyingPriceFeed-0";
+/**
+* Salt a generic contract deploy gets when the caller does not name one. Two
+* deploys of the same type and arguments by the same owner collide under it,
+* which for a singleton like a pause committee is the point.
+**/
+const DEFAULT_DEPLOY_SALT = stringToHex("SALT", { size: 32 });
+/**
+* The salt a price feed is deployed under, derived from its name so that two
+* feeds of the same type and arguments get different addresses.
+**/
+function priceFeedSalt(name) {
+	return keccak256(toHex(name));
+}
+/**
+* Deploys through the BytecodeRepository: the constructor arguments it wants,
+* the CREATE2 address those produce, and the transaction that gets there.
+*
+* Entirely on-chain — no backend is involved, every answer is derived from the
+* target chain. Nothing is sent either: a browser holds the only wallet, so a
+* call prepares the deploy and the caller sends
+* {@link PreparedDeployment.tx} with whatever signs for them.
+*
+* ```ts
+* const feed = await permissionless.deploy.priceFeed({
+*   chainId: 1,
+*   owner: account,
+*   contractType: "PRICE_FEED::CHAINLINK",
+*   version: 310,
+*   name: "WETH / USD",
+*   values,
+* });
+* if (!feed.isAlreadyDeployed) {
+*   await sendRawTx(wallet, { tx: feed.tx });
+* }
+* ```
+**/
+var PermissionlessDeploy = class {
+	#chains;
+	constructor(chains) {
+		this.#chains = chains;
+	}
+	/**
+	* Prepares a price feed deploy from the values a form collected: encodes
+	* them the way the PriceFeedStore reads them back, and reports where the
+	* feed will land.
+	*
+	* A COMPOSITE's first leg is the one case where the values are not taken as
+	* given. It arrives with `stalenessPeriod` 0 whenever it is a derived feed,
+	* because the store registers those with 0 and rejects anything else — which
+	* says nothing about what the leg itself enforces. A composite built on that
+	* 0 can never pass its own staleness check, so the real bound is read off
+	* the leg, see {@link deriveEffectiveStalenessPeriod}.
+	*
+	* The deployed feed reaches {@link PermissionlessOracles.store} only once
+	* it is in the PriceFeedStore, which is a batch the instance owner
+	* executes, see {@link InstanceOwnerTransactions.addFeeds}.
+	**/
+	async priceFeed(args) {
+		const client = this.#chains.client(args.chainId);
+		const salt = this.#priceFeedSalt(args);
+		const values = args.contractType === COMPOSITE ? await this.#withDerivedStaleness(client, args.values) : args.values;
+		const encodedParams = await new PriceFeedStoreContract("0x74A868AC479EE145029bB80827BB77F7B7c441cB", client).encodeConstructorParams(args.contractType, args.version, values);
+		return {
+			...await this.#prepare(client, {
+				contractType: args.contractType,
+				version: args.version,
+				owner: args.owner,
+				encodedParams,
+				salt
+			}),
+			values
+		};
+	}
+	/**
+	* Prepares a generic contract deploy from ABI type/value pairs.
+	*
+	* Unlike a price feed, the arguments here are already typed by the caller,
+	* so nothing is looked up: they are encoded as given and the address they
+	* produce is reported.
+	**/
+	async contract(args) {
+		const client = this.#chains.client(args.chainId);
+		return this.#prepare(client, {
+			contractType: args.contractType,
+			version: args.version,
+			owner: args.owner,
+			encodedParams: encodeFunctionParams(args.values),
+			salt: args.salt ?? DEFAULT_DEPLOY_SALT
+		});
+	}
+	/**
+	* Where the encoded deploy lands, whether it is already there, and the
+	* transaction that puts it there.
+	**/
+	async #prepare(client, args) {
+		const repository = new BytecodeRepositoryContract("0x1cE2B1BE96a082b1b1539F80d5D8f82Ec06a0f9A", client);
+		const [isAlreadyDeployed, address] = await repository.isAlreadyDeployedAddress(args);
+		return {
+			...args,
+			address,
+			isAlreadyDeployed,
+			tx: repository.deployTx({
+				contractType: args.contractType,
+				version: BigInt(args.version),
+				encodedParams: args.encodedParams,
+				salt: args.salt
+			})
+		};
+	}
+	/**
+	* The values with the composite's first leg given the bound it actually
+	* enforces, when it came in without one.
+	**/
+	async #withDerivedStaleness(client, values) {
+		const leg = values[COMPOSITE_FIRST_LEG];
+		if (!leg || typeof leg !== "object" || !leg.address || leg.stalenessPeriod !== 0) return values;
+		const derived = await deriveEffectiveStalenessPeriod(client, leg.address);
+		if (derived === null) throw new PriceFeedStalenessUnknownError(leg.address);
+		return {
+			...values,
+			[COMPOSITE_FIRST_LEG]: {
+				...leg,
+				stalenessPeriod: derived
+			}
+		};
+	}
+	#priceFeedSalt(args) {
+		if (args.salt) return args.salt;
+		if (!args.name) throw new PriceFeedSaltMissingError();
+		return priceFeedSalt(args.name);
+	}
+};
+//#endregion
+export { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt };

package/dist/esm/permissionless/api/deploy/effective-staleness.js

@@ -0,0 +1,46 @@
+import { parseAbi } from "viem";
+//#region src/permissionless/api/deploy/effective-staleness.ts
+const abi = parseAbi(["function stalenessPeriod() view returns (uint32)", "function latestRoundData() view returns (uint80,int256,uint256,uint256,uint80)"]);
+/**
+* Bound for a leg that recomputes its answer on every read and stamps it with
+* the current block (exchange-rate adapters, NAV feeds, Pendle oracles,
+* constant feeds). One second is the tightest value that still satisfies
+* `block.timestamp < updatedAt + stalenessPeriod`.
+**/
+const CURRENT_BLOCK_STALENESS = 1;
+/**
+* The staleness a deployed price feed enforces on the price it reports.
+*
+* This is deliberately not the value the feed is registered with in the
+* PriceFeedStore — derived feeds must be registered with 0 there, and the store
+* rejects anything else for them with `IncorrectParameterException()`. It is
+* the value a parent feed needs when it re-checks the leg's `updatedAt`
+* itself.
+*
+* Returns `null` when it cannot be determined. Callers must surface that
+* rather than substitute a bound: a leg constructed with a staleness its
+* underlying oracle can never satisfy produces a feed that reverts on every
+* read and can never be added to the store.
+**/
+async function deriveEffectiveStalenessPeriod(client, address) {
+	try {
+		const own = await client.readContract({
+			address,
+			abi,
+			functionName: "stalenessPeriod"
+		});
+		if (Number(own) > 0) return Number(own);
+	} catch {}
+	try {
+		const [block, round] = await Promise.all([client.getBlock(), client.readContract({
+			address,
+			abi,
+			functionName: "latestRoundData"
+		})]);
+		const updatedAt = Number(round[3]);
+		if (updatedAt > 0 && updatedAt >= Number(block.timestamp)) return CURRENT_BLOCK_STALENESS;
+	} catch {}
+	return null;
+}
+//#endregion
+export { deriveEffectiveStalenessPeriod };

package/dist/esm/permissionless/api/deploy/index.js

@@ -0,0 +1,4 @@
+import { deriveEffectiveStalenessPeriod } from "./effective-staleness.js";
+import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./PermissionlessDeploy.js";
+import "./types.js";
+export { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, deriveEffectiveStalenessPeriod, priceFeedSalt };

package/dist/esm/permissionless/api/deploy/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/permissionless/api/errors.js

@@ -0,0 +1,77 @@
+import { BaseError } from "viem";
+//#region src/permissionless/api/errors.ts
+/**
+* Thrown when anything is read off {@link ChainsNamespace} before
+* {@link GearboxPermissionless.attach} has completed.
+*
+* The chain list is the backend's answer, so there is nothing to report until
+* it arrives. Answering with an empty list instead would be indistinguishable
+* from a backend that serves no chains at all.
+**/
+var PermissionlessNotAttachedError = class extends BaseError {
+	name = "PermissionlessNotAttachedError";
+	constructor() {
+		super("The client has not attached yet.", { metaMessages: ["Await `attach()` before reading chains off the client."] });
+	}
+};
+/**
+* Thrown when a call has to read a chain the client holds no viem client for.
+*
+* Either the backend does not serve the chain, or it serves one this SDK
+* carries no definition for: endpoints come from the chain definition, since
+* the backend's own urls carry provider keys and are never handed out.
+**/
+var PermissionlessChainUnreachableError = class extends BaseError {
+	name = "PermissionlessChainUnreachableError";
+	/** Chain that was asked for. */
+	chainId;
+	constructor(chainId) {
+		super(`Chain ${chainId} cannot be read directly.`, { metaMessages: ["The backend either does not serve it, or serves a chain this SDK has no definition for."] });
+		this.chainId = chainId;
+	}
+};
+/**
+* Thrown when a rename names a feed the PriceFeedStore does not carry. A name
+* is part of what the store holds, so there is nothing to change on a feed
+* that never reached it.
+**/
+var PriceFeedNotInStoreError = class extends BaseError {
+	name = "PriceFeedNotInStoreError";
+	/** Feed that was named. */
+	priceFeed;
+	chainId;
+	constructor(priceFeed, chainId) {
+		super(`Price feed ${priceFeed} is not in the PriceFeedStore of chain ${chainId}.`, { metaMessages: ["Only a feed the store already carries can be renamed; add it first."] });
+		this.priceFeed = priceFeed;
+		this.chainId = chainId;
+	}
+};
+/**
+* Thrown when a composite feed names a leg whose own staleness bound cannot be
+* read off the chain.
+*
+* Deploying with a placeholder is not an option: a composite whose check can
+* never pass reverts on every read, and the store will not take it. The bound
+* has to be set on the leg first.
+**/
+var PriceFeedStalenessUnknownError = class extends BaseError {
+	name = "PriceFeedStalenessUnknownError";
+	/** Leg whose bound could not be determined. */
+	priceFeed;
+	constructor(priceFeed) {
+		super(`Cannot determine the staleness period of price feed ${priceFeed}.`, { metaMessages: ["Deploying with a placeholder would make this composite permanently stale.", "Set the staleness period on the underlying feed first."] });
+		this.priceFeed = priceFeed;
+	}
+};
+/**
+* Thrown when a price feed deploy names neither a salt nor the name one would
+* be derived from, leaving CREATE2 nothing to distinguish it by.
+**/
+var PriceFeedSaltMissingError = class extends BaseError {
+	name = "PriceFeedSaltMissingError";
+	constructor() {
+		super("A price feed deploy needs either `salt` or `name`.", { metaMessages: ["`name` is hashed into the salt, which is what keeps two feeds of the", "same type and arguments from landing on the same address."] });
+	}
+};
+//#endregion
+export { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError };

package/dist/esm/permissionless/api/index.js

@@ -0,0 +1,13 @@
+import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./errors.js";
+import { ChainsNamespace } from "./chains/ChainsNamespace.js";
+import "./chains/index.js";
+import { deriveEffectiveStalenessPeriod } from "./deploy/effective-staleness.js";
+import { DEFAULT_DEPLOY_SALT, PermissionlessDeploy, priceFeedSalt } from "./deploy/PermissionlessDeploy.js";
+import "./deploy/index.js";
+import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
+import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransactions.js";
+import { GearboxPermissionless } from "./GearboxPermissionless.js";
+import "./oracles/index.js";
+import "./transactions/index.js";
+import "./types.js";
+export { ChainsNamespace, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, InstanceOwnerTransactions, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };

package/dist/esm/permissionless/api/oracles/PermissionlessOracles.js

@@ -0,0 +1,81 @@
+import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
+import { getPrices } from "../../utils/price-update/get-prices.js";
+import { priceFeedStoreSchema, pricesSchema } from "./schemas.js";
+//#region src/permissionless/api/oracles/PermissionlessOracles.ts
+const GET_PRICES_GAS_LIMIT_BY_CHAIN_ID = { 143: 100000000n };
+const GET_PRICES_CHUNK_SIZE = 200;
+/**
+* The price feeds of one chain: the PriceFeedStore as the backend has indexed
+* it, and the prices behind it.
+*
+* ```ts
+* const store = await permissionless.oracles.store({ chainId: 1 });
+* const { prices } = await permissionless.oracles.prices({ chainId: 1 });
+* ```
+*
+* Read-only. What the store carries is decided on chain, so putting a feed
+* there is a batch the instance owner executes — see
+* {@link InstanceOwnerTransactions} — not a row a client writes here.
+**/
+var PermissionlessOracles = class extends AbstractOffchainNamespace {
+	#chains;
+	constructor(options, chains) {
+		super("PermissionlessOracles", {
+			...options,
+			chainIds: []
+		});
+		this.#chains = chains;
+	}
+	/**
+	* The store with the assets and feeds of one chain.
+	**/
+	async store({ chainId }) {
+		return this.getData({
+			path: `/pfs/${chainId}`,
+			schema: priceFeedStoreSchema
+		});
+	}
+	/**
+	* A price per feed, and a market cap per feed and asset. The feeds the
+	* indexer has not seen are read off the chain by the backend, so the store
+	* is priced whole.
+	**/
+	async prices({ chainId }) {
+		return this.getData({
+			path: `/pfs/${chainId}/prices`,
+			schema: pricesSchema
+		});
+	}
+	/**
+	* The price each of the named feeds reports, read off the chain.
+	*
+	* Where {@link prices} answers for the store as a whole and at whatever
+	* moment the backend priced it, this prices exactly the feeds asked for, at
+	* the current block. A feed the store does not carry prices the same way,
+	* which is what makes this the call to reach for after a deploy, or while a
+	* form is still choosing between candidates.
+	*
+	* Feeds needing a fresh answer before they can be read are updated inside
+	* the same simulation, so a push-based feed prices as readily as a
+	* pull-based one. `null` is a feed whose read reverted, not a zero.
+	*
+	* ```ts
+	* const prices = await permissionless.oracles.getPrices({
+	*   chainId: 1,
+	*   priceFeeds: [feed],
+	* });
+	* ```
+	*
+	* @returns A price per feed, in the 8 decimals every Gearbox feed reports.
+	**/
+	async getPrices({ chainId, priceFeeds }) {
+		return getPrices({
+			client: this.#chains.client(chainId),
+			priceFeeds,
+			chunkSize: 200,
+			gasLimit: GET_PRICES_GAS_LIMIT_BY_CHAIN_ID[chainId]
+		});
+	}
+};
+//#endregion
+export { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles };

package/dist/esm/permissionless/api/oracles/index.js

@@ -0,0 +1,3 @@
+import { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles } from "./PermissionlessOracles.js";
+import "./types.js";
+export { GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, PermissionlessOracles };

package/dist/esm/permissionless/api/oracles/schemas.js

@@ -0,0 +1,59 @@
+import { addressRecord, addressSchema } from "../schemas.js";
+import { z } from "zod/v4";
+//#region src/permissionless/api/oracles/schemas.ts
+/**
+* Runtime schemas for {@link ./types.js}.
+*
+* The objects are loose: the backend reads most of these rows straight off the
+* chain through the SDK's own bindings, which attach fields the hand-written
+* types do not declare, and dropping them would make this client lossier than
+* the payload it decodes.
+**/
+/** {@link PriceFeed}, as the backend serves it. */
+const priceFeedSchema = z.looseObject({
+	address: addressSchema,
+	contractType: z.string(),
+	version: z.number(),
+	deployedBy: addressSchema,
+	isInStore: z.boolean(),
+	stalenessPeriod: z.number(),
+	name: z.string()
+});
+/** {@link PermissionlessPriceFeedStatus} */
+const priceFeedStatusSchema = z.enum([
+	"private",
+	"inStore",
+	"pendingForbidden",
+	"forbidden"
+]);
+/** {@link PermissionlessAsset} */
+const assetSchema = z.looseObject({
+	address: addressSchema,
+	symbol: z.string(),
+	name: z.string(),
+	decimals: z.number(),
+	isInStore: z.boolean(),
+	owner: addressSchema,
+	priceFeeds: z.array(z.looseObject({
+		pricefeed: priceFeedSchema,
+		status: priceFeedStatusSchema
+	}))
+});
+/** {@link PermissionlessPriceFeedStore} */
+const priceFeedStoreSchema = z.looseObject({
+	chainId: z.number(),
+	name: z.string(),
+	isPublic: z.boolean(),
+	isActivated: z.boolean(),
+	explorerUrl: z.string(),
+	assets: z.array(assetSchema),
+	priceFeeds: z.array(priceFeedSchema)
+});
+/** {@link PermissionlessPrices} */
+const pricesSchema = z.looseObject({
+	prices: addressRecord(z.string().nullable()),
+	marketCaps: addressRecord(addressRecord(z.string().nullable())),
+	time: z.number()
+});
+//#endregion
+export { assetSchema, priceFeedSchema, priceFeedStatusSchema, priceFeedStoreSchema, pricesSchema };

package/dist/esm/permissionless/api/oracles/types.js

@@ -0,0 +1 @@
+export {};