@gearbox-protocol/sdk 18.1.0 → 18.2.0-next.2

package/dist/esm/onchain/market/adapters/abi/actionAbi.js

@@ -32,6 +32,7 @@ const adapterActionSignatures = {
 		311: "function setPairStatusBatch((address,address,address,uint8,uint8)[])"
 	},
 	["TRADERJOE_ROUTER"]: { 310: "function setPoolStatusBatch((address,address,uint256,uint8,bool)[])" },
+	["TREEHOUSE_ROUTER"]: { 310: "function setAssetStatusBatch(address[],bool[])" },
 	["UNISWAP_V2_ROUTER"]: { 310: "function setPairStatusBatch((address,address,bool)[])" },
 	["UNISWAP_V3_ROUTER"]: { 310: "function setPoolStatusBatch((address,address,uint24,bool)[])" },
 	["UNISWAP_V4_GATEWAY"]: { 310: "function setPoolKeyStatusBatch(((address,address,uint24,int24,address),bool)[])" },

package/dist/esm/onchain/market/adapters/abi/conctructorAbi.js

@@ -35,6 +35,9 @@ const adapterConstructorAbi = {
 	["UNISWAP_V4_GATEWAY"]: { 310: BASIC_ADAPTER_ABI },
 	["VELODROME_V2_ROUTER"]: { 310: BASIC_ADAPTER_ABI },
 	["SECURITIZE_ONRAMP"]: { 310: BASIC_ADAPTER_ABI },
+	["TREEHOUSE_FASTLANE"]: { 310: BASIC_ADAPTER_ABI },
+	["TREEHOUSE_GATEWAY"]: { 310: BASIC_ADAPTER_ABI },
+	["TREEHOUSE_ROUTER"]: { 310: BASIC_ADAPTER_ABI },
 	["CURVE_V1_2ASSETS"]: { 311: CURVE_V1_ADAPTER_311_ABI },
 	["CURVE_V1_3ASSETS"]: { 311: CURVE_V1_ADAPTER_311_ABI },
 	["CURVE_V1_4ASSETS"]: { 311: CURVE_V1_ADAPTER_311_ABI },

package/dist/esm/onchain/market/adapters/types.js

@@ -33,6 +33,9 @@ let AdapterType = /* @__PURE__ */ function(AdapterType) {
 	AdapterType["SECURITIZE_REDEMPTION"] = "SECURITIZE_REDEMPTION";
 	AdapterType["STAKING_REWARDS"] = "STAKING_REWARDS";
 	AdapterType["TRADERJOE_ROUTER"] = "TRADERJOE_ROUTER";
+	AdapterType["TREEHOUSE_FASTLANE"] = "TREEHOUSE_FASTLANE";
+	AdapterType["TREEHOUSE_GATEWAY"] = "TREEHOUSE_GATEWAY";
+	AdapterType["TREEHOUSE_ROUTER"] = "TREEHOUSE_ROUTER";
 	AdapterType["UNISWAP_V2_ROUTER"] = "UNISWAP_V2_ROUTER";
 	AdapterType["UNISWAP_V3_ROUTER"] = "UNISWAP_V3_ROUTER";
 	AdapterType["UNISWAP_V4_GATEWAY"] = "UNISWAP_V4_GATEWAY";

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

@@ -1,3 +1,4 @@
+import { PermissionlessAnalytics } from "./analytics/PermissionlessAnalytics.js";
 import { ChainsNamespace } from "./chains/ChainsNamespace.js";
 import { PermissionlessDeploy } from "./deploy/PermissionlessDeploy.js";
 import { PermissionlessOracles } from "./oracles/PermissionlessOracles.js";
@@ -24,11 +25,11 @@ import { InstanceOwnerTransactions } from "./transactions/InstanceOwnerTransacti
 * const store = await permissionless.oracles.store({ chainId: chain.chainId });
 * ```
 *
-* Only what needs a server goes to one. {@link chains} and {@link oracles}
-* are the backend's reads; {@link deploy} and {@link transactions} read the
-* target chain directly, because everything they answer is derived from there
-* and a round trip would only move the derivation further from the wallet
-* that has to sign for it.
+* Only what needs a server goes to one. {@link chains}, {@link oracles} and
+* {@link analytics} are the backend's reads; {@link deploy} and
+* {@link transactions} read the target chain directly, because everything
+* they answer is derived from there and a round trip would only move the
+* derivation further from the wallet that has to sign for it.
 **/
 var GearboxPermissionless = class {
 	/**
@@ -41,6 +42,11 @@ var GearboxPermissionless = class {
 	**/
 	oracles;
 	/**
+	* Namespace for history: what a feed's price did over a window, see
+	* {@link PermissionlessAnalytics}.
+	**/
+	analytics;
+	/**
 	* Namespace for the Safe batches an instance owner executes. Backend-free,
 	* see {@link InstanceOwnerTransactions}.
 	**/
@@ -53,6 +59,7 @@ var GearboxPermissionless = class {
 	constructor(options = {}) {
 		this.chains = new ChainsNamespace(options);
 		this.oracles = new PermissionlessOracles(options, this.chains);
+		this.analytics = new PermissionlessAnalytics(options);
 		this.transactions = new InstanceOwnerTransactions(this.chains, this.oracles);
 		this.deploy = new PermissionlessDeploy(this.chains);
 	}

package/dist/esm/permissionless/api/analytics/PermissionlessAnalytics.js

@@ -0,0 +1,49 @@
+import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
+import { priceFeedChartSchema } from "./schemas.js";
+//#region src/permissionless/api/analytics/PermissionlessAnalytics.ts
+/**
+* History of the permissionless stack: what a thing did, rather than what it
+* is.
+*
+* Separate from {@link PermissionlessOracles} because the two are read on
+* different clocks. A feed's identity settles when a curator uploads it and
+* is read once per page; its price moves every block and is re-read whenever
+* a window changes. Folding the series into the feed would make every range
+* switch re-fetch the identity, and every identity read carry a series the
+* caller may never draw.
+*
+* ```ts
+* const chart = await permissionless.analytics.priceChart({
+*   chainId: 1,
+*   address: feed,
+*   range: "1w",
+* });
+* ```
+**/
+var PermissionlessAnalytics = class extends AbstractOffchainNamespace {
+	constructor(options) {
+		super("PermissionlessAnalytics", {
+			...options,
+			chainIds: []
+		});
+	}
+	/**
+	* The price one feed reported over a window.
+	*
+	* Backend-only by construction: the chain serves the present, and
+	* reconstructing a series from it would mean an archive read per point.
+	*
+	* @throws When the PriceFeedStore does not carry the feed. An address the
+	* store never held has no indexed history, and answering an empty series
+	* would read as "no price yet" rather than as the mistake it is.
+	**/
+	async priceChart({ chainId, address, range }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}/chart`,
+			query: { range },
+			schema: priceFeedChartSchema
+		});
+	}
+};
+//#endregion
+export { PermissionlessAnalytics };

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

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

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

@@ -0,0 +1,25 @@
+import { CHART_RANGES } from "../../../model/charts.js";
+import { z } from "zod/v4";
+//#region src/permissionless/api/analytics/schemas.ts
+/**
+* Runtime schemas for {@link ./types.js}.
+*
+* Loose for the same reason the oracles schemas are: the backend assembles
+* these rows from its own indexes and may report more about a window than the
+* hand-written types declare.
+**/
+/** {@link PriceFeedChartPoint} */
+const priceFeedChartPointSchema = z.looseObject({
+	timestamp: z.number(),
+	value: z.number()
+});
+/** {@link PriceFeedPriceChart} */
+const priceFeedChartSchema = z.looseObject({
+	range: z.enum(CHART_RANGES),
+	from: z.number(),
+	to: z.number(),
+	intervalSeconds: z.number(),
+	points: z.array(priceFeedChartPointSchema)
+});
+//#endregion
+export { priceFeedChartPointSchema, priceFeedChartSchema };

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

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

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

@@ -1,3 +1,5 @@
+import { PermissionlessAnalytics } from "./analytics/PermissionlessAnalytics.js";
+import "./analytics/index.js";
 import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./errors.js";
 import { ChainsNamespace } from "./chains/ChainsNamespace.js";
 import "./chains/index.js";
@@ -10,4 +12,4 @@ 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 };
+export { ChainsNamespace, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, InstanceOwnerTransactions, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, deriveEffectiveStalenessPeriod, priceFeedSalt };

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

@@ -1,6 +1,7 @@
+import { priceFeedDataSchema } from "../../../model/opportunities.schema.js";
 import { AbstractOffchainNamespace } from "../../../offchain/AbstractOffchainNamespace.js";
 import { getPrices } from "../../utils/price-update/get-prices.js";
-import { priceFeedStoreSchema, pricesSchema } from "./schemas.js";
+import { priceFeedDetailsSchema, priceFeedMarketCapsSchema, 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;
@@ -36,9 +37,77 @@ var PermissionlessOracles = class extends AbstractOffchainNamespace {
 		});
 	}
 	/**
+	* One feed of the store: what it is, which assets it may price, and which
+	* market slots it currently fills.
+	*
+	* Singular where {@link store} is plural, and not a filter over it: the
+	* store answers what a list renders, while this answers what a feed is used
+	* for, which the store does not carry at all.
+	*
+	* ```ts
+	* const { priceFeed, markets } = await permissionless.oracles.feed({
+	*   chainId: 1,
+	*   address: feed,
+	* });
+	* ```
+	*
+	* @throws When the store does not carry the feed. A private draft is not
+	* here — it lives in whichever app wrote it.
+	**/
+	async feed({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}`,
+			schema: priceFeedDetailsSchema
+		});
+	}
+	/**
+	* The feeds one feed reads from, recursively.
+	*
+	* Answers for any feed the chain has indexed, store member or not: a
+	* composite feed's children are rarely in the store themselves, and a tree
+	* that stopped at the first of them would not be one.
+	*
+	* ```ts
+	* const tree = await permissionless.oracles.dependencies({
+	*   chainId: 1,
+	*   address: feed,
+	* });
+	* ```
+	**/
+	async dependencies({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}/graph`,
+			schema: priceFeedDataSchema
+		});
+	}
+	/**
+	* What the market values each of one feed's assets at.
+	*
+	* Prefer this over {@link prices} whenever the caller is looking at a single
+	* feed. That one prices the whole store, which costs the backend one
+	* `totalSupply` call per asset of every market on the chain; this costs it
+	* one price lookup and one multicall over the feed's own assets.
+	*
+	* ```ts
+	* const { marketCaps } = await permissionless.oracles.feedMarketCaps({
+	*   chainId: 1,
+	*   address: feed,
+	* });
+	* ```
+	**/
+	async feedMarketCaps({ chainId, address }) {
+		return this.getData({
+			path: `/pfs/${chainId}/price-feed/${address}/market-caps`,
+			schema: priceFeedMarketCapsSchema
+		});
+	}
+	/**
 	* 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.
+	*
+	* Chain-wide, and priced accordingly — see {@link feedMarketCaps} for one
+	* feed.
 	**/
 	async prices({ chainId }) {
 		return this.getData({

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

@@ -43,5 +43,37 @@ const pricesSchema = z.looseObject({
 	marketCaps: addressRecord(addressRecord(z.string().nullable())),
 	time: z.number()
 });
+/** {@link PermissionlessPriceFeedAsset} */
+const priceFeedAssetSchema = z.looseObject({
+	address: addressSchema,
+	symbol: z.string(),
+	name: z.string(),
+	decimals: z.number()
+});
+/** {@link PermissionlessPriceFeedMarket} */
+const priceFeedMarketSchema = z.looseObject({
+	market: addressSchema,
+	marketConfigurator: addressSchema,
+	curatorName: z.string().nullable(),
+	marketName: z.string().nullable(),
+	token: addressSchema,
+	tokenSymbol: z.string().nullable(),
+	underlyingSymbol: z.string().nullable(),
+	reserve: z.boolean(),
+	isUnderlying: z.boolean(),
+	quotaLimit: z.number().nullable()
+});
+/** {@link PermissionlessPriceFeedDetails} */
+const priceFeedDetailsSchema = z.looseObject({
+	chainId: z.number(),
+	priceFeed: priceFeedSchema,
+	assets: z.array(priceFeedAssetSchema),
+	markets: z.array(priceFeedMarketSchema)
+});
+/** {@link PermissionlessPriceFeedMarketCaps} */
+const priceFeedMarketCapsSchema = z.looseObject({
+	marketCaps: addressRecord(z.string().nullable()),
+	time: z.number()
+});
 //#endregion
-export { assetSchema, priceFeedSchema, priceFeedStoreSchema, pricesSchema };
+export { assetSchema, priceFeedAssetSchema, priceFeedDetailsSchema, priceFeedMarketCapsSchema, priceFeedMarketSchema, priceFeedSchema, priceFeedStoreSchema, pricesSchema };

package/dist/esm/permissionless/index.js

@@ -1,3 +1,4 @@
+import { PermissionlessAnalytics } from "./api/analytics/PermissionlessAnalytics.js";
 import { PermissionlessChainUnreachableError, PermissionlessNotAttachedError, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError } from "./api/errors.js";
 import { ChainsNamespace } from "./api/chains/ChainsNamespace.js";
 import { deriveEffectiveStalenessPeriod } from "./api/deploy/effective-staleness.js";
@@ -40,4 +41,4 @@ import { getBlockNumberByTimestamp } from "./utils/block-utils.js";
 import { convertQueueBatchToExecuteTx } from "./utils/governance/timelock-txs.js";
 import { getPriceUpdateTx } from "./utils/price-update/get-price-update-tx.js";
 import "./utils/index.js";
-export { AccessMode, AddressProviderContract, Addresses, ArchiveTransport, BYTECODE_REPOSITORY, BytecodeRepositoryContract, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainsNamespace, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GovernorContract, INSTANCE_MANAGER, InstanceManagerContract, InstanceOwnerTransactions, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, PriceFeedStoreContract, RoutingManagerContract, TOKEN_COMPRESSOR, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, priceFeedSalt, priceFeedSetupParams, shortenHash, significantTrunc };
+export { AccessMode, AddressProviderContract, Addresses, ArchiveTransport, BYTECODE_REPOSITORY, BytecodeRepositoryContract, CROSS_CHAIN_GOVERNANCE, CROSS_CHAIN_MULTISIG, ChainsNamespace, CrossChainMultisigContract, DEFAULT_DEPLOY_SALT, GET_PRICES_CHUNK_SIZE, GET_PRICES_GAS_LIMIT_BY_CHAIN_ID, GearboxPermissionless, GovernorContract, INSTANCE_MANAGER, InstanceManagerContract, InstanceOwnerTransactions, MAINNET_CCM_CONSTRUCTOR_PARAMS, MAINNET_DEPLOYMENT_BLOCK, MAINNET_DEPLOYMENT_CCM_SALT, MAINNET_DEPLOYMENT_IM_SALT, MARKET_CONFIGURATOR_FACTORY, MarketConfiguratorContract, MarketConfiguratorFactoryContract, PRICE_FEED_STORE, PUBLIC_CREATE2_FACTORY, PermissionlessAnalytics, PermissionlessChainUnreachableError, PermissionlessDeploy, PermissionlessNotAttachedError, PermissionlessOracles, PriceFeedNotInStoreError, PriceFeedSaltMissingError, PriceFeedStalenessUnknownError, PriceFeedStoreContract, RoutingManagerContract, TOKEN_COMPRESSOR, TimeLockContract, TokenCompressorContract, TreasurySplitterContract, WithdrawalCompressorContract, calculateChecksum, checkCreate2Deployment, checkCreate2DeploymentAddress, chunkedLogsTransport, convertPercent, convertQueueBatchToExecuteTx, convertRawTxToSafeMultisigTx, createCallData, createCreate2DeployRawTx, deepJsonParse, deployUsingPublicCreate2, deriveEffectiveStalenessPeriod, encodeFunctionParams, formatBytecodeSize, formatBytecodeVersion, getBlockNumberByTimestamp, getCreate2AddressPublicFactory, getCreate2DeploymentAddress, getPriceUpdateTx, getPrices, getSafeBatch, getSafeBatches, getUpdatablePriceFeeds, handleSalt, normalizeSignature, priceFeedSalt, priceFeedSetupParams, shortenHash, significantTrunc };

package/dist/types/abi/compressors/subcompressors/liquidation/treehouseLiquidationSubcompressor.d.ts

@@ -0,0 +1,148 @@
+//#region src/abi/compressors/subcompressors/liquidation/treehouseLiquidationSubcompressor.d.ts
+export declare const treehouseLiquidationSubcompressorAbi: readonly [{
+  readonly type: "function";
+  readonly name: "contractType";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "bytes32";
+    readonly internalType: "bytes32";
+  }];
+  readonly stateMutability: "view";
+}, {
+  readonly type: "function";
+  readonly name: "getLiquidationData";
+  readonly inputs: readonly [{
+    readonly name: "liquidator";
+    readonly type: "address";
+    readonly internalType: "address";
+  }, {
+    readonly name: "creditAccount";
+    readonly type: "address";
+    readonly internalType: "address";
+  }, {
+    readonly name: "phantomToken";
+    readonly type: "address";
+    readonly internalType: "address";
+  }, {
+    readonly name: "priceUpdates";
+    readonly type: "tuple[]";
+    readonly internalType: "struct PriceUpdate[]";
+    readonly components: readonly [{
+      readonly name: "priceFeed";
+      readonly type: "address";
+      readonly internalType: "address";
+    }, {
+      readonly name: "data";
+      readonly type: "bytes";
+      readonly internalType: "bytes";
+    }];
+  }];
+  readonly outputs: readonly [{
+    readonly name: "data";
+    readonly type: "tuple";
+    readonly internalType: "struct LiquidationData";
+    readonly components: readonly [{
+      readonly name: "requiredToken";
+      readonly type: "address";
+      readonly internalType: "address";
+    }, {
+      readonly name: "requiredAmount";
+      readonly type: "uint256";
+      readonly internalType: "uint256";
+    }, {
+      readonly name: "expectedOutputs";
+      readonly type: "tuple[]";
+      readonly internalType: "struct LiquidationOutput[]";
+      readonly components: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+      }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+      }, {
+        readonly name: "delayed";
+        readonly type: "bool";
+        readonly internalType: "bool";
+      }, {
+        readonly name: "redeemerAddress";
+        readonly type: "address";
+        readonly internalType: "address";
+      }, {
+        readonly name: "claimableAt";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+      }];
+    }, {
+      readonly name: "liquidationCall";
+      readonly type: "tuple";
+      readonly internalType: "struct MultiCall";
+      readonly components: readonly [{
+        readonly name: "target";
+        readonly type: "address";
+        readonly internalType: "address";
+      }, {
+        readonly name: "callData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+      }];
+    }, {
+      readonly name: "isLiquidatorEligible";
+      readonly type: "bool";
+      readonly internalType: "bool";
+    }, {
+      readonly name: "isCreditAccountFrozen";
+      readonly type: "bool";
+      readonly internalType: "bool";
+    }, {
+      readonly name: "kycProtocol";
+      readonly type: "string";
+      readonly internalType: "string";
+    }, {
+      readonly name: "kycToken";
+      readonly type: "address";
+      readonly internalType: "address";
+    }];
+  }];
+  readonly stateMutability: "nonpayable";
+}, {
+  readonly type: "function";
+  readonly name: "getRWALiquidatorInfo";
+  readonly inputs: readonly [{
+    readonly name: "token";
+    readonly type: "address";
+    readonly internalType: "address";
+  }];
+  readonly outputs: readonly [{
+    readonly name: "info";
+    readonly type: "tuple";
+    readonly internalType: "struct RWALiquidatorInfo";
+    readonly components: readonly [{
+      readonly name: "gateway";
+      readonly type: "address";
+      readonly internalType: "address";
+    }, {
+      readonly name: "liquidatorAddress";
+      readonly type: "address";
+      readonly internalType: "address";
+    }, {
+      readonly name: "contractType";
+      readonly type: "bytes32";
+      readonly internalType: "bytes32";
+    }];
+  }];
+  readonly stateMutability: "view";
+}, {
+  readonly type: "function";
+  readonly name: "version";
+  readonly inputs: readonly [];
+  readonly outputs: readonly [{
+    readonly name: "";
+    readonly type: "uint256";
+    readonly internalType: "uint256";
+  }];
+  readonly stateMutability: "view";
+}];
+//#endregion