@rhinestone/sdk 0.0.0-dev-20260204114155

package/dist/src/orchestrator/error.js

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulationFailedError = exports.BodyParserError = exports.InternalServerError = exports.UnprocessableEntityError = exports.BadRequestError = exports.ConflictError = exports.ResourceNotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.ServiceUnavailableError = exports.RateLimitedError = exports.SchemaValidationError = exports.IntentNotFoundError = exports.NoPathFoundError = exports.OnlyOneTargetTokenAmountCanBeUnsetError = exports.InvalidIntentSignatureError = exports.InvalidApiKeyError = exports.AuthenticationRequiredError = exports.TokenNotSupportedError = exports.UnsupportedTokenError = exports.UnsupportedChainError = exports.UnsupportedChainIdError = exports.InsufficientBalanceError = exports.InsufficientLiquidityError = exports.OrchestratorError = void 0;
+exports.isOrchestratorError = isOrchestratorError;
+exports.isRetryable = isRetryable;
+exports.isAuthError = isAuthError;
+exports.isValidationError = isValidationError;
+exports.isRateLimited = isRateLimited;
+class OrchestratorError extends Error {
+    _message;
+    _context;
+    _errorType;
+    _traceId;
+    _statusCode;
+    constructor(params) {
+        super();
+        this._message = params?.message || 'OrchestratorError ';
+        this._context = params?.context || {};
+        this._errorType = params?.errorType || 'Unknown';
+        this._traceId = params?.traceId || '';
+        this._statusCode = params?.statusCode;
+    }
+    get message() {
+        return this._message;
+    }
+    get context() {
+        return this._context;
+    }
+    get errorType() {
+        return this._errorType;
+    }
+    get traceId() {
+        return this._traceId;
+    }
+    get statusCode() {
+        return this._statusCode;
+    }
+}
+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;
+class SchemaValidationError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: params?.message || 'Schema validation error',
+            ...params,
+        });
+    }
+}
+exports.SchemaValidationError = SchemaValidationError;
+class RateLimitedError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Too Many Requests',
+            ...params,
+        });
+    }
+}
+exports.RateLimitedError = RateLimitedError;
+class ServiceUnavailableError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Service Unavailable',
+            ...params,
+        });
+    }
+}
+exports.ServiceUnavailableError = ServiceUnavailableError;
+class UnauthorizedError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Unauthorized',
+            ...params,
+        });
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+class ForbiddenError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Forbidden',
+            ...params,
+        });
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+class ResourceNotFoundError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Not Found',
+            ...params,
+        });
+    }
+}
+exports.ResourceNotFoundError = ResourceNotFoundError;
+class ConflictError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Conflict',
+            ...params,
+        });
+    }
+}
+exports.ConflictError = ConflictError;
+class BadRequestError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: params?.message || 'Bad Request',
+            ...params,
+        });
+    }
+}
+exports.BadRequestError = BadRequestError;
+class UnprocessableEntityError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: params?.message || 'Unprocessable Entity',
+            ...params,
+        });
+    }
+}
+exports.UnprocessableEntityError = UnprocessableEntityError;
+class InternalServerError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: 'Internal Server Error',
+            ...params,
+        });
+    }
+}
+exports.InternalServerError = InternalServerError;
+class BodyParserError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: params?.message || 'Body parser error',
+            ...params,
+        });
+    }
+}
+exports.BodyParserError = BodyParserError;
+class SimulationFailedError extends OrchestratorError {
+    constructor(params) {
+        super({
+            message: params?.message || 'Simulation failed',
+            ...params,
+        });
+    }
+}
+exports.SimulationFailedError = SimulationFailedError;
+class InsufficientLiquidityError extends OrchestratorError {
+    availableIntents;
+    unfillable;
+    constructor(params) {
+        super({
+            message: 'Insufficient liquidity to fill the requested amounts. Partial splits available.',
+            statusCode: params.statusCode ?? 422,
+            traceId: params.traceId,
+            errorType: 'Unprocessable Entity',
+        });
+        this.availableIntents = params.availableIntents;
+        this.unfillable = params.unfillable;
+    }
+}
+exports.InsufficientLiquidityError = InsufficientLiquidityError;
+function isOrchestratorError(error) {
+    return error instanceof OrchestratorError;
+}
+function isRateLimited(error) {
+    return (error instanceof RateLimitedError ||
+        (error instanceof OrchestratorError && error.statusCode === 429));
+}
+function isValidationError(error) {
+    if (!(error instanceof OrchestratorError))
+        return false;
+    return error.statusCode === 400 || error.statusCode === 422;
+}
+function isAuthError(error) {
+    if (!(error instanceof OrchestratorError))
+        return false;
+    return (error.statusCode === 401 || error instanceof AuthenticationRequiredError);
+}
+function isRetryable(error) {
+    if (!(error instanceof OrchestratorError))
+        return false;
+    return error.statusCode === 500 || error.statusCode === 503;
+}

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

@@ -0,0 +1,10 @@
+import { Orchestrator } from './client';
+import { RHINESTONE_SPOKE_POOL_ADDRESS } from './consts';
+import { AuthenticationRequiredError, BadRequestError, BodyParserError, ConflictError, ForbiddenError, InsufficientBalanceError, InsufficientLiquidityError, IntentNotFoundError, InternalServerError, InvalidApiKeyError, InvalidIntentSignatureError, isAuthError, isOrchestratorError, isRateLimited, isRetryable, isValidationError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, RateLimitedError, ResourceNotFoundError, SchemaValidationError, ServiceUnavailableError, SimulationFailedError, TokenNotSupportedError, UnauthorizedError, UnprocessableEntityError, UnsupportedChainError, UnsupportedChainIdError, UnsupportedTokenError } from './error';
+import { getAllSupportedChainsAndTokens, getSupportedTokens, getTokenAddress, getTokenDecimals, getTokenSymbol, getWethAddress, isTokenAddressSupported } from './registry';
+import type { ApprovalRequired, IntentInput, IntentOp, IntentOpStatus, IntentResult, IntentRoute, Portfolio, SettlementLayer, SignedIntentOp, SplitIntentsInput, SplitIntentsResult, SupportedChain, TokenConfig, TokenRequirements, WrapRequired } from './types';
+import { INTENT_STATUS_CLAIMED, INTENT_STATUS_COMPLETED, INTENT_STATUS_EXPIRED, INTENT_STATUS_FAILED, INTENT_STATUS_FILLED, INTENT_STATUS_PENDING, INTENT_STATUS_PRECONFIRMED } from './types';
+declare function getOrchestrator(apiKey?: string, orchestratorUrl?: string): Orchestrator;
+export type { IntentInput, IntentOp, IntentOpStatus, IntentResult, IntentRoute, SettlementLayer, SignedIntentOp, SplitIntentsInput, SplitIntentsResult, SupportedChain, TokenConfig, Portfolio, TokenRequirements, WrapRequired, ApprovalRequired, };
+export { INTENT_STATUS_PENDING, INTENT_STATUS_EXPIRED, INTENT_STATUS_COMPLETED, INTENT_STATUS_FILLED, INTENT_STATUS_FAILED, INTENT_STATUS_PRECONFIRMED, INTENT_STATUS_CLAIMED, RHINESTONE_SPOKE_POOL_ADDRESS, Orchestrator, AuthenticationRequiredError, BadRequestError, BodyParserError, ConflictError, ForbiddenError, InsufficientBalanceError, InsufficientLiquidityError, InvalidApiKeyError, InvalidIntentSignatureError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, IntentNotFoundError, InternalServerError, ResourceNotFoundError, RateLimitedError, SchemaValidationError, ServiceUnavailableError, SimulationFailedError, UnprocessableEntityError, UnauthorizedError, TokenNotSupportedError, UnsupportedChainError, UnsupportedChainIdError, UnsupportedTokenError, getOrchestrator, getWethAddress, getTokenSymbol, getTokenAddress, getTokenDecimals, getSupportedTokens, getAllSupportedChainsAndTokens, isOrchestratorError, isRetryable, isAuthError, isValidationError, isRateLimited, 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,eAAe,EACf,eAAe,EACf,aAAa,EACb,cAAc,EACd,wBAAwB,EACxB,0BAA0B,EAC1B,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,2BAA2B,EAC3B,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,uCAAuC,EACvC,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,EACtB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,8BAA8B,EAC9B,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,uBAAuB,EACxB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACX,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,WAAW,EACX,SAAS,EACT,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,YAAY,EACb,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,0BAA0B,EAC3B,MAAM,SAAS,CAAA;AAEhB,iBAAS,eAAe,CACtB,MAAM,CAAC,EAAE,MAAM,EACf,eAAe,CAAC,EAAE,MAAM,GACvB,YAAY,CAEd;AAED,YAAY,EACV,WAAW,EACX,QAAQ,EACR,cAAc,EACd,YAAY,EACZ,WAAW,EACX,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,GACjB,CAAA;AACD,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,EAC1B,qBAAqB,EACrB,6BAA6B,EAC7B,YAAY,EACZ,2BAA2B,EAC3B,eAAe,EACf,eAAe,EACf,aAAa,EACb,cAAc,EACd,wBAAwB,EACxB,0BAA0B,EAC1B,kBAAkB,EAClB,2BAA2B,EAC3B,gBAAgB,EAChB,uCAAuC,EACvC,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,wBAAwB,EACxB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,eAAe,EACf,cAAc,EACd,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,8BAA8B,EAC9B,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,aAAa,EACb,uBAAuB,GACxB,CAAA"}

package/dist/src/orchestrator/index.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTokenAddressSupported = exports.isRateLimited = exports.isValidationError = exports.isAuthError = exports.isRetryable = exports.isOrchestratorError = exports.getAllSupportedChainsAndTokens = exports.getSupportedTokens = exports.getTokenDecimals = exports.getTokenAddress = exports.getTokenSymbol = exports.getWethAddress = exports.UnsupportedTokenError = exports.UnsupportedChainIdError = exports.UnsupportedChainError = exports.TokenNotSupportedError = exports.UnauthorizedError = exports.UnprocessableEntityError = exports.SimulationFailedError = exports.ServiceUnavailableError = exports.SchemaValidationError = exports.RateLimitedError = exports.ResourceNotFoundError = exports.InternalServerError = exports.IntentNotFoundError = exports.OrchestratorError = exports.OnlyOneTargetTokenAmountCanBeUnsetError = exports.NoPathFoundError = exports.InvalidIntentSignatureError = exports.InvalidApiKeyError = exports.InsufficientLiquidityError = exports.InsufficientBalanceError = exports.ForbiddenError = exports.ConflictError = exports.BodyParserError = exports.BadRequestError = exports.AuthenticationRequiredError = exports.Orchestrator = exports.RHINESTONE_SPOKE_POOL_ADDRESS = exports.INTENT_STATUS_CLAIMED = exports.INTENT_STATUS_PRECONFIRMED = exports.INTENT_STATUS_FAILED = exports.INTENT_STATUS_FILLED = exports.INTENT_STATUS_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, "BadRequestError", { enumerable: true, get: function () { return error_1.BadRequestError; } });
+Object.defineProperty(exports, "BodyParserError", { enumerable: true, get: function () { return error_1.BodyParserError; } });
+Object.defineProperty(exports, "ConflictError", { enumerable: true, get: function () { return error_1.ConflictError; } });
+Object.defineProperty(exports, "ForbiddenError", { enumerable: true, get: function () { return error_1.ForbiddenError; } });
+Object.defineProperty(exports, "InsufficientBalanceError", { enumerable: true, get: function () { return error_1.InsufficientBalanceError; } });
+Object.defineProperty(exports, "InsufficientLiquidityError", { enumerable: true, get: function () { return error_1.InsufficientLiquidityError; } });
+Object.defineProperty(exports, "IntentNotFoundError", { enumerable: true, get: function () { return error_1.IntentNotFoundError; } });
+Object.defineProperty(exports, "InternalServerError", { enumerable: true, get: function () { return error_1.InternalServerError; } });
+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, "isAuthError", { enumerable: true, get: function () { return error_1.isAuthError; } });
+Object.defineProperty(exports, "isOrchestratorError", { enumerable: true, get: function () { return error_1.isOrchestratorError; } });
+Object.defineProperty(exports, "isRateLimited", { enumerable: true, get: function () { return error_1.isRateLimited; } });
+Object.defineProperty(exports, "isRetryable", { enumerable: true, get: function () { return error_1.isRetryable; } });
+Object.defineProperty(exports, "isValidationError", { enumerable: true, get: function () { return error_1.isValidationError; } });
+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, "RateLimitedError", { enumerable: true, get: function () { return error_1.RateLimitedError; } });
+Object.defineProperty(exports, "ResourceNotFoundError", { enumerable: true, get: function () { return error_1.ResourceNotFoundError; } });
+Object.defineProperty(exports, "SchemaValidationError", { enumerable: true, get: function () { return error_1.SchemaValidationError; } });
+Object.defineProperty(exports, "ServiceUnavailableError", { enumerable: true, get: function () { return error_1.ServiceUnavailableError; } });
+Object.defineProperty(exports, "SimulationFailedError", { enumerable: true, get: function () { return error_1.SimulationFailedError; } });
+Object.defineProperty(exports, "TokenNotSupportedError", { enumerable: true, get: function () { return error_1.TokenNotSupportedError; } });
+Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return error_1.UnauthorizedError; } });
+Object.defineProperty(exports, "UnprocessableEntityError", { enumerable: true, get: function () { return error_1.UnprocessableEntityError; } });
+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, "getAllSupportedChainsAndTokens", { enumerable: true, get: function () { return registry_1.getAllSupportedChainsAndTokens; } });
+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, "getTokenDecimals", { enumerable: true, get: function () { return registry_1.getTokenDecimals; } });
+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_CLAIMED", { enumerable: true, get: function () { return types_1.INTENT_STATUS_CLAIMED; } });
+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_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; } });
+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,22 @@
+import { type Address, type Chain } from 'viem';
+import type { TokenSymbol } from '../types';
+import type { TokenConfig } from './types';
+declare function getSupportedChainIds(): number[];
+declare function getWethAddress(chain: Chain): Address;
+declare function getTokenSymbol(tokenAddress: Address, chainId: number): string | undefined;
+declare function getTokenAddress(tokenSymbol: TokenSymbol, chainId: number): Address;
+declare function getTokenDecimals(tokenSymbol: TokenSymbol, chainId: number): number;
+declare function getChainById(chainId: number): Chain;
+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;
+declare function getAllSupportedChainsAndTokens(): {
+    chainId: number;
+    tokens: TokenConfig[];
+}[];
+export { getTokenSymbol, getTokenAddress, getTokenDecimals, getWethAddress, getChainById, getSupportedTokens, getSupportedChainIds, isTestnet, isTokenAddressSupported, getDefaultAccountAccessList, resolveTokenAddress, getAllSupportedChainsAndTokens, };
+//# 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":"AAKA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,EAAa,MAAM,MAAM,CAAA;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE1C,iBAAS,oBAAoB,IAAI,MAAM,EAAE,CAExC;AAMD,iBAAS,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAY7C;AAED,iBAAS,cAAc,CACrB,YAAY,EAAE,OAAO,EACrB,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,SAAS,CAWpB;AAED,iBAAS,eAAe,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAY3E;AAED,iBAAS,gBAAgB,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAY3E;AAED,iBAAS,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAM5C;AAED,iBAAS,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAG3C;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,iBAAS,8BAA8B,IAAI;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,WAAW,EAAE,CAAA;CACtB,EAAE,CAMF;AAED,OAAO,EACL,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,oBAAoB,EACpB,SAAS,EACT,uBAAuB,EACvB,2BAA2B,EAC3B,mBAAmB,EACnB,8BAA8B,GAC/B,CAAA"}

package/dist/src/orchestrator/registry.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenSymbol = getTokenSymbol;
+exports.getTokenAddress = getTokenAddress;
+exports.getTokenDecimals = getTokenDecimals;
+exports.getWethAddress = getWethAddress;
+exports.getChainById = getChainById;
+exports.getSupportedTokens = getSupportedTokens;
+exports.getSupportedChainIds = getSupportedChainIds;
+exports.isTestnet = isTestnet;
+exports.isTokenAddressSupported = isTokenAddressSupported;
+exports.getDefaultAccountAccessList = getDefaultAccountAccessList;
+exports.resolveTokenAddress = resolveTokenAddress;
+exports.getAllSupportedChainsAndTokens = getAllSupportedChainsAndTokens;
+const shared_configs_1 = require("@rhinestone/shared-configs");
+const viem_1 = require("viem");
+const error_1 = require("./error");
+function getSupportedChainIds() {
+    return shared_configs_1.chains.map((chain) => chain.id);
+}
+function getChainEntry(chainId) {
+    return shared_configs_1.chainRegistry[chainId.toString()];
+}
+function getWethAddress(chain) {
+    const chainEntry = getChainEntry(chain.id);
+    if (!chainEntry) {
+        throw new error_1.UnsupportedChainError(chain.id);
+    }
+    const wethToken = chainEntry.tokens.find((token) => token.symbol === 'WETH');
+    if (!wethToken) {
+        throw new error_1.UnsupportedTokenError('WETH', chain.id);
+    }
+    return wethToken.address;
+}
+function getTokenSymbol(tokenAddress, chainId) {
+    const chainEntry = getChainEntry(chainId);
+    if (!chainEntry) {
+        throw new error_1.UnsupportedChainError(chainId);
+    }
+    const token = chainEntry.tokens.find((t) => t.address.toLowerCase() === tokenAddress.toLowerCase());
+    return token?.symbol;
+}
+function getTokenAddress(tokenSymbol, chainId) {
+    const chainEntry = getChainEntry(chainId);
+    if (!chainEntry) {
+        throw new error_1.UnsupportedChainError(chainId);
+    }
+    const token = chainEntry.tokens.find((t) => t.symbol === tokenSymbol);
+    if (!token) {
+        throw new error_1.UnsupportedTokenError(tokenSymbol, chainId);
+    }
+    return token.address;
+}
+function getTokenDecimals(tokenSymbol, chainId) {
+    const chainEntry = getChainEntry(chainId);
+    if (!chainEntry) {
+        throw new error_1.UnsupportedChainError(chainId);
+    }
+    const token = chainEntry.tokens.find((t) => t.symbol === tokenSymbol);
+    if (!token) {
+        throw new error_1.UnsupportedTokenError(tokenSymbol, chainId);
+    }
+    return token.decimals;
+}
+function getChainById(chainId) {
+    const chain = shared_configs_1.chains.find((chain) => chain.id === chainId);
+    if (!chain) {
+        throw new error_1.UnsupportedChainError(chainId);
+    }
+    return chain;
+}
+function isTestnet(chainId) {
+    const chain = getChainById(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_1.UnsupportedChainError(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);
+}
+function getAllSupportedChainsAndTokens() {
+    const supportedChainIds = getSupportedChainIds();
+    return supportedChainIds.map((chainId) => ({
+        chainId,
+        tokens: getSupportedTokens(chainId),
+    }));
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=registry.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.test.d.ts","sourceRoot":"","sources":["../../../orchestrator/registry.test.ts"],"names":[],"mappings":""}