@rhinestone/sdk 2.0.0-beta.3 → 2.0.0-beta.30

package/dist/src/orchestrator/error.js

@@ -37,7 +37,25 @@ class UnauthorizedError extends OrchestratorError {
 }
 class ForbiddenError extends OrchestratorError {
     constructor(params) {
-        super({ ...params, code: 'FORBIDDEN' });
+        super({ ...params, code: params.code ?? 'FORBIDDEN' });
+    }
+}
+/**
+ * Thrown when an API key's scope denies the request.
+ *
+ * Subclass of `ForbiddenError` carrying the failed `scope` and the
+ * `required` / `actual` levels — distinct from a generic 403 so integrators
+ * can prompt the user to widen the key's scope rather than rotate it.
+ */
+class KeyScopeDeniedError extends ForbiddenError {
+    scope;
+    required;
+    actual;
+    constructor(params) {
+        super({ ...params, code: 'KEY_SCOPE_DENIED' });
+        this.scope = params.scope;
+        this.required = params.required;
+        this.actual = params.actual;
     }
 }
 class ConflictError extends OrchestratorError {
@@ -67,6 +85,27 @@ class SettlementExecutionError extends OrchestratorError {
         super({ ...params, code: 'SETTLEMENT_EXECUTION_ERROR' });
     }
 }
+class SimulationFailedError extends OrchestratorError {
+    nonce;
+    category;
+    errorSelector;
+    errorName;
+    errorArgs;
+    retryable;
+    retryHint;
+    simulations;
+    constructor(params) {
+        super({ ...params, code: 'SIMULATION_FAILED' });
+        this.nonce = params.nonce;
+        this.category = params.category;
+        this.errorSelector = params.errorSelector;
+        this.errorName = params.errorName;
+        this.errorArgs = params.errorArgs;
+        this.retryable = params.retryable ?? false;
+        this.retryHint = params.retryHint;
+        this.simulations = params.simulations ?? [];
+    }
+}
 class ExternalServiceTimeoutError extends OrchestratorError {
     constructor(params) {
         super({ ...params, code: 'EXTERNAL_SERVICE_TIMEOUT' });
@@ -106,6 +145,114 @@ class UnsupportedTokenError extends Error {
 function parseTokenAmounts(record) {
     return Object.fromEntries(Object.entries(record).map(([addr, amount]) => [addr, BigInt(amount)]));
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function booleanValue(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function recordValue(value) {
+    return isRecord(value) ? value : undefined;
+}
+const SIMULATION_ACTIONS = ['claim', 'fill'];
+const SIMULATION_RETRY_HINTS = ['RE_PREPARE', 'RETRY_LATER'];
+const SIMULATION_ERROR_CATEGORIES = [
+    'QUOTE_EXPIRED',
+    'ORDER_EXPIRED',
+    'PERMIT_EXPIRED',
+    'PERMIT2_NONCE_CONSUMED',
+    'EXECUTOR_NONCE_CONSUMED',
+    'INVALID_SIGNATURE',
+    'INVALID_PERMIT2_SIGNATURE',
+    'INVALID_CONTRACT_SIGNATURE',
+    'INVALID_SIGNER',
+    'INSUFFICIENT_BALANCE',
+    'INSUFFICIENT_ALLOWANCE',
+    'ACCOUNT_CREATION_FAILED',
+    'ACCOUNT_UNAUTHORIZED',
+    'ADAPTER_CALL_FAILED',
+    'EXECUTION_FAILED',
+    'CLAIM_FAILED',
+    'ROUTER_PAUSED',
+    'ADAPTER_NOT_FOUND',
+    'PANIC',
+    'REQUIRE_FAILED',
+    'UNCLASSIFIED_REVERT',
+    'EMPTY_REVERT',
+];
+function oneOf(value, allowed) {
+    return typeof value === 'string' && allowed.includes(value)
+        ? value
+        : undefined;
+}
+function stringArrayValue(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string')
+        : undefined;
+}
+function parseSimulationCall(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        chainId: stringValue(value.chainId),
+        to: stringValue(value.to),
+        data: stringValue(value.data),
+        value: stringValue(value.value),
+    };
+}
+function parseSimulationDetails(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return {
+        stateOverride: value.stateOverride,
+        blockNumber: stringValue(value.blockNumber),
+        relayer: stringValue(value.relayer),
+        simulationUrls: stringArrayValue(value.simulationUrls),
+    };
+}
+function isSimulationFailureSimulation(value) {
+    return isRecord(value) && value.success === false;
+}
+function parseSimulationFailureSimulation(value) {
+    if (!isSimulationFailureSimulation(value)) {
+        return undefined;
+    }
+    return {
+        success: false,
+        action: oneOf(value.action, SIMULATION_ACTIONS),
+        chainId: stringValue(value.chainId),
+        call: parseSimulationCall(value.call),
+        errorSelector: stringValue(value.errorSelector),
+        errorName: stringValue(value.errorName),
+        errorArgs: recordValue(value.errorArgs),
+        errorCategory: oneOf(value.errorCategory, SIMULATION_ERROR_CATEGORIES),
+        details: parseSimulationDetails(value.details),
+    };
+}
+function parseSimulationFailureDetails(details) {
+    if (!isRecord(details)) {
+        return {};
+    }
+    return {
+        nonce: stringValue(details.nonce),
+        category: oneOf(details.category, SIMULATION_ERROR_CATEGORIES),
+        errorSelector: stringValue(details.errorSelector),
+        errorName: stringValue(details.errorName),
+        errorArgs: recordValue(details.errorArgs),
+        retryable: booleanValue(details.retryable),
+        retryHint: oneOf(details.retryHint, SIMULATION_RETRY_HINTS),
+        simulations: Array.isArray(details.simulations)
+            ? details.simulations
+                .map(parseSimulationFailureSimulation)
+                .filter((simulation) => simulation !== undefined)
+            : undefined,
+    };
+}
 function parseErrorEnvelope(envelope, statusCode, retryAfter) {
     const base = {
         message: envelope.message,
@@ -133,6 +280,18 @@ function parseErrorEnvelope(envelope, statusCode, retryAfter) {
             return new UnauthorizedError(base);
         case 'FORBIDDEN':
             return new ForbiddenError(base);
+        case 'KEY_SCOPE_DENIED': {
+            const detail = Array.isArray(envelope.details)
+                ? envelope.details[0]
+                : undefined;
+            const context = (detail?.context ?? {});
+            return new KeyScopeDeniedError({
+                ...base,
+                scope: context.scope ?? '',
+                required: context.required ?? '',
+                actual: context.actual ?? '',
+            });
+        }
         case 'CONFLICT':
             return new ConflictError(base);
         case 'UNPROCESSABLE_CONTENT':
@@ -143,6 +302,11 @@ function parseErrorEnvelope(envelope, statusCode, retryAfter) {
             return new SettlementQuoteError(base);
         case 'SETTLEMENT_EXECUTION_ERROR':
             return new SettlementExecutionError(base);
+        case 'SIMULATION_FAILED':
+            return new SimulationFailedError({
+                ...base,
+                ...parseSimulationFailureDetails(envelope.details),
+            });
         case 'EXTERNAL_SERVICE_TIMEOUT':
             return new ExternalServiceTimeoutError(base);
         case 'RELAYER_MARKET_UNAVAILABLE':
@@ -165,9 +329,79 @@ function isValidationError(error) {
 function isAuthError(error) {
     return error instanceof UnauthorizedError || error instanceof ForbiddenError;
 }
+function isSimulationFailed(error) {
+    return error instanceof SimulationFailedError;
+}
 function isRetryable(error) {
     return (error instanceof InternalServerError ||
         error instanceof ExternalServiceTimeoutError ||
-        error instanceof RelayerMarketUnavailableError);
+        error instanceof RelayerMarketUnavailableError ||
+        (error instanceof SimulationFailedError && error.retryable));
+}
+// Transport-level error codes that escape `fetch` as raw errors rather than
+// typed HTTP envelopes. Spans Node/undici and common system codes.
+const CONNECTION_ERROR_CODES = new Set([
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ECONNABORTED',
+    'ETIMEDOUT',
+    'EPIPE',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+    'UND_ERR_SOCKET',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_HEADERS_TIMEOUT',
+    'UND_ERR_BODY_TIMEOUT',
+]);
+const CONNECTION_ERROR_MESSAGES = [
+    'socket connection was closed', // Bun
+    'fetch failed', // undici/Node (the coded cause is matched separately)
+    'failed to fetch', // Chrome/Edge
+    'networkerror when attempting to fetch', // Firefox
+    'network request failed',
+    'connection closed',
+    'connection reset',
+];
+/**
+ * Detects transport-level failures (connection reset, socket closed, DNS, TLS)
+ * that `fetch` rejects with instead of returning an HTTP response. Unlike HTTP
+ * errors — which the client converts into typed {@link OrchestratorError}s —
+ * these carry no status and bubble up untyped, so {@link isRetryable} misses
+ * them. They are safe to retry for idempotent reads (e.g. intent-status
+ * polling). We match by `code` and message across the cause chain — never by
+ * error type: `fetch` rejects network failures as `TypeError`, but `TypeError`
+ * is also thrown for logic bugs, bad URLs, and response-decoding errors that
+ * must NOT be retried (`waitForExecution` has no SDK-side deadline). Runtimes
+ * differ (Bun throws a plain `Error` with a socket message; undici/Node a
+ * `TypeError` with a coded `cause`), hence both signals. Caller-initiated
+ * aborts are excluded so deadlines/cancellation still propagate.
+ */
+function isConnectionError(error) {
+    // HTTP-status errors are already typed and classified elsewhere.
+    if (isOrchestratorError(error)) {
+        return false;
+    }
+    // Caller cancellation / deadline must propagate, not retry.
+    if (error instanceof Error && error.name === 'AbortError') {
+        return false;
+    }
+    // Walk the `cause` chain; `seen` guards against cyclic causes looping forever.
+    const seen = new Set();
+    let current = error;
+    while (current != null && !seen.has(current)) {
+        seen.add(current);
+        const code = current.code;
+        if (typeof code === 'string' && CONNECTION_ERROR_CODES.has(code)) {
+            return true;
+        }
+        const message = current instanceof Error ? current.message.toLowerCase() : '';
+        if (CONNECTION_ERROR_MESSAGES.some((m) => message.includes(m))) {
+            return true;
+        }
+        current = current.cause;
+    }
+    return false;
 }
-export { parseErrorEnvelope, isOrchestratorError, isRetryable, isAuthError, isValidationError, isRateLimited, OrchestratorError, ValidationError, InsufficientLiquidityError, NotFoundError, UnauthorizedError, ForbiddenError, ConflictError, UnprocessableContentError, RateLimitedError, SettlementQuoteError, SettlementExecutionError, ExternalServiceTimeoutError, RelayerMarketUnavailableError, InternalServerError, UnsupportedChainError, UnsupportedTokenError, };
+export { parseErrorEnvelope, isOrchestratorError, isRetryable, isConnectionError, isAuthError, isValidationError, isRateLimited, isSimulationFailed, OrchestratorError, ValidationError, InsufficientLiquidityError, NotFoundError, UnauthorizedError, ForbiddenError, KeyScopeDeniedError, ConflictError, UnprocessableContentError, RateLimitedError, SettlementQuoteError, SettlementExecutionError, SimulationFailedError, ExternalServiceTimeoutError, RelayerMarketUnavailableError, InternalServerError, UnsupportedChainError, UnsupportedTokenError, };

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

@@ -1,11 +1,12 @@
 import type { AuthProvider } from '../auth/provider.js';
 import { Orchestrator } from './client.js';
 import { RHINESTONE_SPOKE_POOL_ADDRESS } from './consts.js';
-import { ConflictError, ExternalServiceTimeoutError, ForbiddenError, InsufficientLiquidityError, InternalServerError, isAuthError, isOrchestratorError, isRateLimited, isRetryable, isValidationError, NotFoundError, OrchestratorError, RateLimitedError, RelayerMarketUnavailableError, SettlementExecutionError, SettlementQuoteError, UnauthorizedError, UnprocessableContentError, UnsupportedChainError, UnsupportedTokenError, ValidationError } from './error.js';
+import { type DestinationChain, hyperCoreMainnet, isNonEvmChain, type NonEvmAddress, type NonEvmChain, solanaMainnet, tronMainnet } from './destinations.js';
+import { ConflictError, ExternalServiceTimeoutError, ForbiddenError, InsufficientLiquidityError, InternalServerError, isAuthError, isConnectionError, isOrchestratorError, isRateLimited, isRetryable, isSimulationFailed, isValidationError, KeyScopeDeniedError, NotFoundError, OrchestratorError, RateLimitedError, RelayerMarketUnavailableError, SettlementExecutionError, SettlementQuoteError, SimulationFailedError, UnauthorizedError, UnprocessableContentError, UnsupportedChainError, UnsupportedTokenError, ValidationError } from './error.js';
 import { getTokenSymbol, getWethAddress, isTokenAddressSupported } from './registry.js';
-import type { ApprovalRequired, AuxiliaryFunds, Cost, CostTokenEntry, EstimatedFillTime, Execution, FeeBreakdown, Fees, IntentInput, IntentOpStatus, IntentOptions, IntentSubmitRequest, IntentSubmitResponse, Portfolio, Price, Quote, QuoteResponse, SettlementLayer, SignatureMode, SignData, SignedAuthorization, SplitIntentsInput, SplitIntentsResult, SponsorSettings, SupportedChain, TokenConfig, TokenRequirements, TypedDataDefinition, UsdAmount, 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';
+import type { AppFee, AppFeeRate, ApprovalRequired, AuxiliaryFunds, BridgeFill, ChainOperation, Cost, CostTokenEntry, EstimatedFillTime, Execution, FailureReason, FeeBreakdown, Fees, IntentInput, IntentOpStatus, IntentOptions, IntentSubmitRequest, IntentSubmitResponse, OperationStatus, OriginSignature, Portfolio, Price, Quote, QuoteResponse, SettlementLayer, SettlementLayerFilter, SignatureMode, SignData, SignedAuthorization, SplitIntentsInput, SplitIntentsResult, SponsorSettings, SupportedChain, TokenConfig, TokenRequirements, TypedDataDefinition, UsdAmount, WrapRequired } from './types.js';
+import { INTENT_STATUS_COMPLETED, INTENT_STATUS_FAILED, INTENT_STATUS_PENDING } from './types.js';
 declare function getOrchestrator(authProvider: AuthProvider, orchestratorUrl?: string, headers?: Record<string, string>): Orchestrator;
-export type { ApprovalRequired, AuxiliaryFunds, Cost, CostTokenEntry, EstimatedFillTime, Execution, FeeBreakdown, Fees, IntentInput, IntentOpStatus, IntentOptions, IntentSubmitRequest, IntentSubmitResponse, Portfolio, Price, Quote, QuoteResponse, SettlementLayer, SignatureMode, SignData, SignedAuthorization, SplitIntentsInput, SplitIntentsResult, SponsorSettings, SupportedChain, TokenConfig, TokenRequirements, TypedDataDefinition, UsdAmount, WrapRequired, };
-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, ConflictError, ExternalServiceTimeoutError, ForbiddenError, InsufficientLiquidityError, InternalServerError, NotFoundError, OrchestratorError, RateLimitedError, RelayerMarketUnavailableError, SettlementExecutionError, SettlementQuoteError, UnauthorizedError, UnprocessableContentError, UnsupportedChainError, UnsupportedTokenError, ValidationError, getOrchestrator, getWethAddress, getTokenSymbol, isOrchestratorError, isRetryable, isAuthError, isValidationError, isRateLimited, isTokenAddressSupported, };
+export type { ApprovalRequired, AppFee, AppFeeRate, AuxiliaryFunds, BridgeFill, ChainOperation, Cost, CostTokenEntry, DestinationChain, NonEvmAddress, NonEvmChain, EstimatedFillTime, Execution, FailureReason, FeeBreakdown, Fees, IntentInput, IntentOpStatus, IntentOptions, IntentSubmitRequest, IntentSubmitResponse, OperationStatus, OriginSignature, Portfolio, Price, Quote, QuoteResponse, SettlementLayer, SettlementLayerFilter, SignatureMode, SignData, SignedAuthorization, SplitIntentsInput, SplitIntentsResult, SponsorSettings, SupportedChain, TokenConfig, TokenRequirements, TypedDataDefinition, UsdAmount, WrapRequired, };
+export { hyperCoreMainnet, isNonEvmChain, solanaMainnet, tronMainnet, INTENT_STATUS_PENDING, INTENT_STATUS_COMPLETED, INTENT_STATUS_FAILED, RHINESTONE_SPOKE_POOL_ADDRESS, Orchestrator, ConflictError, ExternalServiceTimeoutError, ForbiddenError, InsufficientLiquidityError, InternalServerError, KeyScopeDeniedError, NotFoundError, OrchestratorError, RateLimitedError, RelayerMarketUnavailableError, SimulationFailedError, SettlementExecutionError, SettlementQuoteError, UnauthorizedError, UnprocessableContentError, UnsupportedChainError, UnsupportedTokenError, ValidationError, getOrchestrator, getWethAddress, getTokenSymbol, isOrchestratorError, isRetryable, isConnectionError, isAuthError, isValidationError, isRateLimited, isSimulationFailed, 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,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,aAAa,EACb,2BAA2B,EAC3B,cAAc,EACd,0BAA0B,EAC1B,mBAAmB,EACnB,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,6BAA6B,EAC7B,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EACjB,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,EAChB,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,cAAc,EACd,cAAc,EACd,uBAAuB,EACxB,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACd,IAAI,EACJ,cAAc,EACd,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,IAAI,EACJ,WAAW,EACX,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,SAAS,EACT,KAAK,EACL,KAAK,EACL,aAAa,EACb,eAAe,EACf,aAAa,EACb,QAAQ,EACR,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,mBAAmB,EACnB,SAAS,EACT,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,gBAAgB,EAChB,cAAc,EACd,IAAI,EACJ,cAAc,EACd,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,IAAI,EACJ,WAAW,EACX,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,SAAS,EACT,KAAK,EACL,KAAK,EACL,aAAa,EACb,eAAe,EACf,aAAa,EACb,QAAQ,EACR,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,mBAAmB,EACnB,SAAS,EACT,YAAY,GACb,CAAA;AACD,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,EAC1B,qBAAqB,EACrB,6BAA6B,EAC7B,YAAY,EACZ,aAAa,EACb,2BAA2B,EAC3B,cAAc,EACd,0BAA0B,EAC1B,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,6BAA6B,EAC7B,wBAAwB,EACxB,oBAAoB,EACpB,iBAAiB,EACjB,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACrB,eAAe,EACf,eAAe,EACf,cAAc,EACd,cAAc,EACd,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":"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"}

package/dist/src/orchestrator/index.js

@@ -1,9 +1,10 @@
 import { Orchestrator } from './client.js';
 import { PROD_ORCHESTRATOR_URL, RHINESTONE_SPOKE_POOL_ADDRESS } from './consts.js';
-import { ConflictError, ExternalServiceTimeoutError, ForbiddenError, InsufficientLiquidityError, InternalServerError, isAuthError, isOrchestratorError, isRateLimited, isRetryable, isValidationError, NotFoundError, OrchestratorError, RateLimitedError, RelayerMarketUnavailableError, SettlementExecutionError, SettlementQuoteError, UnauthorizedError, UnprocessableContentError, UnsupportedChainError, UnsupportedTokenError, ValidationError, } from './error.js';
+import { hyperCoreMainnet, isNonEvmChain, solanaMainnet, tronMainnet, } from './destinations.js';
+import { ConflictError, ExternalServiceTimeoutError, ForbiddenError, InsufficientLiquidityError, InternalServerError, isAuthError, isConnectionError, isOrchestratorError, isRateLimited, isRetryable, isSimulationFailed, isValidationError, KeyScopeDeniedError, NotFoundError, OrchestratorError, RateLimitedError, RelayerMarketUnavailableError, SettlementExecutionError, SettlementQuoteError, SimulationFailedError, UnauthorizedError, UnprocessableContentError, UnsupportedChainError, UnsupportedTokenError, ValidationError, } from './error.js';
 import { 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';
+import { INTENT_STATUS_COMPLETED, INTENT_STATUS_FAILED, INTENT_STATUS_PENDING, } from './types.js';
 function getOrchestrator(authProvider, orchestratorUrl, 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, ConflictError, ExternalServiceTimeoutError, ForbiddenError, InsufficientLiquidityError, InternalServerError, NotFoundError, OrchestratorError, RateLimitedError, RelayerMarketUnavailableError, SettlementExecutionError, SettlementQuoteError, UnauthorizedError, UnprocessableContentError, UnsupportedChainError, UnsupportedTokenError, ValidationError, getOrchestrator, getWethAddress, getTokenSymbol, isOrchestratorError, isRetryable, isAuthError, isValidationError, isRateLimited, isTokenAddressSupported, };
+export { hyperCoreMainnet, isNonEvmChain, solanaMainnet, tronMainnet, INTENT_STATUS_PENDING, INTENT_STATUS_COMPLETED, INTENT_STATUS_FAILED, RHINESTONE_SPOKE_POOL_ADDRESS, Orchestrator, ConflictError, ExternalServiceTimeoutError, ForbiddenError, InsufficientLiquidityError, InternalServerError, KeyScopeDeniedError, NotFoundError, OrchestratorError, RateLimitedError, RelayerMarketUnavailableError, SimulationFailedError, SettlementExecutionError, SettlementQuoteError, UnauthorizedError, UnprocessableContentError, UnsupportedChainError, UnsupportedTokenError, ValidationError, getOrchestrator, getWethAddress, getTokenSymbol, isOrchestratorError, isRetryable, isConnectionError, isAuthError, isValidationError, isRateLimited, isSimulationFailed, isTokenAddressSupported, };

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

@@ -1,5 +1,6 @@
 import { type Address, type Chain } from 'viem';
 import type { TokenSymbol } from '../types.js';
+import type { NonEvmAddress } from './destinations.js';
 declare function getSupportedChainIds(): number[];
 declare function getWethAddress(chain: Chain): Address;
 declare function getWrappedTokenAddress(chain: Chain): Address;
@@ -11,6 +12,6 @@ declare function isTokenAddressSupported(address: Address, chainId: number): boo
 declare function getDefaultAccountAccessList(onTestnets?: boolean): {
     chainIds: number[];
 };
-declare function resolveTokenAddress(token: TokenSymbol | Address, chainId: number): Address;
+declare function resolveTokenAddress(token: TokenSymbol | Address | NonEvmAddress, chainId: number): Address | NonEvmAddress;
 export { getTokenSymbol, getTokenAddress, getWethAddress, getWrappedTokenAddress, getChainById, getSupportedChainIds, isTestnet, isTokenAddressSupported, getDefaultAccountAccessList, resolveTokenAddress, };
 //# sourceMappingURL=registry.d.ts.map

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

@@ -1 +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;AAG3C,iBAAS,oBAAoB,IAAI,MAAM,EAAE,CAExC;AAMD,iBAAS,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAY7C;AAED,iBAAS,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAarD;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,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,2BAA2B,CAAC,UAAU,CAAC,EAAE,OAAO;;EAaxD;AAED,iBAAS,mBAAmB,CAC1B,KAAK,EAAE,WAAW,GAAG,OAAO,EAC5B,OAAO,EAAE,MAAM,GACd,OAAO,CAKT;AAED,OAAO,EACL,cAAc,EACd,eAAe,EACf,cAAc,EACd,sBAAsB,EACtB,YAAY,EACZ,oBAAoB,EACpB,SAAS,EACT,uBAAuB,EACvB,2BAA2B,EAC3B,mBAAmB,GACpB,CAAA"}
+{"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,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAGnD,iBAAS,oBAAoB,IAAI,MAAM,EAAE,CAExC;AAMD,iBAAS,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAY7C;AAED,iBAAS,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAarD;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,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,2BAA2B,CAAC,UAAU,CAAC,EAAE,OAAO;;EAaxD;AAED,iBAAS,mBAAmB,CAC1B,KAAK,EAAE,WAAW,GAAG,OAAO,GAAG,aAAa,EAC5C,OAAO,EAAE,MAAM,GACd,OAAO,GAAG,aAAa,CAiBzB;AAED,OAAO,EACL,cAAc,EACd,eAAe,EACf,cAAc,EACd,sBAAsB,EACtB,YAAY,EACZ,oBAAoB,EACpB,SAAS,EACT,uBAAuB,EACvB,2BAA2B,EAC3B,mBAAmB,GACpB,CAAA"}

package/dist/src/orchestrator/registry.js

@@ -1,5 +1,6 @@
 import { chainRegistry, chains, } from '@rhinestone/shared-configs';
 import { isAddress } from 'viem';
+import { isNonEvmChainId } from './caip2.js';
 import { UnsupportedChainError, UnsupportedTokenError } from './error.js';
 function getSupportedChainIds() {
     return chains.map((chain) => chain.id);
@@ -85,6 +86,18 @@ function resolveTokenAddress(token, chainId) {
     if (isAddress(token)) {
         return token;
     }
+    // Non-EVM destinations carry SPL mints (base58) / Tron T-prefixed
+    // addresses that don't satisfy viem's `isAddress`. The orchestrator's
+    // wire schema accepts the raw string for non-EVM chains, so pass it
+    // through unchanged. HyperCore is descriptor-addressed too but its tokens
+    // are EVM hex addresses (returned above), so it is intentionally absent
+    // from `isNonEvmChainId` — a token *symbol* for HyperCore is not a valid
+    // request and falls through to the throw below.
+    if (isNonEvmChainId(chainId)) {
+        return token;
+    }
+    // For EVM chains that aren't a hex address, the value must be a known
+    // token symbol. `getTokenAddress` throws if it isn't.
     return getTokenAddress(token, chainId);
 }
 export { getTokenSymbol, getTokenAddress, getWethAddress, getWrappedTokenAddress, getChainById, getSupportedChainIds, isTestnet, isTokenAddressSupported, getDefaultAccountAccessList, resolveTokenAddress, };

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

@@ -1,16 +1,20 @@
 import type { SettlementLayer as CrossChainSettlementLayer, SupportedChain, SupportedMainnet, SupportedOPStackMainnet, SupportedOPStackTestnet, SupportedTestnet } from '@rhinestone/shared-configs';
 import type { Address, Chain, Hex, TypedDataDefinition } from 'viem';
+import type { NonEvmAddress } from './destinations.js';
 type SupportedTokenSymbol = 'ETH' | 'WETH' | 'USDC' | 'USDT' | 'USDT0';
 type SupportedToken = SupportedTokenSymbol | Address;
 type AccountType = 'GENERIC' | 'ERC7579' | 'EOA';
 declare const INTENT_STATUS_PENDING = "PENDING";
 declare const INTENT_STATUS_FAILED = "FAILED";
-declare const INTENT_STATUS_EXPIRED = "EXPIRED";
 declare const INTENT_STATUS_COMPLETED = "COMPLETED";
-declare const INTENT_STATUS_FILLED = "FILLED";
-declare const INTENT_STATUS_PRECONFIRMED = "PRECONFIRMED";
-declare const INTENT_STATUS_CLAIMED = "CLAIMED";
-type IntentStatus = typeof INTENT_STATUS_PENDING | typeof INTENT_STATUS_EXPIRED | typeof INTENT_STATUS_COMPLETED | typeof INTENT_STATUS_FILLED | typeof INTENT_STATUS_PRECONFIRMED | typeof INTENT_STATUS_FAILED | typeof INTENT_STATUS_CLAIMED;
+/**
+ * High-level intent status.
+ *
+ * - `PENDING`   – the intent has been accepted and is being processed
+ * - `COMPLETED` – all operations finished successfully
+ * - `FAILED`    – the intent failed (inspect `operations` for details)
+ */
+type IntentStatus = typeof INTENT_STATUS_PENDING | typeof INTENT_STATUS_COMPLETED | typeof INTENT_STATUS_FAILED;
 type MappedChainTokenAccessList = {
     chainTokens?: {
         [chainId in SupportedChain]?: SupportedToken[];
@@ -24,20 +28,50 @@ type UnmappedChainTokenAccessList = {
     tokens?: SupportedToken[];
 };
 type AccountAccessList = MappedChainTokenAccessList | UnmappedChainTokenAccessList;
-type ClaimStatus = 'PENDING' | 'EXPIRED' | 'CLAIMED';
-interface Claim {
-    depositId: bigint;
-    chainId: number;
-    status: ClaimStatus;
-    claimTimestamp?: number;
-    claimTransactionHash?: Hex;
-}
+/** Per-operation status. */
+type OperationStatus = 'PENDING' | 'COMPLETED' | 'FAILED';
+/**
+ * Why an operation failed. Only meaningful when `status` is `FAILED`.
+ *
+ * - `EXPIRED`          – the operation deadline passed without completion
+ * - `REVERTED`         – the on-chain transaction reverted
+ * - `RELAYER_FAILURE`  – the relayer could not submit the transaction
+ */
+type FailureReason = 'EXPIRED' | 'REVERTED' | 'RELAYER_FAILURE';
+/**
+ * One operation per chain involved in the intent.
+ *
+ * The orchestrator returns `items[]` per chain for future extensibility;
+ * the SDK flattens to one entry per chain for simpler DX.
+ */
+type ChainOperation = {
+    /** Chain ID this operation belongs to. */
+    chain: number;
+    status: 'PENDING';
+} | {
+    chain: number;
+    status: 'COMPLETED';
+    /** Transaction hash of the confirmed on-chain transaction. */
+    txHash: Hex;
+    /** UNIX epoch seconds when the on-chain transaction was confirmed. */
+    timestamp: number;
+} | {
+    chain: number;
+    status: 'FAILED';
+    /** Why the operation failed. */
+    failureReason: FailureReason;
+};
 interface Execution {
     to: Address;
     value: bigint;
     data: Hex;
 }
 type SettlementLayer = 'SAME_CHAIN' | 'INTENT_EXECUTOR' | CrossChainSettlementLayer;
+type SettlementLayerFilter = {
+    include: CrossChainSettlementLayer[];
+} | {
+    exclude: CrossChainSettlementLayer[];
+};
 declare const SIG_MODE_EMISSARY = 0;
 declare const SIG_MODE_ERC1271 = 1;
 declare const SIG_MODE_EMISSARY_ERC1271 = 2;
@@ -51,11 +85,21 @@ type AuxiliaryFunds = {
 };
 interface IntentOptions {
     feeToken?: Address | SupportedTokenSymbol;
+    appFees?: AppFeeRate;
     sponsorSettings?: SponsorSettings;
-    settlementLayers?: SettlementLayer[];
+    settlementLayers?: SettlementLayerFilter;
     signatureMode?: SignatureMode;
     auxiliaryFunds?: AuxiliaryFunds;
 }
+interface AppFeeRate {
+    feeBps: number;
+}
+interface AppFee extends AppFeeRate {
+    baseAmount: bigint;
+    amount: bigint;
+    chainId: number;
+    tokenAddress: Address;
+}
 interface SponsorSettings {
     gas: boolean;
     bridgeFees: boolean;
@@ -77,7 +121,7 @@ interface IntentInput {
     destinationExecutions: Execution[];
     destinationGasUnits?: bigint;
     tokenRequests: {
-        tokenAddress: Address;
+        tokenAddress: Address | NonEvmAddress;
         amount?: bigint;
     }[];
     recipient?: Account;
@@ -102,9 +146,8 @@ interface CostTokenEntry {
 interface FeeBreakdown {
     gas: UsdAmount;
     bridge: UsdAmount;
-    protocol: UsdAmount;
     swap: UsdAmount;
-    settlement: UsdAmount;
+    app: UsdAmount;
 }
 interface Fees {
     total: UsdAmount;
@@ -123,6 +166,27 @@ interface SignData {
     destination: TypedDataDefinition;
     targetExecution?: TypedDataDefinition;
 }
+type BridgeFill = {
+    type: 'OFT';
+    destinationChainId: number;
+} | {
+    type: 'RELAY';
+    destinationChainId: number;
+    requestId: string;
+} | {
+    type: 'NEAR';
+    destinationChainId: number;
+    depositAddress: Address;
+} | {
+    type: 'RHINO';
+    destinationChainId: number;
+    commitmentId: string;
+} | {
+    type: 'CCTP';
+    destinationChainId: number;
+    sourceDomainId: number;
+    destinationDomainId: number;
+};
 interface Quote {
     intentId: string;
     expiresAt: number;
@@ -130,9 +194,12 @@ interface Quote {
     settlementLayer: SettlementLayer;
     signData: SignData;
     cost: Cost;
+    appFee?: AppFee[];
     tokenRequirements?: TokenRequirements;
+    bridgeFill?: BridgeFill;
 }
 interface QuoteResponse {
+    traceId: string;
     routes: Quote[];
 }
 type OriginSignature = Hex | {
@@ -140,7 +207,7 @@ type OriginSignature = Hex | {
     preClaimSig: Hex;
 };
 interface SignedAuthorization {
-    chainId: number;
+    chainId: string;
     address: Address;
     nonce: number;
     yParity: number;
@@ -170,6 +237,7 @@ interface IntentSubmitRequestInternal extends IntentSubmitRequest {
     };
 }
 interface IntentSubmitResponse {
+    traceId: string;
     intentId: string;
 }
 type AccountContext = {
@@ -182,9 +250,18 @@ type AccountContext = {
     accountType: 'EOA';
 };
 interface Account {
-    address: Address;
-    accountType: AccountType;
-    setupOps: Pick<Execution, 'to' | 'data'>[];
+    address: Address | NonEvmAddress;
+    /**
+     * Account type — required for EVM accounts. Omitted for non-EVM
+     * recipients (Solana / Tron) where smart-account semantics don't apply
+     * and the orchestrator schema requires it unset.
+     */
+    accountType?: AccountType;
+    /**
+     * Per-chain account-setup operations — required for EVM accounts.
+     * Omitted for non-EVM recipients for the same reason as `accountType`.
+     */
+    setupOps?: Pick<Execution, 'to' | 'data'>[];
     delegations?: Delegations;
     /** Per-chain SSX mock signatures keyed by decimal chainId string. */
     mockSignatures?: Record<`${number}`, Hex>;
@@ -237,19 +314,28 @@ export type OPNetworkParams = {
 interface SplitIntentsInput {
     chain: Chain;
     tokens: Record<Address, bigint>;
-    settlementLayers?: SettlementLayer[];
+    settlementLayers?: SettlementLayerFilter;
 }
 interface SplitIntentsResult {
+    traceId: string;
     intents: Record<Address, bigint>[];
 }
+/**
+ * Full intent status as returned by the orchestrator (blanc API version).
+ *
+ * One operation per chain involved in the intent. The SDK flattens the
+ * orchestrator's per-chain `items[]` to a single entry per chain.
+ */
 interface IntentOpStatus {
+    /** OpenTelemetry trace ID for correlating this orchestrator response. */
+    traceId: string;
+    /** High-level intent status. */
     status: IntentStatus;
-    claims: Claim[];
-    destinationChainId: number;
+    /** The smart-account address that owns this intent. */
     accountAddress: Address;
-    fillTimestamp?: number;
-    fillTransactionHash?: Hex;
+    /** Per-chain operation status. One entry per chain. */
+    operations: ChainOperation[];
 }
-export type { Account, AccountType, AccountWithContext, AuxiliaryFunds, TokenConfig, SupportedChain, SettlementLayer, SignatureMode, IntentInput, Quote, QuoteResponse, Cost, CostTokenEntry, FeeBreakdown, Fees, Price, UsdAmount, EstimatedFillTime, SignData, IntentSubmitRequest, IntentSubmitRequestInternal, IntentSubmitResponse, IntentOpStatus, IntentOptions, SponsorSettings, SignedAuthorization, SplitIntentsInput, SplitIntentsResult, Portfolio, PortfolioToken, Execution, AccountAccessList, MappedChainTokenAccessList, UnmappedChainTokenAccessList, OriginSignature, TokenRequirements, WrapRequired, ApprovalRequired, TypedDataDefinition, };
-export { INTENT_STATUS_PENDING, INTENT_STATUS_FAILED, INTENT_STATUS_EXPIRED, INTENT_STATUS_CLAIMED, INTENT_STATUS_COMPLETED, INTENT_STATUS_FILLED, INTENT_STATUS_PRECONFIRMED, SIG_MODE_EMISSARY, SIG_MODE_ERC1271, SIG_MODE_EMISSARY_ERC1271, SIG_MODE_ERC1271_EMISSARY, SIG_MODE_EMISSARY_EXECUTION, SIG_MODE_EMISSARY_EXECUTION_ERC1271, SIG_MODE_ERC1271_EMISSARY_EXECUTION, };
+export type { Account, AccountType, AccountWithContext, AppFee, AppFeeRate, AuxiliaryFunds, TokenConfig, SupportedChain, SettlementLayer, SettlementLayerFilter, SignatureMode, IntentInput, BridgeFill, Quote, QuoteResponse, Cost, CostTokenEntry, FeeBreakdown, Fees, Price, UsdAmount, EstimatedFillTime, SignData, IntentSubmitRequest, IntentSubmitRequestInternal, IntentSubmitResponse, IntentOpStatus, IntentOptions, SponsorSettings, SignedAuthorization, SplitIntentsInput, SplitIntentsResult, Portfolio, PortfolioToken, Execution, AccountAccessList, MappedChainTokenAccessList, UnmappedChainTokenAccessList, OriginSignature, TokenRequirements, WrapRequired, ApprovalRequired, TypedDataDefinition, OperationStatus, FailureReason, ChainOperation, };
+export { INTENT_STATUS_PENDING, INTENT_STATUS_FAILED, INTENT_STATUS_COMPLETED, SIG_MODE_EMISSARY, SIG_MODE_ERC1271, SIG_MODE_EMISSARY_ERC1271, SIG_MODE_ERC1271_EMISSARY, SIG_MODE_EMISSARY_EXECUTION, SIG_MODE_EMISSARY_EXECUTION_ERC1271, SIG_MODE_ERC1271_EMISSARY_EXECUTION, };
 //# sourceMappingURL=types.d.ts.map