@rhinestone/sdk 1.5.0 → 2.0.0-beta.0

package/dist/src/orchestrator/client.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Orchestrator = void 0;
-const consts_1 = require("./consts");
-const error_1 = require("./error");
-const utils_1 = require("./utils");
+import { API_VERSION, SDK_VERSION } from './consts.js';
+import { AuthenticationRequiredError, BadRequestError, BodyParserError, ConflictError, ForbiddenError, InsufficientBalanceError, InsufficientLiquidityError, IntentNotFoundError, InternalServerError, InvalidApiKeyError, InvalidIntentSignatureError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, RateLimitedError, ResourceNotFoundError, ServiceUnavailableError, SimulationFailedError, TokenNotSupportedError, UnauthorizedError, UnsupportedChainError, UnsupportedChainIdError, UnsupportedTokenError, } from './error.js';
+import { convertBigIntFields } from './utils.js';
 function parseTokenAmountsRecord(record) {
     return Object.fromEntries(Object.entries(record).map(([addr, amount]) => [
         addr,
         BigInt(amount),
     ]));
 }
-class Orchestrator {
+export class Orchestrator {
     serverUrl;
     authProvider;
     extraHeaders;
@@ -52,7 +49,7 @@ class Orchestrator {
         return portfolio;
     }
     async getIntentRoute(input) {
-        const body = (0, utils_1.convertBigIntFields)(input);
+        const body = convertBigIntFields(input);
         return await this.fetch(`${this.serverUrl}/intents/route`, {
             method: 'POST',
             headers: await this.getHeaders(),
@@ -63,7 +60,7 @@ class Orchestrator {
         const response = await fetch(`${this.serverUrl}/intents/split`, {
             method: 'POST',
             headers: await this.getHeaders(),
-            body: JSON.stringify((0, utils_1.convertBigIntFields)({
+            body: JSON.stringify(convertBigIntFields({
                 chainId: input.chain.id,
                 tokens: input.tokens,
                 settlementLayers: input.settlementLayers,
@@ -88,7 +85,7 @@ class Orchestrator {
         }
         if (response.status === 422 &&
             errorData.error === 'INSUFFICIENT_LIQUIDITY') {
-            throw new error_1.InsufficientLiquidityError({
+            throw new InsufficientLiquidityError({
                 availableIntents: errorData.availableIntents.map(parseTokenAmountsRecord),
                 unfillable: parseTokenAmountsRecord(errorData.unfillable),
                 traceId: errorData.traceId,
@@ -102,10 +99,10 @@ class Orchestrator {
                 headers: {},
             },
         });
-        throw new error_1.OrchestratorError({ message: 'Unexpected error' });
+        throw new OrchestratorError({ message: 'Unexpected error' });
     }
     async submitIntent(signedIntentOpUnformatted, dryRun, policyContext) {
-        const signedIntentOp = (0, utils_1.convertBigIntFields)(signedIntentOpUnformatted);
+        const signedIntentOp = convertBigIntFields(signedIntentOpUnformatted);
         if (dryRun) {
             signedIntentOp.options = {
                 dryRun: true,
@@ -130,8 +127,8 @@ class Orchestrator {
         const auth = await this.authProvider.getHeaders();
         return {
             'Content-Type': 'application/json',
-            'x-sdk-version': consts_1.SDK_VERSION,
-            'x-api-version': consts_1.API_VERSION,
+            'x-sdk-version': SDK_VERSION,
+            'x-api-version': API_VERSION,
             ...auth,
             ...this.extraHeaders,
         };
@@ -140,7 +137,7 @@ class Orchestrator {
         const auth = await this.authProvider.getSubmitHeaders(intentInput, isSponsored);
         return {
             'Content-Type': 'application/json',
-            'x-sdk-version': consts_1.SDK_VERSION,
+            'x-sdk-version': SDK_VERSION,
             ...auth,
             ...this.extraHeaders,
         };
@@ -218,13 +215,13 @@ class Orchestrator {
             if (status === 429) {
                 const retryAfter = headers?.retryAfter;
                 const context = { traceId, retryAfter };
-                throw new error_1.RateLimitedError({
+                throw new RateLimitedError({
                     ...baseParams,
                     context,
                 });
             }
             if (status === 503) {
-                throw new error_1.ServiceUnavailableError(baseParams);
+                throw new ServiceUnavailableError(baseParams);
             }
             if (message) {
                 this.parseErrorMessage(message, baseParams);
@@ -238,36 +235,36 @@ class Orchestrator {
             }
             switch (status) {
                 case 400:
-                    throw new error_1.BadRequestError({
+                    throw new BadRequestError({
                         ...baseParams,
                         context: { traceId, errors },
                         message: message,
                     });
                 case 401:
                     if (message === 'Authentication is required') {
-                        throw new error_1.AuthenticationRequiredError(baseParams);
+                        throw new AuthenticationRequiredError(baseParams);
                     }
-                    throw new error_1.UnauthorizedError(baseParams);
+                    throw new UnauthorizedError(baseParams);
                 case 403:
-                    throw new error_1.ForbiddenError(baseParams);
+                    throw new ForbiddenError(baseParams);
                 case 404:
-                    throw new error_1.ResourceNotFoundError(baseParams);
+                    throw new ResourceNotFoundError(baseParams);
                 case 409:
-                    throw new error_1.ConflictError(baseParams);
+                    throw new ConflictError(baseParams);
                 case 500:
                     if (errors && errors.length > 0) {
                         const mergedParams = {
                             ...baseParams,
                             context: { ...errors[0].context, traceId },
                         };
-                        throw new error_1.OrchestratorError({
+                        throw new OrchestratorError({
                             ...mergedParams,
                             message: errors[0].message || 'Internal Server Error',
                         });
                     }
-                    throw new error_1.InternalServerError(baseParams);
+                    throw new InternalServerError(baseParams);
                 default:
-                    throw new error_1.OrchestratorError({
+                    throw new OrchestratorError({
                         ...baseParams,
                         message: message || errorType,
                     });
@@ -276,19 +273,19 @@ class Orchestrator {
     }
     parseErrorMessage(message, errorParams) {
         if (message === 'Insufficient balance') {
-            throw new error_1.InsufficientBalanceError(errorParams);
+            throw new InsufficientBalanceError(errorParams);
         }
         else if (message === 'Unsupported chain id' ||
             message === 'Unsupported chain ids') {
-            throw new error_1.UnsupportedChainIdError(errorParams);
+            throw new UnsupportedChainIdError(errorParams);
         }
         else if (message.startsWith('Unsupported chain ')) {
             const chainIdMatch = message.match(/Unsupported chain (\d+)/);
             if (chainIdMatch) {
                 const chainId = parseInt(chainIdMatch[1], 10);
-                throw new error_1.UnsupportedChainError(chainId, errorParams);
+                throw new UnsupportedChainError(chainId, errorParams);
             }
-            throw new error_1.UnsupportedChainIdError(errorParams);
+            throw new UnsupportedChainIdError(errorParams);
         }
         else if (message.includes('Unsupported token') &&
             message.includes('for chain')) {
@@ -296,70 +293,70 @@ class Orchestrator {
             if (tokenMatch) {
                 const tokenSymbol = tokenMatch[1];
                 const chainId = parseInt(tokenMatch[2], 10);
-                throw new error_1.UnsupportedTokenError(tokenSymbol, chainId, errorParams);
+                throw new UnsupportedTokenError(tokenSymbol, chainId, errorParams);
             }
-            throw new error_1.OrchestratorError({ message, ...errorParams });
+            throw new OrchestratorError({ message, ...errorParams });
         }
         else if (message === 'Unsupported token addresses') {
             // generic unsupported tokens without specific symbol/chain context
-            throw new error_1.BadRequestError({ message, ...errorParams });
+            throw new BadRequestError({ message, ...errorParams });
         }
         else if (message.includes('not supported on chain')) {
             const tokenMatch = message.match(/Token (.+) not supported on chain (\d+)/);
             if (tokenMatch) {
                 const tokenAddress = tokenMatch[1];
                 const chainId = parseInt(tokenMatch[2], 10);
-                throw new error_1.TokenNotSupportedError(tokenAddress, chainId, errorParams);
+                throw new TokenNotSupportedError(tokenAddress, chainId, errorParams);
             }
-            throw new error_1.OrchestratorError({ message, ...errorParams });
+            throw new OrchestratorError({ message, ...errorParams });
         }
         else if (message === 'Authentication is required') {
-            throw new error_1.AuthenticationRequiredError(errorParams);
+            throw new AuthenticationRequiredError(errorParams);
         }
         else if (message === 'Invalid API key') {
-            throw new error_1.InvalidApiKeyError(errorParams);
+            throw new InvalidApiKeyError(errorParams);
         }
         else if (message === 'Insufficient permissions') {
-            throw new error_1.ForbiddenError(errorParams);
+            throw new ForbiddenError(errorParams);
         }
         else if (message === 'Invalid bundle signature') {
-            throw new error_1.InvalidIntentSignatureError(errorParams);
+            throw new InvalidIntentSignatureError(errorParams);
         }
         else if (message === 'Invalid checksum signature') {
-            throw new error_1.InvalidIntentSignatureError(errorParams);
+            throw new InvalidIntentSignatureError(errorParams);
         }
         else if (message === 'Only one target token amount can be unset' ||
             message === 'Only one max-out transfer is allowed') {
-            throw new error_1.OnlyOneTargetTokenAmountCanBeUnsetError(errorParams);
+            throw new OnlyOneTargetTokenAmountCanBeUnsetError(errorParams);
         }
         else if (message === 'No valid settlement plan found for the given transfers' ||
             message === 'No valid transfers sent for settlement quotes' ||
             message === 'No Path Found') {
-            throw new error_1.NoPathFoundError(errorParams);
+            throw new NoPathFoundError(errorParams);
         }
         else if (message === 'Emissary is not enabled' ||
             message === 'Emissary is not the expected address') {
-            throw new error_1.ForbiddenError(errorParams);
+            throw new ForbiddenError(errorParams);
         }
         else if (message.includes('No such intent with nonce') ||
             message === 'Order bundle not found') {
-            throw new error_1.IntentNotFoundError(errorParams);
+            throw new IntentNotFoundError(errorParams);
         }
         else if (message === 'Could not retrieve a valid quote from any aggregator') {
-            throw new error_1.NoPathFoundError(errorParams);
+            throw new NoPathFoundError(errorParams);
         }
         else if (message === 'No aggregators available for swap') {
-            throw new error_1.InternalServerError(errorParams);
+            throw new InternalServerError(errorParams);
         }
         else if (message === 'entity.parse.failed' ||
             message === 'entity.too.large' ||
             message === 'encoding.unsupported') {
-            throw new error_1.BodyParserError({ message, ...errorParams });
+            throw new BodyParserError({ message, ...errorParams });
         }
         else if (message === 'Bundle simulation failed') {
             const simulations = errorParams.context.error.simulations;
             const { traceId, errorType, statusCode, context } = errorParams;
-            throw new error_1.SimulationFailedError({
+            throw new SimulationFailedError({
                 message,
                 context,
                 errorType,
@@ -369,8 +366,7 @@ class Orchestrator {
             });
         }
         else {
-            throw new error_1.OrchestratorError({ message, ...errorParams });
+            throw new OrchestratorError({ message, ...errorParams });
         }
     }
 }
-exports.Orchestrator = Orchestrator;

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

@@ -1,6 +1,6 @@
 declare const PROD_ORCHESTRATOR_URL = "https://v1.orchestrator.rhinestone.dev";
 declare const RHINESTONE_SPOKE_POOL_ADDRESS = "0x000000000060f6e853447881951574cdd0663530";
-declare const SDK_VERSION = "1.5.0";
+declare const SDK_VERSION = "2.0.0-beta.0";
 declare const API_VERSION = "2026-01.alps";
 export { PROD_ORCHESTRATOR_URL, RHINESTONE_SPOKE_POOL_ADDRESS, SDK_VERSION, API_VERSION, };
 //# sourceMappingURL=consts.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../../../orchestrator/consts.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,qBAAqB,2CAA2C,CAAA;AACtE,QAAA,MAAM,6BAA6B,+CACW,CAAA;AAE9C,QAAA,MAAM,WAAW,UAAU,CAAA;AAC3B,QAAA,MAAM,WAAW,iBAAiB,CAAA;AAElC,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,WAAW,EACX,WAAW,GACZ,CAAA"}
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../../../orchestrator/consts.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,qBAAqB,2CAA2C,CAAA;AACtE,QAAA,MAAM,6BAA6B,+CACW,CAAA;AAE9C,QAAA,MAAM,WAAW,iBAAiB,CAAA;AAClC,QAAA,MAAM,WAAW,iBAAiB,CAAA;AAElC,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,WAAW,EACX,WAAW,GACZ,CAAA"}

package/dist/src/orchestrator/consts.js

@@ -1,11 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.API_VERSION = exports.SDK_VERSION = exports.RHINESTONE_SPOKE_POOL_ADDRESS = exports.PROD_ORCHESTRATOR_URL = void 0;
 const PROD_ORCHESTRATOR_URL = 'https://v1.orchestrator.rhinestone.dev';
-exports.PROD_ORCHESTRATOR_URL = PROD_ORCHESTRATOR_URL;
 const RHINESTONE_SPOKE_POOL_ADDRESS = '0x000000000060f6e853447881951574cdd0663530';
-exports.RHINESTONE_SPOKE_POOL_ADDRESS = RHINESTONE_SPOKE_POOL_ADDRESS;
-const SDK_VERSION = '1.5.0';
-exports.SDK_VERSION = SDK_VERSION;
+const SDK_VERSION = '2.0.0-beta.0';
 const API_VERSION = '2026-01.alps';
-exports.API_VERSION = API_VERSION;
+export { PROD_ORCHESTRATOR_URL, RHINESTONE_SPOKE_POOL_ADDRESS, SDK_VERSION, API_VERSION, };

package/dist/src/orchestrator/error.js

@@ -1,11 +1,3 @@
-"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;
@@ -36,7 +28,6 @@ class OrchestratorError extends Error {
         return this._statusCode;
     }
 }
-exports.OrchestratorError = OrchestratorError;
 class InsufficientBalanceError extends OrchestratorError {
     constructor(params) {
         super({
@@ -45,7 +36,6 @@ class InsufficientBalanceError extends OrchestratorError {
         });
     }
 }
-exports.InsufficientBalanceError = InsufficientBalanceError;
 class UnsupportedChainIdError extends OrchestratorError {
     constructor(params) {
         super({
@@ -54,7 +44,6 @@ class UnsupportedChainIdError extends OrchestratorError {
         });
     }
 }
-exports.UnsupportedChainIdError = UnsupportedChainIdError;
 class UnsupportedChainError extends OrchestratorError {
     constructor(chainId, params) {
         super({
@@ -63,7 +52,6 @@ class UnsupportedChainError extends OrchestratorError {
         });
     }
 }
-exports.UnsupportedChainError = UnsupportedChainError;
 class UnsupportedTokenError extends OrchestratorError {
     constructor(tokenSymbol, chainId, params) {
         super({
@@ -72,7 +60,6 @@ class UnsupportedTokenError extends OrchestratorError {
         });
     }
 }
-exports.UnsupportedTokenError = UnsupportedTokenError;
 class TokenNotSupportedError extends OrchestratorError {
     constructor(tokenAddress, chainId, params) {
         super({
@@ -81,7 +68,6 @@ class TokenNotSupportedError extends OrchestratorError {
         });
     }
 }
-exports.TokenNotSupportedError = TokenNotSupportedError;
 class AuthenticationRequiredError extends OrchestratorError {
     constructor(params) {
         super({
@@ -90,7 +76,6 @@ class AuthenticationRequiredError extends OrchestratorError {
         });
     }
 }
-exports.AuthenticationRequiredError = AuthenticationRequiredError;
 class InvalidApiKeyError extends OrchestratorError {
     constructor(params) {
         super({
@@ -99,7 +84,6 @@ class InvalidApiKeyError extends OrchestratorError {
         });
     }
 }
-exports.InvalidApiKeyError = InvalidApiKeyError;
 class InvalidIntentSignatureError extends OrchestratorError {
     constructor(params) {
         super({
@@ -108,7 +92,6 @@ class InvalidIntentSignatureError extends OrchestratorError {
         });
     }
 }
-exports.InvalidIntentSignatureError = InvalidIntentSignatureError;
 class OnlyOneTargetTokenAmountCanBeUnsetError extends OrchestratorError {
     constructor(params) {
         super({
@@ -117,7 +100,6 @@ class OnlyOneTargetTokenAmountCanBeUnsetError extends OrchestratorError {
         });
     }
 }
-exports.OnlyOneTargetTokenAmountCanBeUnsetError = OnlyOneTargetTokenAmountCanBeUnsetError;
 class NoPathFoundError extends OrchestratorError {
     constructor(params) {
         super({
@@ -126,7 +108,6 @@ class NoPathFoundError extends OrchestratorError {
         });
     }
 }
-exports.NoPathFoundError = NoPathFoundError;
 class IntentNotFoundError extends OrchestratorError {
     constructor(params) {
         super({
@@ -135,7 +116,6 @@ class IntentNotFoundError extends OrchestratorError {
         });
     }
 }
-exports.IntentNotFoundError = IntentNotFoundError;
 class SchemaValidationError extends OrchestratorError {
     constructor(params) {
         super({
@@ -144,7 +124,6 @@ class SchemaValidationError extends OrchestratorError {
         });
     }
 }
-exports.SchemaValidationError = SchemaValidationError;
 class RateLimitedError extends OrchestratorError {
     constructor(params) {
         super({
@@ -153,7 +132,6 @@ class RateLimitedError extends OrchestratorError {
         });
     }
 }
-exports.RateLimitedError = RateLimitedError;
 class ServiceUnavailableError extends OrchestratorError {
     constructor(params) {
         super({
@@ -162,7 +140,6 @@ class ServiceUnavailableError extends OrchestratorError {
         });
     }
 }
-exports.ServiceUnavailableError = ServiceUnavailableError;
 class UnauthorizedError extends OrchestratorError {
     constructor(params) {
         super({
@@ -171,7 +148,6 @@ class UnauthorizedError extends OrchestratorError {
         });
     }
 }
-exports.UnauthorizedError = UnauthorizedError;
 class ForbiddenError extends OrchestratorError {
     constructor(params) {
         super({
@@ -180,7 +156,6 @@ class ForbiddenError extends OrchestratorError {
         });
     }
 }
-exports.ForbiddenError = ForbiddenError;
 class ResourceNotFoundError extends OrchestratorError {
     constructor(params) {
         super({
@@ -189,7 +164,6 @@ class ResourceNotFoundError extends OrchestratorError {
         });
     }
 }
-exports.ResourceNotFoundError = ResourceNotFoundError;
 class ConflictError extends OrchestratorError {
     constructor(params) {
         super({
@@ -198,7 +172,6 @@ class ConflictError extends OrchestratorError {
         });
     }
 }
-exports.ConflictError = ConflictError;
 class BadRequestError extends OrchestratorError {
     constructor(params) {
         super({
@@ -207,7 +180,6 @@ class BadRequestError extends OrchestratorError {
         });
     }
 }
-exports.BadRequestError = BadRequestError;
 class UnprocessableEntityError extends OrchestratorError {
     constructor(params) {
         super({
@@ -216,7 +188,6 @@ class UnprocessableEntityError extends OrchestratorError {
         });
     }
 }
-exports.UnprocessableEntityError = UnprocessableEntityError;
 class InternalServerError extends OrchestratorError {
     constructor(params) {
         super({
@@ -225,7 +196,6 @@ class InternalServerError extends OrchestratorError {
         });
     }
 }
-exports.InternalServerError = InternalServerError;
 class BodyParserError extends OrchestratorError {
     constructor(params) {
         super({
@@ -234,7 +204,6 @@ class BodyParserError extends OrchestratorError {
         });
     }
 }
-exports.BodyParserError = BodyParserError;
 class SimulationFailedError extends OrchestratorError {
     constructor(params) {
         super({
@@ -243,7 +212,6 @@ class SimulationFailedError extends OrchestratorError {
         });
     }
 }
-exports.SimulationFailedError = SimulationFailedError;
 class InsufficientLiquidityError extends OrchestratorError {
     availableIntents;
     unfillable;
@@ -258,7 +226,6 @@ class InsufficientLiquidityError extends OrchestratorError {
         this.unfillable = params.unfillable;
     }
 }
-exports.InsufficientLiquidityError = InsufficientLiquidityError;
 function isOrchestratorError(error) {
     return error instanceof OrchestratorError;
 }
@@ -281,3 +248,4 @@ function isRetryable(error) {
         return false;
     return error.statusCode === 500 || error.statusCode === 503;
 }
+export { isOrchestratorError, isRetryable, isAuthError, isValidationError, isRateLimited, OrchestratorError, InsufficientLiquidityError, InsufficientBalanceError, UnsupportedChainIdError, UnsupportedChainError, UnsupportedTokenError, TokenNotSupportedError, AuthenticationRequiredError, InvalidApiKeyError, InvalidIntentSignatureError, OnlyOneTargetTokenAmountCanBeUnsetError, NoPathFoundError, IntentNotFoundError, SchemaValidationError, RateLimitedError, ServiceUnavailableError, UnauthorizedError, ForbiddenError, ResourceNotFoundError, ConflictError, BadRequestError, UnprocessableEntityError, InternalServerError, BodyParserError, SimulationFailedError, };

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

@@ -1,10 +1,10 @@
-import type { AuthProvider } from '../auth/provider';
-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, AuxiliaryFunds, Execution, 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';
+import type { AuthProvider } from '../auth/provider.js';
+import { Orchestrator } from './client.js';
+import { RHINESTONE_SPOKE_POOL_ADDRESS } from './consts.js';
+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.js';
+import { getAllSupportedChainsAndTokens, getSupportedTokens, getTokenAddress, getTokenDecimals, getTokenSymbol, getWethAddress, isTokenAddressSupported } from './registry.js';
+import type { ApprovalRequired, AuxiliaryFunds, Execution, IntentInput, IntentOp, IntentOpStatus, IntentResult, IntentRoute, Portfolio, SettlementLayer, SignedIntentOp, SplitIntentsInput, SplitIntentsResult, SupportedChain, TokenConfig, TokenRequirements, WrapRequired } from './types.js';
+import { INTENT_STATUS_CLAIMED, INTENT_STATUS_COMPLETED, INTENT_STATUS_EXPIRED, INTENT_STATUS_FAILED, INTENT_STATUS_FILLED, INTENT_STATUS_PENDING, INTENT_STATUS_PRECONFIRMED } from './types.js';
 declare function getOrchestrator(authProvider: AuthProvider, orchestratorUrl?: string, headers?: Record<string, string>): Orchestrator;
 export type { AuxiliaryFunds, Execution, 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, };

package/dist/src/orchestrator/index.js

@@ -1,58 +1,9 @@
-"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; } });
+import { Orchestrator } from './client.js';
+import { PROD_ORCHESTRATOR_URL, RHINESTONE_SPOKE_POOL_ADDRESS } from './consts.js';
+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.js';
+import { getAllSupportedChainsAndTokens, getSupportedTokens, getTokenAddress, getTokenDecimals, getTokenSymbol, getWethAddress, isTokenAddressSupported, } from './registry.js';
+import { INTENT_STATUS_CLAIMED, INTENT_STATUS_COMPLETED, INTENT_STATUS_EXPIRED, INTENT_STATUS_FAILED, INTENT_STATUS_FILLED, INTENT_STATUS_PENDING, INTENT_STATUS_PRECONFIRMED, } from './types.js';
 function getOrchestrator(authProvider, orchestratorUrl, headers) {
-    return new client_1.Orchestrator(orchestratorUrl ?? consts_1.PROD_ORCHESTRATOR_URL, authProvider, headers);
+    return new Orchestrator(orchestratorUrl ?? PROD_ORCHESTRATOR_URL, authProvider, headers);
 }
+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, };

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

@@ -1,6 +1,6 @@
 import { type Address, type Chain } from 'viem';
-import type { TokenSymbol } from '../types';
-import type { TokenConfig } from './types';
+import type { TokenSymbol } from '../types.js';
+import type { TokenConfig } from './types.js';
 declare function getSupportedChainIds(): number[];
 declare function getWethAddress(chain: Chain): Address;
 declare function getWrappedTokenAddress(chain: Chain): Address;