@rhinestone/sdk 1.4.2 → 2.0.0-beta.0

package/dist/src/orchestrator/client.js

@@ -1,23 +1,20 @@
-"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;
-    apiKey;
-    headers;
-    constructor(serverUrl, apiKey, headers) {
+    authProvider;
+    extraHeaders;
+    constructor(serverUrl, authProvider, headers) {
         this.serverUrl = serverUrl;
-        this.apiKey = apiKey;
-        this.headers = headers;
+        this.authProvider = authProvider;
+        this.extraHeaders = headers;
     }
     async getPortfolio(userAddress, filter) {
         const params = new URLSearchParams();
@@ -32,7 +29,7 @@ class Orchestrator {
         const url = new URL(`${this.serverUrl}/accounts/${userAddress}/portfolio`);
         url.search = params.toString();
         const json = await this.fetch(url.toString(), {
-            headers: this.getHeaders(),
+            headers: await this.getHeaders(),
         });
         const portfolioResponse = json.portfolio;
         const portfolio = portfolioResponse.map((tokenResponse) => ({
@@ -52,18 +49,18 @@ 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: this.getHeaders(),
+            headers: await this.getHeaders(),
             body: JSON.stringify(body),
         });
     }
     async splitIntents(input) {
         const response = await fetch(`${this.serverUrl}/intents/split`, {
             method: 'POST',
-            headers: this.getHeaders(),
-            body: JSON.stringify((0, utils_1.convertBigIntFields)({
+            headers: await this.getHeaders(),
+            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,37 +99,48 @@ class Orchestrator {
                 headers: {},
             },
         });
-        throw new error_1.OrchestratorError({ message: 'Unexpected error' });
+        throw new OrchestratorError({ message: 'Unexpected error' });
     }
-    async submitIntent(signedIntentOpUnformatted, dryRun) {
-        const signedIntentOp = (0, utils_1.convertBigIntFields)(signedIntentOpUnformatted);
+    async submitIntent(signedIntentOpUnformatted, dryRun, policyContext) {
+        const signedIntentOp = convertBigIntFields(signedIntentOpUnformatted);
         if (dryRun) {
             signedIntentOp.options = {
                 dryRun: true,
             };
         }
         const body = { signedIntentOp };
+        const headers = policyContext
+            ? await this.getSubmitHeaders(policyContext.intentInput, policyContext.isSponsored)
+            : await this.getHeaders();
         return await this.fetch(`${this.serverUrl}/intent-operations`, {
             method: 'POST',
-            headers: this.getHeaders(),
+            headers,
             body: JSON.stringify(body),
         });
     }
     async getIntentOpStatus(intentId) {
         return await this.fetch(`${this.serverUrl}/intent-operation/${intentId.toString()}`, {
-            headers: this.getHeaders(),
+            headers: await this.getHeaders(),
         });
     }
-    getHeaders() {
-        const headers = {
+    async getHeaders() {
+        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,
+        };
+    }
+    async getSubmitHeaders(intentInput, isSponsored) {
+        const auth = await this.authProvider.getSubmitHeaders(intentInput, isSponsored);
+        return {
+            'Content-Type': 'application/json',
+            'x-sdk-version': SDK_VERSION,
+            ...auth,
+            ...this.extraHeaders,
         };
-        if (this.apiKey) {
-            headers['x-api-key'] = this.apiKey;
-        }
-        return { ...headers, ...this.headers };
     }
     async fetch(url, options) {
         const response = await fetch(url, options);
@@ -207,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);
@@ -227,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,
                     });
@@ -265,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')) {
@@ -285,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,
@@ -358,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.4.2";
+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.4.2';
-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,11 @@
-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';
-declare function getOrchestrator(apiKey?: string, orchestratorUrl?: string, headers?: Record<string, string>): Orchestrator;
+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, };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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,cAAc,EACd,SAAS,EACT,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,EACxB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,YAAY,CAMd;AAED,YAAY,EACV,cAAc,EACd,SAAS,EACT,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../orchestrator/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACpD,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,cAAc,EACd,SAAS,EACT,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,YAAY,EAAE,YAAY,EAC1B,eAAe,CAAC,EAAE,MAAM,EACxB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC/B,YAAY,CAMd;AAED,YAAY,EACV,cAAc,EACd,SAAS,EACT,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"}