@rhinestone/sdk 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/src/orchestrator/client.js

@@ -1,12 +1,7 @@
+import { fromCaip2, toCaip2 } from './caip2.js';
 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 { OrchestratorError, parseErrorEnvelope, } from './error.js';
 import { convertBigIntFields } from './utils.js';
-function parseTokenAmountsRecord(record) {
-    return Object.fromEntries(Object.entries(record).map(([addr, amount]) => [
-        addr,
-        BigInt(amount),
-    ]));
-}
 export class Orchestrator {
     serverUrl;
     authProvider;
@@ -16,112 +11,90 @@ export class Orchestrator {
         this.authProvider = authProvider;
         this.extraHeaders = headers;
     }
-    async getPortfolio(userAddress, filter) {
+    async getPortfolio(accountAddress, filter) {
         const params = new URLSearchParams();
         if (filter?.chainIds) {
-            params.set('chainIds', filter.chainIds.join(','));
+            for (const id of filter.chainIds) {
+                params.append('chainIds', toCaip2(id));
+            }
         }
         if (filter?.tokens) {
-            params.set('tokens', Object.entries(filter.tokens)
-                .flatMap(([chainId, tokens]) => tokens.map((token) => `${chainId}:${token}`))
-                .join(','));
+            for (const [chainId, tokens] of Object.entries(filter.tokens)) {
+                for (const token of tokens) {
+                    params.append('tokens', `${toCaip2(Number(chainId))}:${token}`);
+                }
+            }
         }
-        const url = new URL(`${this.serverUrl}/accounts/${userAddress}/portfolio`);
+        const url = new URL(`${this.serverUrl}/accounts/${accountAddress}/portfolio`);
         url.search = params.toString();
         const json = await this.fetch(url.toString(), {
             headers: await this.getHeaders(),
         });
-        const portfolioResponse = json.portfolio;
-        const portfolio = portfolioResponse.map((tokenResponse) => ({
-            symbol: tokenResponse.tokenName,
-            decimals: tokenResponse.tokenDecimals,
-            balances: {
-                locked: BigInt(tokenResponse.balance.locked),
-                unlocked: BigInt(tokenResponse.balance.unlocked),
-            },
-            chains: tokenResponse.tokenChainBalance.map((chainBalance) => ({
-                chain: chainBalance.chainId,
-                address: chainBalance.tokenAddress,
-                locked: BigInt(chainBalance.balance.locked),
-                unlocked: BigInt(chainBalance.balance.unlocked),
+        const portfolioWire = json.portfolio;
+        return portfolioWire.map((token) => ({
+            symbol: token.symbol,
+            chains: token.chains.map((c) => ({
+                chain: parseChainId(c.chainId),
+                address: c.address,
+                decimals: c.decimals,
+                locked: BigInt(c.balance.locked),
+                unlocked: BigInt(c.balance.unlocked),
             })),
         }));
-        return portfolio;
     }
-    async getIntentRoute(input) {
-        const body = convertBigIntFields(input);
-        return await this.fetch(`${this.serverUrl}/intents/route`, {
+    async createQuote(input) {
+        const body = encodeIntentInput(input);
+        const json = await this.fetch(`${this.serverUrl}/quotes`, {
             method: 'POST',
             headers: await this.getHeaders(),
             body: JSON.stringify(body),
         });
+        return decodeQuoteResponse(json);
     }
-    async splitIntents(input) {
-        const response = await fetch(`${this.serverUrl}/intents/split`, {
+    async getSplit(input) {
+        const body = convertBigIntFields({
+            chainId: toCaip2(input.chain.id),
+            tokens: input.tokens,
+            settlementLayers: input.settlementLayers,
+        });
+        const json = await this.fetch(`${this.serverUrl}/intents/splits`, {
             method: 'POST',
             headers: await this.getHeaders(),
-            body: JSON.stringify(convertBigIntFields({
-                chainId: input.chain.id,
-                tokens: input.tokens,
-                settlementLayers: input.settlementLayers,
-            })),
-        });
-        if (response.ok) {
-            const json = await response.json();
-            return {
-                intents: json.intents.map(parseTokenAmountsRecord),
-            };
-        }
-        let errorData = {};
-        try {
-            errorData = await response.json();
-        }
-        catch {
-            try {
-                const text = await response.text();
-                errorData = { message: text };
-            }
-            catch { }
-        }
-        if (response.status === 422 &&
-            errorData.error === 'INSUFFICIENT_LIQUIDITY') {
-            throw new InsufficientLiquidityError({
-                availableIntents: errorData.availableIntents.map(parseTokenAmountsRecord),
-                unfillable: parseTokenAmountsRecord(errorData.unfillable),
-                traceId: errorData.traceId,
-                statusCode: 422,
-            });
-        }
-        this.parseError({
-            response: {
-                status: response.status,
-                data: errorData,
-                headers: {},
-            },
+            body: JSON.stringify(body),
         });
-        throw new OrchestratorError({ message: 'Unexpected error' });
+        return {
+            intents: json.intents.map(parseTokenAmountsRecord),
+        };
     }
-    async submitIntent(signedIntentOpUnformatted, dryRun, policyContext) {
-        const signedIntentOp = convertBigIntFields(signedIntentOpUnformatted);
-        if (dryRun) {
-            signedIntentOp.options = {
-                dryRun: true,
-            };
-        }
-        const body = { signedIntentOp };
+    async createIntent(request, policyContext) {
+        const body = convertBigIntFields(request);
         const headers = policyContext
             ? await this.getSubmitHeaders(policyContext.intentInput, policyContext.isSponsored)
             : await this.getHeaders();
-        return await this.fetch(`${this.serverUrl}/intent-operations`, {
+        return await this.fetch(`${this.serverUrl}/intents`, {
             method: 'POST',
             headers,
             body: JSON.stringify(body),
         });
     }
-    async getIntentOpStatus(intentId) {
-        return await this.fetch(`${this.serverUrl}/intent-operation/${intentId.toString()}`, {
+    async getIntent(intentId) {
+        const json = await this.fetch(`${this.serverUrl}/intents/${intentId}`, {
             headers: await this.getHeaders(),
         });
+        return {
+            status: json.status,
+            claims: (json.claims ?? []).map((claim) => ({
+                depositId: claim.depositId !== undefined ? BigInt(claim.depositId) : 0n,
+                chainId: parseChainId(claim.chainId),
+                status: claim.status,
+                claimTimestamp: claim.claimTimestamp,
+                claimTransactionHash: claim.claimTransactionHash,
+            })),
+            destinationChainId: parseChainId(json.destinationChainId),
+            accountAddress: json.accountAddress,
+            fillTimestamp: json.fillTimestamp,
+            fillTransactionHash: json.fillTransactionHash,
+        };
     }
     async getHeaders() {
         const auth = await this.authProvider.getHeaders();
@@ -138,6 +111,7 @@ export class Orchestrator {
         return {
             'Content-Type': 'application/json',
             'x-sdk-version': SDK_VERSION,
+            'x-api-version': API_VERSION,
             ...auth,
             ...this.extraHeaders,
         };
@@ -145,228 +119,152 @@ export class Orchestrator {
     async fetch(url, options) {
         const response = await fetch(url, options);
         if (!response.ok) {
-            let errorData = {};
+            let body;
             try {
-                errorData = await response.json();
+                body = await response.json();
             }
             catch {
-                try {
-                    const text = await response.text();
-                    errorData = { message: text };
-                }
-                catch { }
+                body = {
+                    code: 'INTERNAL_ERROR',
+                    message: `Request failed with status ${response.status}`,
+                    traceId: '',
+                };
             }
-            const retryAfterHeader = response.headers?.get?.('retry-after') || undefined;
-            this.parseError({
-                response: {
-                    status: response.status,
-                    data: errorData,
-                    headers: {
-                        retryAfter: retryAfterHeader,
-                    },
-                },
-            });
+            const retryAfter = response.headers?.get?.('retry-after') ?? undefined;
+            throw parseErrorEnvelope(body, response.status, retryAfter ?? undefined);
         }
         return response.json();
     }
-    parseError(error) {
-        if (error.response) {
-            const status = error.response.status;
-            const { headers } = error.response;
-            const { errors = [], traceId, message } = error.response.data || {};
-            let errorType = 'Unknown';
-            switch (status) {
-                case 400:
-                    errorType = 'Bad Request';
-                    break;
-                case 401:
-                    errorType = 'Unauthorized';
-                    break;
-                case 403:
-                    errorType = 'Forbidden';
-                    break;
-                case 404:
-                    errorType = 'Not Found';
-                    break;
-                case 409:
-                    errorType = 'Conflict';
-                    break;
-                case 422:
-                    errorType = 'Unprocessable Entity';
-                    break;
-                case 429:
-                    errorType = 'Too Many Requests';
-                    break;
-                case 500:
-                    errorType = 'Internal Server Error';
-                    break;
-                case 503:
-                    errorType = 'Service Unavailable';
-                    break;
-                default:
-                    errorType = 'Unknown';
-            }
-            const baseParams = {
-                context: { traceId },
-                errorType,
-                traceId,
-                statusCode: status,
-            };
-            if (status === 429) {
-                const retryAfter = headers?.retryAfter;
-                const context = { traceId, retryAfter };
-                throw new RateLimitedError({
-                    ...baseParams,
-                    context,
-                });
-            }
-            if (status === 503) {
-                throw new ServiceUnavailableError(baseParams);
-            }
-            if (message) {
-                this.parseErrorMessage(message, baseParams);
-            }
-            for (const err of errors) {
-                const mergedParams = {
-                    ...baseParams,
-                    context: { ...err.context, traceId },
-                };
-                this.parseErrorMessage(err.message, mergedParams);
-            }
-            switch (status) {
-                case 400:
-                    throw new BadRequestError({
-                        ...baseParams,
-                        context: { traceId, errors },
-                        message: message,
-                    });
-                case 401:
-                    if (message === 'Authentication is required') {
-                        throw new AuthenticationRequiredError(baseParams);
-                    }
-                    throw new UnauthorizedError(baseParams);
-                case 403:
-                    throw new ForbiddenError(baseParams);
-                case 404:
-                    throw new ResourceNotFoundError(baseParams);
-                case 409:
-                    throw new ConflictError(baseParams);
-                case 500:
-                    if (errors && errors.length > 0) {
-                        const mergedParams = {
-                            ...baseParams,
-                            context: { ...errors[0].context, traceId },
-                        };
-                        throw new OrchestratorError({
-                            ...mergedParams,
-                            message: errors[0].message || 'Internal Server Error',
-                        });
-                    }
-                    throw new InternalServerError(baseParams);
-                default:
-                    throw new OrchestratorError({
-                        ...baseParams,
-                        message: message || errorType,
-                    });
-            }
-        }
+}
+function parseTokenAmountsRecord(record) {
+    return Object.fromEntries(Object.entries(record).map(([addr, amount]) => [
+        addr,
+        BigInt(amount),
+    ]));
+}
+function parseChainId(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string') {
+        if (value.startsWith('eip155:'))
+            return fromCaip2(value);
+        return Number(value);
     }
-    parseErrorMessage(message, errorParams) {
-        if (message === 'Insufficient balance') {
-            throw new InsufficientBalanceError(errorParams);
-        }
-        else if (message === 'Unsupported chain id' ||
-            message === 'Unsupported chain ids') {
-            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 UnsupportedChainError(chainId, errorParams);
-            }
-            throw new UnsupportedChainIdError(errorParams);
-        }
-        else if (message.includes('Unsupported token') &&
-            message.includes('for chain')) {
-            const tokenMatch = message.match(/Unsupported token (\w+) for chain (\d+)/);
-            if (tokenMatch) {
-                const tokenSymbol = tokenMatch[1];
-                const chainId = parseInt(tokenMatch[2], 10);
-                throw new UnsupportedTokenError(tokenSymbol, chainId, errorParams);
-            }
-            throw new OrchestratorError({ message, ...errorParams });
-        }
-        else if (message === 'Unsupported token addresses') {
-            // generic unsupported tokens without specific symbol/chain context
-            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 TokenNotSupportedError(tokenAddress, chainId, errorParams);
+    throw new OrchestratorError({
+        message: `Invalid chain id value: ${String(value)}`,
+    });
+}
+function encodeIntentInput(input) {
+    const { account, destinationChainId, destinationExecutions, destinationGasUnits, tokenRequests, recipient, accountAccessList, options, preClaimExecutions, } = input;
+    const wire = {
+        account,
+        destinationChainId: toCaip2(destinationChainId),
+        destinationExecutions,
+        tokenRequests,
+        recipient,
+        accountAccessList: encodeAccountAccessList(accountAccessList),
+        options: encodeOptions(options),
+    };
+    if (destinationGasUnits !== undefined) {
+        wire.destinationGasLimit = destinationGasUnits;
+    }
+    if (preClaimExecutions) {
+        wire.preClaimExecutions = Object.fromEntries(Object.entries(preClaimExecutions).map(([chainId, ops]) => [
+            toCaip2(Number(chainId)),
+            ops,
+        ]));
+    }
+    return convertBigIntFields(wire);
+}
+function encodeAccountAccessList(list) {
+    if (!list)
+        return undefined;
+    const out = {};
+    if ('chainIds' in list && list.chainIds) {
+        out.chainIds = list.chainIds.map(toCaip2);
+    }
+    if ('tokens' in list && list.tokens) {
+        out.tokens = list.tokens;
+    }
+    if ('chainTokens' in list && list.chainTokens) {
+        out.chainTokens = Object.fromEntries(Object.entries(list.chainTokens).map(([chainId, tokens]) => [
+            toCaip2(Number(chainId)),
+            tokens,
+        ]));
+    }
+    if ('chainTokenAmounts' in list && list.chainTokenAmounts) {
+        out.chainTokenAmounts = Object.fromEntries(Object.entries(list.chainTokenAmounts).map(([chainId, tokens]) => [
+            toCaip2(Number(chainId)),
+            tokens,
+        ]));
+    }
+    return out;
+}
+function encodeAuxiliaryFunds(funds) {
+    return Object.fromEntries(Object.entries(funds).map(([chainId, balances]) => [
+        toCaip2(Number(chainId)),
+        balances,
+    ]));
+}
+function encodeOptions(options) {
+    if (!options.auxiliaryFunds)
+        return options;
+    return {
+        ...options,
+        auxiliaryFunds: encodeAuxiliaryFunds(options.auxiliaryFunds),
+    };
+}
+function decodeQuoteResponse(json) {
+    const routes = (json.routes ?? []);
+    return { routes: routes.map(decodeQuote) };
+}
+function decodeQuote(route) {
+    return {
+        intentId: route.intentId,
+        expiresAt: route.expiresAt,
+        estimatedFillTime: route.estimatedFillTime,
+        settlementLayer: route.settlementLayer,
+        signData: route.signData,
+        cost: decodeCost(route.cost),
+        tokenRequirements: route.tokenRequirements
+            ? decodeTokenRequirements(route.tokenRequirements)
+            : undefined,
+    };
+}
+function decodeCost(cost) {
+    return {
+        input: cost.input.map(decodeCostTokenEntry),
+        output: cost.output.map(decodeCostTokenEntry),
+        feeToken: cost.feeToken
+            ? {
+                chainId: parseChainId(cost.feeToken.chainId),
+                tokenAddress: cost.feeToken.tokenAddress,
             }
-            throw new OrchestratorError({ message, ...errorParams });
-        }
-        else if (message === 'Authentication is required') {
-            throw new AuthenticationRequiredError(errorParams);
-        }
-        else if (message === 'Invalid API key') {
-            throw new InvalidApiKeyError(errorParams);
-        }
-        else if (message === 'Insufficient permissions') {
-            throw new ForbiddenError(errorParams);
-        }
-        else if (message === 'Invalid bundle signature') {
-            throw new InvalidIntentSignatureError(errorParams);
-        }
-        else if (message === 'Invalid checksum signature') {
-            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 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 NoPathFoundError(errorParams);
-        }
-        else if (message === 'Emissary is not enabled' ||
-            message === 'Emissary is not the expected address') {
-            throw new ForbiddenError(errorParams);
-        }
-        else if (message.includes('No such intent with nonce') ||
-            message === 'Order bundle not found') {
-            throw new IntentNotFoundError(errorParams);
-        }
-        else if (message === 'Could not retrieve a valid quote from any aggregator') {
-            throw new NoPathFoundError(errorParams);
-        }
-        else if (message === 'No aggregators available for swap') {
-            throw new InternalServerError(errorParams);
-        }
-        else if (message === 'entity.parse.failed' ||
-            message === 'entity.too.large' ||
-            message === 'encoding.unsupported') {
-            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 SimulationFailedError({
-                message,
-                context,
-                errorType,
-                traceId,
-                statusCode,
-                simulations,
-            });
-        }
-        else {
-            throw new OrchestratorError({ message, ...errorParams });
+            : undefined,
+        fees: cost.fees,
+    };
+}
+function decodeCostTokenEntry(entry) {
+    return {
+        chainId: parseChainId(entry.chainId),
+        tokenAddress: entry.tokenAddress,
+        symbol: entry.symbol,
+        decimals: entry.decimals,
+        price: entry.price,
+        amount: BigInt(entry.amount),
+    };
+}
+function decodeTokenRequirements(wire) {
+    const out = {};
+    for (const [chainKey, tokens] of Object.entries(wire)) {
+        const chainId = parseChainId(chainKey);
+        out[chainId] = {};
+        for (const [tokenAddress, requirement] of Object.entries(tokens)) {
+            out[chainId][tokenAddress] = {
+                ...requirement,
+                amount: BigInt(requirement.amount),
+            };
         }
     }
+    return out;
 }

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 = "2.0.0-beta.0";
-declare const API_VERSION = "2026-01.alps";
+declare const SDK_VERSION = "2.0.0-beta.2";
+declare const API_VERSION = "2026-04.blanc";
 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,iBAAiB,CAAA;AAClC,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,kBAAkB,CAAA;AAEnC,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,WAAW,EACX,WAAW,GACZ,CAAA"}

package/dist/src/orchestrator/consts.js

@@ -1,5 +1,5 @@
 const PROD_ORCHESTRATOR_URL = 'https://v1.orchestrator.rhinestone.dev';
 const RHINESTONE_SPOKE_POOL_ADDRESS = '0x000000000060f6e853447881951574cdd0663530';
-const SDK_VERSION = '2.0.0-beta.0';
-const API_VERSION = '2026-01.alps';
+const SDK_VERSION = '2.0.0-beta.2';
+const API_VERSION = '2026-04.blanc';
 export { PROD_ORCHESTRATOR_URL, RHINESTONE_SPOKE_POOL_ADDRESS, SDK_VERSION, API_VERSION, };