@charterlabs/rhinestone-sdk 0.1.1 → 0.1.2

package/dist/src/orchestrator/error.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntentNotFoundError = exports.NoPathFoundError = exports.OnlyOneTargetTokenAmountCanBeUnsetError = exports.InvalidIntentSignatureError = exports.InvalidApiKeyError = exports.AuthenticationRequiredError = exports.TokenNotSupportedError = exports.UnsupportedTokenError = exports.UnsupportedChainError = exports.UnsupportedChainIdError = exports.InsufficientBalanceError = exports.OrchestratorError = void 0;
+exports.isOrchestratorError = isOrchestratorError;
+class OrchestratorError extends Error {
+    _message;
+    _context;
+    _errorType;
+    _traceId;
+    constructor(params) {
+        super();
+        this._message = params?.message || 'OrchestratorError ';
+        this._context = params?.context || {};
+        this._errorType = params?.errorType || 'Unknown';
+        this._traceId = params?.traceId || '';
+    }
+    get message() {
+        return this._message;
+    }
+    get context() {
+        return this._context;
+    }
+    get errorType() {
+        return this._errorType;
+    }
+    get traceId() {
+        return this._traceId;
+    }
+}
+exports.OrchestratorError = OrchestratorError;
+class InsufficientBalanceError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Insufficient balance',
+            ...params,
+        });
+    }
+}
+exports.InsufficientBalanceError = InsufficientBalanceError;
+class UnsupportedChainIdError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Unsupported chain id',
+            ...params,
+        });
+    }
+}
+exports.UnsupportedChainIdError = UnsupportedChainIdError;
+class UnsupportedChainError extends OrchestratorError {
+    constructor(chainId, params) {
+        super({
+            message: `Unsupported chain ${chainId}`,
+            ...params,
+        });
+    }
+}
+exports.UnsupportedChainError = UnsupportedChainError;
+class UnsupportedTokenError extends OrchestratorError {
+    constructor(tokenSymbol, chainId, params) {
+        super({
+            message: `Unsupported token ${tokenSymbol} for chain ${chainId}`,
+            ...params,
+        });
+    }
+}
+exports.UnsupportedTokenError = UnsupportedTokenError;
+class TokenNotSupportedError extends OrchestratorError {
+    constructor(tokenAddress, chainId, params) {
+        super({
+            message: `Token ${tokenAddress} not supported on chain ${chainId}`,
+            ...params,
+        });
+    }
+}
+exports.TokenNotSupportedError = TokenNotSupportedError;
+class AuthenticationRequiredError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Authentication is required',
+            ...params,
+        });
+    }
+}
+exports.AuthenticationRequiredError = AuthenticationRequiredError;
+class InvalidApiKeyError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Invalid API key',
+            ...params,
+        });
+    }
+}
+exports.InvalidApiKeyError = InvalidApiKeyError;
+class InvalidIntentSignatureError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Invalid intent signature',
+            ...params,
+        });
+    }
+}
+exports.InvalidIntentSignatureError = InvalidIntentSignatureError;
+class OnlyOneTargetTokenAmountCanBeUnsetError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Only one target token amount can be unset',
+            ...params,
+        });
+    }
+}
+exports.OnlyOneTargetTokenAmountCanBeUnsetError = OnlyOneTargetTokenAmountCanBeUnsetError;
+class NoPathFoundError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'No Path Found',
+            ...params,
+        });
+    }
+}
+exports.NoPathFoundError = NoPathFoundError;
+class IntentNotFoundError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Intent not found',
+            ...params,
+        });
+    }
+}
+exports.IntentNotFoundError = IntentNotFoundError;
+function isOrchestratorError(error) {
+    return error instanceof OrchestratorError;
+}

package/dist/src/orchestrator/index.d.ts

@@ -0,0 +1,11 @@
+import { Orchestrator } from './client';
+import { RHINESTONE_SPOKE_POOL_ADDRESS } from './consts';
+import { AuthenticationRequiredError, InsufficientBalanceError, IntentNotFoundError, InvalidApiKeyError, InvalidIntentSignatureError, isOrchestratorError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, TokenNotSupportedError, UnsupportedChainError, UnsupportedChainIdError, UnsupportedTokenError } from './error';
+import { getSupportedTokens, getTokenAddress, getTokenSymbol, getWethAddress, isTokenAddressSupported } from './registry';
+import type { IntentCost, IntentInput, IntentOp, IntentOpStatus, IntentResult, IntentRoute, Portfolio, SettlementSystem, SignedIntentOp, SupportedChain, TokenConfig } from './types';
+import { INTENT_STATUS_COMPLETED, INTENT_STATUS_EXPIRED, INTENT_STATUS_FAILED, INTENT_STATUS_FILLED, INTENT_STATUS_PARTIALLY_COMPLETED, INTENT_STATUS_PENDING, INTENT_STATUS_PRECONFIRMED, INTENT_STATUS_UNKNOWN } from './types';
+import { getIntentOpHash } from './utils';
+declare function getOrchestrator(apiKey: string, orchestratorUrl?: string): Orchestrator;
+export type { IntentCost, IntentInput, IntentOp, IntentOpStatus, IntentResult, IntentRoute, SettlementSystem, SignedIntentOp, SupportedChain, TokenConfig, Portfolio, };
+export { INTENT_STATUS_PENDING, INTENT_STATUS_EXPIRED, INTENT_STATUS_PARTIALLY_COMPLETED, INTENT_STATUS_COMPLETED, INTENT_STATUS_FILLED, INTENT_STATUS_FAILED, INTENT_STATUS_PRECONFIRMED, INTENT_STATUS_UNKNOWN, RHINESTONE_SPOKE_POOL_ADDRESS, Orchestrator, AuthenticationRequiredError, InsufficientBalanceError, InvalidApiKeyError, InvalidIntentSignatureError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, IntentNotFoundError, TokenNotSupportedError, UnsupportedChainError, UnsupportedChainIdError, UnsupportedTokenError, getOrchestrator, getIntentOpHash, getWethAddress, getTokenSymbol, getTokenAddress, getSupportedTokens, isOrchestratorError, isTokenAddressSupported, };
+//# sourceMappingURL=index.d.ts.map

package/dist/src/orchestrator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../orchestrator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,EAAyB,6BAA6B,EAAE,MAAM,UAAU,CAAA;AAC/E,OAAO,EACL,2BAA2B,EAC3B,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,2BAA2B,EAC3B,mBAAmB,EACnB,gBAAgB,EAChB,uCAAuC,EACvC,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,cAAc,EACd,uBAAuB,EACxB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,WAAW,EACX,SAAS,EACT,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,WAAW,EACZ,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,iCAAiC,EACjC,qBAAqB,EACrB,0BAA0B,EAC1B,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAEzC,iBAAS,eAAe,CACtB,MAAM,EAAE,MAAM,EACd,eAAe,CAAC,EAAE,MAAM,GACvB,YAAY,CAEd;AAED,YAAY,EACV,UAAU,EACV,WAAW,EACX,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,WAAW,EACX,SAAS,GACV,CAAA;AACD,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,iCAAiC,EACjC,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,EAC1B,qBAAqB,EACrB,6BAA6B,EAC7B,YAAY,EACZ,2BAA2B,EAC3B,wBAAwB,EACxB,kBAAkB,EAClB,2BAA2B,EAC3B,gBAAgB,EAChB,uCAAuC,EACvC,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,eAAe,EACf,eAAe,EACf,cAAc,EACd,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,uBAAuB,GACxB,CAAA"}

package/dist/src/orchestrator/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTokenAddressSupported = exports.isOrchestratorError = exports.getSupportedTokens = exports.getTokenAddress = exports.getTokenSymbol = exports.getWethAddress = exports.getIntentOpHash = exports.UnsupportedTokenError = exports.UnsupportedChainIdError = exports.UnsupportedChainError = exports.TokenNotSupportedError = exports.IntentNotFoundError = exports.OrchestratorError = exports.OnlyOneTargetTokenAmountCanBeUnsetError = exports.NoPathFoundError = exports.InvalidIntentSignatureError = exports.InvalidApiKeyError = exports.InsufficientBalanceError = exports.AuthenticationRequiredError = exports.Orchestrator = exports.RHINESTONE_SPOKE_POOL_ADDRESS = exports.INTENT_STATUS_UNKNOWN = exports.INTENT_STATUS_PRECONFIRMED = exports.INTENT_STATUS_FAILED = exports.INTENT_STATUS_FILLED = exports.INTENT_STATUS_COMPLETED = exports.INTENT_STATUS_PARTIALLY_COMPLETED = exports.INTENT_STATUS_EXPIRED = exports.INTENT_STATUS_PENDING = void 0;
+exports.getOrchestrator = getOrchestrator;
+const client_1 = require("./client");
+Object.defineProperty(exports, "Orchestrator", { enumerable: true, get: function () { return client_1.Orchestrator; } });
+const consts_1 = require("./consts");
+Object.defineProperty(exports, "RHINESTONE_SPOKE_POOL_ADDRESS", { enumerable: true, get: function () { return consts_1.RHINESTONE_SPOKE_POOL_ADDRESS; } });
+const error_1 = require("./error");
+Object.defineProperty(exports, "AuthenticationRequiredError", { enumerable: true, get: function () { return error_1.AuthenticationRequiredError; } });
+Object.defineProperty(exports, "InsufficientBalanceError", { enumerable: true, get: function () { return error_1.InsufficientBalanceError; } });
+Object.defineProperty(exports, "IntentNotFoundError", { enumerable: true, get: function () { return error_1.IntentNotFoundError; } });
+Object.defineProperty(exports, "InvalidApiKeyError", { enumerable: true, get: function () { return error_1.InvalidApiKeyError; } });
+Object.defineProperty(exports, "InvalidIntentSignatureError", { enumerable: true, get: function () { return error_1.InvalidIntentSignatureError; } });
+Object.defineProperty(exports, "isOrchestratorError", { enumerable: true, get: function () { return error_1.isOrchestratorError; } });
+Object.defineProperty(exports, "NoPathFoundError", { enumerable: true, get: function () { return error_1.NoPathFoundError; } });
+Object.defineProperty(exports, "OnlyOneTargetTokenAmountCanBeUnsetError", { enumerable: true, get: function () { return error_1.OnlyOneTargetTokenAmountCanBeUnsetError; } });
+Object.defineProperty(exports, "OrchestratorError", { enumerable: true, get: function () { return error_1.OrchestratorError; } });
+Object.defineProperty(exports, "TokenNotSupportedError", { enumerable: true, get: function () { return error_1.TokenNotSupportedError; } });
+Object.defineProperty(exports, "UnsupportedChainError", { enumerable: true, get: function () { return error_1.UnsupportedChainError; } });
+Object.defineProperty(exports, "UnsupportedChainIdError", { enumerable: true, get: function () { return error_1.UnsupportedChainIdError; } });
+Object.defineProperty(exports, "UnsupportedTokenError", { enumerable: true, get: function () { return error_1.UnsupportedTokenError; } });
+const registry_1 = require("./registry");
+Object.defineProperty(exports, "getSupportedTokens", { enumerable: true, get: function () { return registry_1.getSupportedTokens; } });
+Object.defineProperty(exports, "getTokenAddress", { enumerable: true, get: function () { return registry_1.getTokenAddress; } });
+Object.defineProperty(exports, "getTokenSymbol", { enumerable: true, get: function () { return registry_1.getTokenSymbol; } });
+Object.defineProperty(exports, "getWethAddress", { enumerable: true, get: function () { return registry_1.getWethAddress; } });
+Object.defineProperty(exports, "isTokenAddressSupported", { enumerable: true, get: function () { return registry_1.isTokenAddressSupported; } });
+const types_1 = require("./types");
+Object.defineProperty(exports, "INTENT_STATUS_COMPLETED", { enumerable: true, get: function () { return types_1.INTENT_STATUS_COMPLETED; } });
+Object.defineProperty(exports, "INTENT_STATUS_EXPIRED", { enumerable: true, get: function () { return types_1.INTENT_STATUS_EXPIRED; } });
+Object.defineProperty(exports, "INTENT_STATUS_FAILED", { enumerable: true, get: function () { return types_1.INTENT_STATUS_FAILED; } });
+Object.defineProperty(exports, "INTENT_STATUS_FILLED", { enumerable: true, get: function () { return types_1.INTENT_STATUS_FILLED; } });
+Object.defineProperty(exports, "INTENT_STATUS_PARTIALLY_COMPLETED", { enumerable: true, get: function () { return types_1.INTENT_STATUS_PARTIALLY_COMPLETED; } });
+Object.defineProperty(exports, "INTENT_STATUS_PENDING", { enumerable: true, get: function () { return types_1.INTENT_STATUS_PENDING; } });
+Object.defineProperty(exports, "INTENT_STATUS_PRECONFIRMED", { enumerable: true, get: function () { return types_1.INTENT_STATUS_PRECONFIRMED; } });
+Object.defineProperty(exports, "INTENT_STATUS_UNKNOWN", { enumerable: true, get: function () { return types_1.INTENT_STATUS_UNKNOWN; } });
+const utils_1 = require("./utils");
+Object.defineProperty(exports, "getIntentOpHash", { enumerable: true, get: function () { return utils_1.getIntentOpHash; } });
+function getOrchestrator(apiKey, orchestratorUrl) {
+    return new client_1.Orchestrator(orchestratorUrl ?? consts_1.PROD_ORCHESTRATOR_URL, apiKey);
+}

package/dist/src/orchestrator/registry.d.ts

@@ -0,0 +1,39 @@
+import { type Address, type Chain } from 'viem';
+import type { TokenSymbol } from '../types';
+import type { TokenConfig } from './types';
+interface TokenEntry {
+    symbol: string;
+    address: Address;
+    decimals: number;
+    balanceSlot: number | null;
+}
+interface ChainContracts {
+    spokepool: Address;
+    hook: Address;
+    originModule: Address;
+    targetModule: Address;
+    sameChainModule: Address;
+}
+interface ChainEntry {
+    name: string;
+    contracts: ChainContracts;
+    tokens: TokenEntry[];
+}
+interface Registry {
+    [chainId: string]: ChainEntry;
+}
+declare function getSupportedChainIds(): number[];
+declare function getWethAddress(chain: Chain): Address;
+declare function getTokenSymbol(tokenAddress: Address, chainId: number): string;
+declare function getTokenAddress(tokenSymbol: TokenSymbol, chainId: number): Address;
+declare function getChainById(chainId: number): Chain | undefined;
+declare function isTestnet(chainId: number): boolean;
+declare function isTokenAddressSupported(address: Address, chainId: number): boolean;
+declare function getSupportedTokens(chainId: number): TokenConfig[];
+declare function getDefaultAccountAccessList(onTestnets?: boolean): {
+    chainIds: number[];
+};
+declare function resolveTokenAddress(token: TokenSymbol | Address, chainId: number): Address;
+export { getTokenSymbol, getTokenAddress, getWethAddress, getChainById, getSupportedTokens, getSupportedChainIds, isTestnet, isTokenAddressSupported, getDefaultAccountAccessList, resolveTokenAddress, };
+export type { TokenEntry, ChainContracts, ChainEntry, Registry };
+//# sourceMappingURL=registry.d.ts.map

package/dist/src/orchestrator/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../orchestrator/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,EAA0B,MAAM,MAAM,CAAA;AAcvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,UAAU,UAAU;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;CAC3B;AAED,UAAU,cAAc;IACtB,SAAS,EAAE,OAAO,CAAA;IAClB,IAAI,EAAE,OAAO,CAAA;IACb,YAAY,EAAE,OAAO,CAAA;IACrB,YAAY,EAAE,OAAO,CAAA;IACrB,eAAe,EAAE,OAAO,CAAA;CACzB;AAED,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,cAAc,CAAA;IACzB,MAAM,EAAE,UAAU,EAAE,CAAA;CACrB;AAED,UAAU,QAAQ;IAChB,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAAA;CAC9B;AAID,iBAAS,oBAAoB,IAAI,MAAM,EAAE,CAExC;AAMD,iBAAS,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAY7C;AAED,iBAAS,cAAc,CAAC,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAiBtE;AAED,iBAAS,eAAe,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAmB3E;AAED,iBAAS,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAexD;AAED,iBAAS,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAM3C;AAED,iBAAS,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAS3E;AAED,iBAAS,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,CAO1D;AAED,iBAAS,2BAA2B,CAAC,UAAU,CAAC,EAAE,OAAO;;EAaxD;AAED,iBAAS,mBAAmB,CAC1B,KAAK,EAAE,WAAW,GAAG,OAAO,EAC5B,OAAO,EAAE,MAAM,GACd,OAAO,CAKT;AAED,OAAO,EACL,cAAc,EACd,eAAe,EACf,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,oBAAoB,EACpB,SAAS,EACT,uBAAuB,EACvB,2BAA2B,EAC3B,mBAAmB,GACpB,CAAA;AAGD,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAA"}

package/dist/src/orchestrator/registry.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenSymbol = getTokenSymbol;
+exports.getTokenAddress = getTokenAddress;
+exports.getWethAddress = getWethAddress;
+exports.getChainById = getChainById;
+exports.getSupportedTokens = getSupportedTokens;
+exports.getSupportedChainIds = getSupportedChainIds;
+exports.isTestnet = isTestnet;
+exports.isTokenAddressSupported = isTokenAddressSupported;
+exports.getDefaultAccountAccessList = getDefaultAccountAccessList;
+exports.resolveTokenAddress = resolveTokenAddress;
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const registry_json_1 = __importDefault(require("./registry.json"));
+const registry = registry_json_1.default;
+function getSupportedChainIds() {
+    return Object.keys(registry).map((chainId) => parseInt(chainId, 10));
+}
+function getChainEntry(chainId) {
+    return registry[chainId.toString()];
+}
+function getWethAddress(chain) {
+    const chainEntry = getChainEntry(chain.id);
+    if (!chainEntry) {
+        throw new Error(`Unsupported chain ${chain.id}`);
+    }
+    const wethToken = chainEntry.tokens.find((token) => token.symbol === 'WETH');
+    if (!wethToken) {
+        throw new Error(`WETH not found for chain ${chain.id}`);
+    }
+    return wethToken.address;
+}
+function getTokenSymbol(tokenAddress, chainId) {
+    const chainEntry = getChainEntry(chainId);
+    if (!chainEntry) {
+        throw new Error(`Unsupported chain ${chainId}`);
+    }
+    const token = chainEntry.tokens.find((t) => t.address.toLowerCase() === tokenAddress.toLowerCase());
+    if (!token) {
+        throw new Error(`Unsupported token address ${tokenAddress} for chain ${chainId}`);
+    }
+    return token.symbol;
+}
+function getTokenAddress(tokenSymbol, chainId) {
+    if (chainId === 137 && tokenSymbol === 'ETH') {
+        throw new Error(`Chain ${chainId} does not allow for ETH to be used`);
+    }
+    if (tokenSymbol === 'ETH') {
+        return viem_1.zeroAddress;
+    }
+    const chainEntry = getChainEntry(chainId);
+    if (!chainEntry) {
+        throw new Error(`Unsupported chain ${chainId}`);
+    }
+    const token = chainEntry.tokens.find((t) => t.symbol === tokenSymbol);
+    if (!token) {
+        throw new Error(`Unsupported token symbol ${tokenSymbol}`);
+    }
+    return token.address;
+}
+function getChainById(chainId) {
+    const supportedChains = [
+        chains_1.mainnet,
+        chains_1.sepolia,
+        chains_1.base,
+        chains_1.baseSepolia,
+        chains_1.arbitrum,
+        chains_1.arbitrumSepolia,
+        chains_1.optimism,
+        chains_1.optimismSepolia,
+        chains_1.polygon,
+        chains_1.zksync,
+        chains_1.soneium,
+    ];
+    return supportedChains.find((chain) => chain.id === chainId);
+}
+function isTestnet(chainId) {
+    const chain = getChainById(chainId);
+    if (!chain) {
+        throw new Error(`Chain not supported: ${chainId}`);
+    }
+    return chain.testnet ?? false;
+}
+function isTokenAddressSupported(address, chainId) {
+    const chainEntry = getChainEntry(chainId);
+    if (!chainEntry) {
+        return false;
+    }
+    return chainEntry.tokens.some((token) => token.address.toLowerCase() === address.toLowerCase());
+}
+function getSupportedTokens(chainId) {
+    const chainEntry = getChainEntry(chainId);
+    if (!chainEntry) {
+        throw new Error(`Chain not supported: ${chainId}`);
+    }
+    return chainEntry.tokens;
+}
+function getDefaultAccountAccessList(onTestnets) {
+    const supportedChainIds = getSupportedChainIds();
+    const filteredChainIds = supportedChainIds.filter((chainId) => {
+        try {
+            return isTestnet(chainId) === !!onTestnets;
+        }
+        catch {
+            return false;
+        }
+    });
+    return {
+        chainIds: filteredChainIds,
+    };
+}
+function resolveTokenAddress(token, chainId) {
+    if ((0, viem_1.isAddress)(token)) {
+        return token;
+    }
+    return getTokenAddress(token, chainId);
+}