@charterlabs/rhinestone-sdk 0.2.7-dev.4 → 0.2.8

package/dist/src/modules/validators/smart-sessions.js

@@ -9,13 +9,10 @@ exports.getPermissionId = getPermissionId;
 exports.isSessionEnabled = isSessionEnabled;
 const solady_1 = require("solady");
 const viem_1 = require("viem");
-const utils_1 = require("../../accounts/utils");
-const orchestrator_1 = require("../../orchestrator");
 const smart_sessions_1 = require("../abi/smart-sessions");
 const common_1 = require("../common");
-const omni_account_1 = require("../omni-account");
 const core_1 = require("./core");
-const SMART_SESSIONS_VALIDATOR_ADDRESS = '0x00000000002b0ecfbd0496ee71e01257da0e37de';
+const SMART_SESSIONS_VALIDATOR_ADDRESS = '0x00000000008bdaba73cd9815d79069c247eb4bda';
 exports.SMART_SESSIONS_VALIDATOR_ADDRESS = SMART_SESSIONS_VALIDATOR_ADDRESS;
 const SMART_SESSION_MODE_USE = '0x00';
 exports.SMART_SESSION_MODE_USE = SMART_SESSION_MODE_USE;
@@ -37,25 +34,11 @@ const ACTION_CONDITION_GREATER_THAN_OR_EQUAL = 3;
 const ACTION_CONDITION_LESS_THAN_OR_EQUAL = 4;
 const ACTION_CONDITION_NOT_EQUAL = 5;
 const ACTION_CONDITION_IN_RANGE = 6;
-async function getSessionData(chain, session, provider) {
-    const { appDomainSeparator, contentsType } = await getSessionAllowedERC7739Content(chain, provider);
-    const allowedERC7739Content = [
-        {
-            appDomainSeparator,
-            contentName: [contentsType],
-        },
-    ];
-    return getSmartSessionData(chain, session, allowedERC7739Content);
+async function getSessionData(session) {
+    return getSmartSessionData(session);
 }
-async function getEnableSessionCall(chain, session, provider) {
-    const { appDomainSeparator, contentsType } = await getSessionAllowedERC7739Content(chain, provider);
-    const allowedERC7739Content = [
-        {
-            appDomainSeparator,
-            contentName: [contentsType],
-        },
-    ];
-    const sessionData = getSmartSessionData(chain, session, allowedERC7739Content);
+async function getEnableSessionCall(session) {
+    const sessionData = getSmartSessionData(session);
     return {
         to: SMART_SESSIONS_VALIDATOR_ADDRESS,
         data: (0, viem_1.encodeFunctionData)({
@@ -65,50 +48,7 @@ async function getEnableSessionCall(chain, session, provider) {
         }),
     };
 }
-function getOmniAccountActions(chain) {
-    const wethAddress = (0, orchestrator_1.getWethAddress)(chain);
-    const omniActions = [
-        {
-            actionTarget: orchestrator_1.RHINESTONE_SPOKE_POOL_ADDRESS,
-            actionTargetSelector: '0xa2418864', // injected execution
-            actionPolicies: [getPolicyData({ type: 'sudo' })],
-        },
-        {
-            actionTarget: omni_account_1.HOOK_ADDRESS,
-            actionTargetSelector: '0x27c777a9', // injected execution
-            actionPolicies: [getPolicyData({ type: 'sudo' })],
-        },
-        {
-            actionTarget: wethAddress,
-            actionTargetSelector: '0xd0e30db0', // deposit
-            actionPolicies: [getPolicyData({ type: 'sudo' })],
-        },
-        {
-            actionTarget: wethAddress,
-            actionTargetSelector: '0x2e1a7d4d', // widthdraw
-            actionPolicies: [getPolicyData({ type: 'sudo' })],
-        },
-    ];
-    return omniActions;
-}
-async function getSessionAllowedERC7739Content(chain, provider) {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain,
-        transport: (0, utils_1.createTransport)(chain, provider),
-    });
-    const appDomainSeparator = await publicClient.readContract({
-        address: omni_account_1.HOOK_ADDRESS,
-        abi: (0, viem_1.parseAbi)(['function DOMAIN_SEPARATOR() view returns (bytes32)']),
-        functionName: 'DOMAIN_SEPARATOR',
-    });
-    const contentsType = 'MultichainCompact(address sponsor,uint256 nonce,uint256 expires,Segment[] segments)Segment(address arbiter,uint256 chainId,uint256[2][] idsAndAmounts,Witness witness)Witness(address recipient,uint256[2][] tokenOut,uint256 depositId,uint256 targetChain,uint32 fillDeadline,XchainExec[] execs,bytes32 userOpHash,uint32 maxFeeBps)XchainExec(address to,uint256 value,bytes data)';
-    return {
-        appDomainSeparator,
-        contentsType,
-    };
-}
-function getSmartSessionData(chain, session, allowedERC7739Content) {
-    const omniActions = getOmniAccountActions(chain);
+function getSmartSessionData(session) {
     const sessionValidator = (0, core_1.getValidator)(session.owners);
     const userOpPolicies = (session.policies || [
         {
@@ -128,8 +68,7 @@ function getSmartSessionData(chain, session, allowedERC7739Content) {
                 target: SMART_SESSIONS_FALLBACK_TARGET_FLAG,
                 selector: SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
             },
-        ])
-            .map((action) => {
+        ]).map((action) => {
             const actionPolicies = (action.policies || [
                 {
                     type: 'sudo',
@@ -142,11 +81,10 @@ function getSmartSessionData(chain, session, allowedERC7739Content) {
                 actionTarget: action.target,
                 actionPolicies,
             };
-        })
-            .concat(omniActions),
+        }),
         erc7739Policies: {
-            allowedERC7739Content,
-            erc1271Policies: [getPolicyData({ type: 'sudo' })],
+            allowedERC7739Content: [],
+            erc1271Policies: [],
         },
         permitERC4337Paymaster: true,
     };

package/dist/src/modules/validators/smart-sessions.test.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const viem_1 = require("viem");
-const chains_1 = require("viem/chains");
 const vitest_1 = require("vitest");
 const consts_1 = require("../../../test/consts");
 const smart_sessions_1 = require("../abi/smart-sessions");
@@ -92,7 +91,7 @@ const smart_sessions_2 = require("./smart-sessions");
         const FALLBACK_TARGET = '0x0000000000000000000000000000000000000001';
         const FALLBACK_SELECTOR = '0x00000001';
         (0, vitest_1.test)('default', async () => {
-            const call = await (0, smart_sessions_2.getEnableSessionCall)(chains_1.mainnet, {
+            const call = await (0, smart_sessions_2.getEnableSessionCall)({
                 owners: {
                     type: 'ecdsa',
                     accounts: [consts_1.accountA],
@@ -104,7 +103,7 @@ const smart_sessions_2 = require("./smart-sessions");
                 action.actionTargetSelector === FALLBACK_SELECTOR)).toEqual(true);
         });
         (0, vitest_1.test)('with action', async () => {
-            const call = await (0, smart_sessions_2.getEnableSessionCall)(chains_1.mainnet, {
+            const call = await (0, smart_sessions_2.getEnableSessionCall)({
                 owners: {
                     type: 'ecdsa',
                     accounts: [consts_1.accountA],
@@ -125,7 +124,7 @@ const smart_sessions_2 = require("./smart-sessions");
                 action.actionTargetSelector === FALLBACK_SELECTOR)).toEqual(false);
         });
         (0, vitest_1.test)('with policy', async () => {
-            const call = await (0, smart_sessions_2.getEnableSessionCall)(chains_1.mainnet, {
+            const call = await (0, smart_sessions_2.getEnableSessionCall)({
                 owners: {
                     type: 'ecdsa',
                     accounts: [consts_1.accountA],
@@ -155,7 +154,7 @@ const smart_sessions_2 = require("./smart-sessions");
             (0, vitest_1.expect)((0, viem_1.isHex)(sessionData.userOpPolicies[1].initData)).toEqual(true);
         });
         (0, vitest_1.test)('with action policy', async () => {
-            const call = await (0, smart_sessions_2.getEnableSessionCall)(chains_1.mainnet, {
+            const call = await (0, smart_sessions_2.getEnableSessionCall)({
                 owners: {
                     type: 'ecdsa',
                     accounts: [consts_1.accountA],

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

@@ -13,9 +13,10 @@ export declare class Orchestrator {
     getMaxTokenAmount(userAddress: Address, destinationChainId: number, destinationTokenAddress: Address, destinationGasUnits: bigint, sponsored: boolean): Promise<bigint>;
     getIntentCost(input: IntentInput): Promise<IntentCost>;
     getIntentRoute(input: IntentInput): Promise<IntentRoute>;
-    submitIntent(signedIntentOp: SignedIntentOp): Promise<IntentResult>;
-    simulateIntent(signedIntentOp: SignedIntentOp): Promise<IntentResult>;
+    submitIntent(signedIntentOpUnformatted: SignedIntentOp, dryRun: boolean): Promise<IntentResult>;
     getIntentOpStatus(intentId: bigint): Promise<IntentOpStatus>;
+    private getHeaders;
+    private fetch;
     private parseError;
     private parseErrorMessage;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../orchestrator/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAuB,MAAM,MAAM,CAAA;AAexD,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,cAAc,EACd,YAAY,EACZ,WAAW,EACX,SAAS,EAET,cAAc,EACf,MAAM,SAAS,CAAA;AAGhB,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAAC,CAAQ;gBAEX,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAKxC,YAAY,CAChB,WAAW,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;QACnB,MAAM,CAAC,EAAE;YACP,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;SAC7B,CAAA;KACF,GACA,OAAO,CAAC,SAAS,CAAC;IAmDf,iBAAiB,CACrB,WAAW,EAAE,OAAO,EACpB,kBAAkB,EAAE,MAAM,EAC1B,uBAAuB,EAAE,OAAO,EAChC,mBAAmB,EAAE,MAAM,EAC3B,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,MAAM,CAAC;IAqDZ,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAqBtD,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAqBxD,YAAY,CAAC,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;IAqBnE,cAAc,CAAC,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;IAqBrE,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAkBlE,OAAO,CAAC,UAAU;IA0ElB,OAAO,CAAC,iBAAiB;CAmD1B"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../orchestrator/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAe,MAAM,MAAM,CAAA;AAwBhD,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,cAAc,EACd,YAAY,EACZ,WAAW,EACX,SAAS,EAET,cAAc,EACf,MAAM,SAAS,CAAA;AAGhB,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,MAAM,CAAC,CAAQ;gBAEX,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAKxC,YAAY,CAChB,WAAW,EAAE,OAAO,EACpB,MAAM,CAAC,EAAE;QACP,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;QACnB,MAAM,CAAC,EAAE;YACP,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE,CAAA;SAC7B,CAAA;KACF,GACA,OAAO,CAAC,SAAS,CAAC;IA+Cf,iBAAiB,CACrB,WAAW,EAAE,OAAO,EACpB,kBAAkB,EAAE,MAAM,EAC1B,uBAAuB,EAAE,OAAO,EAChC,mBAAmB,EAAE,MAAM,EAC3B,SAAS,EAAE,OAAO,GACjB,OAAO,CAAC,MAAM,CAAC;IAqDZ,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IAQtD,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAQxD,YAAY,CAChB,yBAAyB,EAAE,cAAc,EACzC,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,YAAY,CAAC;IAgBlB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IASlE,OAAO,CAAC,UAAU;YAUJ,KAAK;IA4BnB,OAAO,CAAC,UAAU;IA6GlB,OAAO,CAAC,iBAAiB;CAwF1B"}

package/dist/src/orchestrator/client.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Orchestrator = void 0;
-const axios_1 = __importDefault(require("axios"));
 const viem_1 = require("viem");
 const error_1 = require("./error");
 const utils_1 = require("./utils");
@@ -16,41 +12,36 @@ class Orchestrator {
         this.apiKey = apiKey;
     }
     async getPortfolio(userAddress, filter) {
-        try {
-            const response = await axios_1.default.get(`${this.serverUrl}/accounts/${userAddress}/portfolio`, {
-                params: {
-                    chainIds: filter?.chainIds?.join(','),
-                    tokens: filter?.tokens
-                        ? Object.entries(filter.tokens)
-                            .map(([chainId, tokens]) => tokens.map((token) => `${chainId}:${token}`))
-                            .reduce(viem_1.concat, [])
-                        : undefined,
-                },
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            const portfolioResponse = response.data.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),
-                })),
-            }));
-            return portfolio;
+        const params = new URLSearchParams();
+        if (filter?.chainIds) {
+            params.set('chainIds', filter.chainIds.join(','));
         }
-        catch (error) {
-            this.parseError(error);
-            throw new error_1.OrchestratorError({ message: 'Failed to get portfolio' });
+        if (filter?.tokens) {
+            params.set('tokens', Object.entries(filter.tokens)
+                .flatMap(([chainId, tokens]) => tokens.map((token) => `${chainId}:${token}`))
+                .join(','));
         }
+        const url = new URL(`${this.serverUrl}/accounts/${userAddress}/portfolio`);
+        url.search = params.toString();
+        const json = await this.fetch(url.toString(), {
+            headers: 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),
+            })),
+        }));
+        return portfolio;
     }
     async getMaxTokenAmount(userAddress, destinationChainId, destinationTokenAddress, destinationGasUnits, sponsored) {
         const intentCost = await this.getIntentCost({
@@ -90,159 +81,184 @@ class Orchestrator {
             return 0n;
         }
         const tokenAmount = tokenReceived.destinationAmount;
-        if (tokenAmount < 0n) {
+        if (BigInt(tokenAmount) < 0n) {
             throw new Error(`Balance not available. Make sure the account is deployed`);
         }
         // `sponsorSettings` is not taken into account in the API response for now
         // As a workaround, we use the `amountSpent` if the transaction is sponsored
         return sponsored
-            ? tokenReceived.amountSpent
-            : tokenReceived.destinationAmount;
+            ? BigInt(tokenReceived.amountSpent)
+            : BigInt(tokenReceived.destinationAmount);
     }
     async getIntentCost(input) {
-        try {
-            const response = await axios_1.default.post(`${this.serverUrl}/intents/cost`, {
-                ...(0, utils_1.convertBigIntFields)(input),
-            }, {
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            return response.data;
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new error_1.OrchestratorError({ message: 'Failed to get intent cost' });
-        }
+        return await this.fetch(`${this.serverUrl}/intents/cost`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify((0, utils_1.convertBigIntFields)(input)),
+        });
     }
     async getIntentRoute(input) {
-        try {
-            const response = await axios_1.default.post(`${this.serverUrl}/intents/route`, {
-                ...(0, utils_1.convertBigIntFields)(input),
-            }, {
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            return response.data;
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new error_1.OrchestratorError({ message: 'Failed to get intent route' });
-        }
+        return await this.fetch(`${this.serverUrl}/intents/route`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify((0, utils_1.convertBigIntFields)(input)),
+        });
     }
-    async submitIntent(signedIntentOp) {
-        try {
-            const response = await axios_1.default.post(`${this.serverUrl}/intent-operations`, {
-                signedIntentOp: (0, utils_1.convertBigIntFields)(signedIntentOp),
-            }, {
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            return response.data;
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new error_1.OrchestratorError({ message: 'Failed to submit intent' });
+    async submitIntent(signedIntentOpUnformatted, dryRun) {
+        const signedIntentOp = (0, utils_1.convertBigIntFields)(signedIntentOpUnformatted);
+        if (dryRun) {
+            signedIntentOp.options = {
+                dryRun: true,
+            };
         }
+        return await this.fetch(`${this.serverUrl}/intent-operations`, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify({
+                signedIntentOp,
+            }),
+        });
     }
-    async simulateIntent(signedIntentOp) {
-        try {
-            const response = await axios_1.default.post(`${this.serverUrl}/intent-operations/simulate`, {
-                signedIntentOp: (0, utils_1.convertBigIntFields)(signedIntentOp),
-            }, {
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            return response.data;
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new error_1.OrchestratorError({ message: 'Failed to simulate intent' });
+    async getIntentOpStatus(intentId) {
+        return await this.fetch(`${this.serverUrl}/intent-operation/${intentId.toString()}`, {
+            headers: this.getHeaders(),
+        });
+    }
+    getHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['x-api-key'] = this.apiKey;
         }
+        return headers;
     }
-    async getIntentOpStatus(intentId) {
-        try {
-            const response = await axios_1.default.get(`${this.serverUrl}/intent-operation/${intentId.toString()}/status`, {
-                headers: {
-                    'x-api-key': this.apiKey,
+    async fetch(url, options) {
+        const response = await fetch(url, options);
+        if (!response.ok) {
+            let errorData = {};
+            try {
+                errorData = await response.json();
+            }
+            catch {
+                try {
+                    const text = await response.text();
+                    errorData = { message: text };
+                }
+                catch { }
+            }
+            const retryAfterHeader = response.headers?.get?.('retry-after') || undefined;
+            this.parseError({
+                response: {
+                    status: response.status,
+                    data: errorData,
+                    headers: {
+                        retryAfter: retryAfterHeader,
+                    },
                 },
             });
-            return response.data;
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new error_1.OrchestratorError({ message: 'Failed to get intent op status' });
         }
+        return response.json();
     }
     parseError(error) {
         if (error.response) {
-            let errorType;
-            if (error.response.status) {
-                switch (error.response.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 500:
-                        errorType = 'Internal Server Error';
-                        break;
-                    default:
-                        errorType = 'Unknown';
-                }
+            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';
             }
-            let context = {};
-            if (error.response.data) {
-                const { errors, traceId, message } = error.response.data;
-                if (message) {
-                    const mainErrorParams = {
-                        context: { traceId },
-                        errorType,
-                        traceId,
-                    };
-                    this.parseErrorMessage(message, mainErrorParams);
-                }
-                for (const err of errors) {
-                    let errorMessage = `Rhinestone Error: ${err.message}`;
-                    if (errorType) {
-                        errorMessage += ` (${errorType})`;
-                    }
-                    if (traceId) {
-                        errorMessage += ` [Trace ID: ${traceId}]`;
-                        context.traceId = traceId;
+            const baseParams = {
+                context: { traceId },
+                errorType,
+                traceId,
+                statusCode: status,
+            };
+            if (status === 429) {
+                const retryAfter = headers?.retryAfter;
+                const context = { traceId, retryAfter };
+                throw new error_1.RateLimitedError({
+                    ...baseParams,
+                    context,
+                });
+            }
+            if (status === 503) {
+                throw new error_1.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 error_1.BadRequestError({
+                        ...baseParams,
+                        context: { traceId, errors },
+                        message: message,
+                    });
+                case 401:
+                    if (message === 'Authentication is required') {
+                        throw new error_1.AuthenticationRequiredError(baseParams);
                     }
-                    console.error(errorMessage);
-                    if (err.context) {
-                        console.error(`Context: ${JSON.stringify(err.context, undefined, 4)}`);
+                    throw new error_1.UnauthorizedError(baseParams);
+                case 403:
+                    throw new error_1.ForbiddenError(baseParams);
+                case 404:
+                    throw new error_1.ResourceNotFoundError(baseParams);
+                case 409:
+                    throw new error_1.ConflictError(baseParams);
+                case 500:
+                    if (errors && errors.length > 0) {
+                        const mergedParams = {
+                            ...baseParams,
+                            context: { ...errors[0].context, traceId },
+                        };
+                        throw new error_1.OrchestratorError({
+                            ...mergedParams,
+                            message: errors[0].message || 'Internal Server Error',
+                        });
                     }
-                    context = { ...context, ...err.context };
-                    const message = err.message;
-                    const finalErrorParams = {
-                        context: { ...context, traceId },
-                        errorType,
-                        traceId,
-                    };
-                    this.parseErrorMessage(message, finalErrorParams);
-                }
-            }
-            else {
-                console.error(error);
+                    throw new error_1.InternalServerError(baseParams);
+                default:
+                    throw new error_1.OrchestratorError({
+                        ...baseParams,
+                        message: message || errorType,
+                    });
             }
         }
     }
@@ -250,7 +266,8 @@ class Orchestrator {
         if (message === 'Insufficient balance') {
             throw new error_1.InsufficientBalanceError(errorParams);
         }
-        else if (message === 'Unsupported chain id') {
+        else if (message === 'Unsupported chain id' ||
+            message === 'Unsupported chain ids') {
             throw new error_1.UnsupportedChainIdError(errorParams);
         }
         else if (message.startsWith('Unsupported chain ')) {
@@ -271,6 +288,10 @@ class Orchestrator {
             }
             throw new error_1.OrchestratorError({ message, ...errorParams });
         }
+        else if (message === 'Unsupported token addresses') {
+            // generic unsupported tokens without specific symbol/chain context
+            throw new error_1.BadRequestError({ message, ...errorParams });
+        }
         else if (message.includes('not supported on chain')) {
             const tokenMatch = message.match(/Token (.+) not supported on chain (\d+)/);
             if (tokenMatch) {
@@ -286,18 +307,43 @@ class Orchestrator {
         else if (message === 'Invalid API key') {
             throw new error_1.InvalidApiKeyError(errorParams);
         }
+        else if (message === 'Insufficient permissions') {
+            throw new error_1.ForbiddenError(errorParams);
+        }
         else if (message === 'Invalid bundle signature') {
             throw new error_1.InvalidIntentSignatureError(errorParams);
         }
-        else if (message === 'Only one target token amount can be unset') {
+        else if (message === 'Invalid checksum signature') {
+            throw new error_1.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);
         }
-        else if (message === 'No Path Found') {
+        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);
         }
-        else if (message === 'Order bundle not found') {
+        else if (message === 'Emissary is not enabled' ||
+            message === 'Emissary is not the expected address') {
+            throw new error_1.ForbiddenError(errorParams);
+        }
+        else if (message.includes('No such intent with nonce') ||
+            message === 'Order bundle not found') {
             throw new error_1.IntentNotFoundError(errorParams);
         }
+        else if (message === 'Could not retrieve a valid quote from any aggregator') {
+            throw new error_1.NoPathFoundError(errorParams);
+        }
+        else if (message === 'No aggregators available for swap') {
+            throw new error_1.InternalServerError(errorParams);
+        }
+        else if (message === 'entity.parse.failed' ||
+            message === 'entity.too.large' ||
+            message === 'encoding.unsupported') {
+            throw new error_1.BodyParserError({ message, ...errorParams });
+        }
         else {
             throw new error_1.OrchestratorError({ message, ...errorParams });
         }