@charterlabs/rhinestone-sdk 0.1.0 → 0.1.2

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

@@ -0,0 +1,226 @@
+"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");
+const common_1 = require("../common");
+const smart_sessions_2 = require("./smart-sessions");
+(0, vitest_1.describe)('Smart Sessions', () => {
+    (0, vitest_1.describe)('Permission ID', () => {
+        (0, vitest_1.test)('default', () => {
+            (0, vitest_1.expect)((0, smart_sessions_2.getPermissionId)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA, consts_1.accountB],
+                },
+            })).toBe('0x4ad46f8661acf29090a7635877ff94953e0ea05b0583d32de3839acc49739182');
+        });
+        (0, vitest_1.test)('with salt', () => {
+            (0, vitest_1.expect)((0, smart_sessions_2.getPermissionId)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA, consts_1.accountB],
+                },
+                salt: '0x97340e1cfff3319c76ef22b2bc9d3231071d550125d68c9d4a8972823f166320',
+            })).toBe('0xb1adc169088099c6830120c63cde8d2c7e1b9a82857b35c0527dc2e37ce3e7bd');
+        });
+    });
+    (0, vitest_1.describe)('Smart Session Validator', () => {
+        (0, vitest_1.test)('no session', () => {
+            (0, vitest_1.expect)((0, smart_sessions_2.getSmartSessionValidator)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA],
+                },
+                rhinestoneApiKey: consts_1.MOCK_API_KEY,
+            })).toBeNull();
+        });
+        (0, vitest_1.test)('empty session list', () => {
+            (0, vitest_1.expect)((0, smart_sessions_2.getSmartSessionValidator)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA],
+                },
+                rhinestoneApiKey: consts_1.MOCK_API_KEY,
+                sessions: [],
+            })).not.toBeNull();
+        });
+        (0, vitest_1.test)('single session', () => {
+            const validator = (0, smart_sessions_2.getSmartSessionValidator)({
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA],
+                },
+                rhinestoneApiKey: consts_1.MOCK_API_KEY,
+                sessions: [
+                    {
+                        owners: {
+                            type: 'ecdsa',
+                            accounts: [consts_1.accountA],
+                        },
+                    },
+                ],
+            });
+            (0, vitest_1.expect)(validator).not.toBeNull();
+            (0, vitest_1.expect)(validator?.type).toEqual(common_1.MODULE_TYPE_ID_VALIDATOR);
+            (0, vitest_1.expect)(validator && (0, viem_1.isAddress)(validator.address)).toEqual(true);
+        });
+    });
+    (0, vitest_1.describe)('Enable Session Call', () => {
+        vitest_1.vi.mock('viem', async (importOriginal) => {
+            const actual = await importOriginal();
+            return {
+                // @ts-ignore
+                ...actual,
+                createPublicClient: vitest_1.vi.fn().mockReturnValue({
+                    readContract: vitest_1.vi.fn(),
+                }),
+            };
+        });
+        const client = viem_1.createPublicClient;
+        client.mockImplementation((_) => {
+            return {
+                readContract: (params) => {
+                    if (params.functionName === 'DOMAIN_SEPARATOR') {
+                        return '0xf5f6dfa751763cc5278cba45d03ea9797c1660b2cb7f5ffd188fa3e8523abdca';
+                    }
+                    throw new Error('Unknown function call');
+                },
+            };
+        });
+        const TARGET = '0x063DFbDb1610EC7BbfA1fFBE603Ac5aA1B67a935';
+        const SELECTOR = '0x12345678';
+        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, {
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA],
+                },
+            });
+            const sessionData = toSessionData(call);
+            // Should have a fallback action
+            (0, vitest_1.expect)(sessionData.actions.some((action) => action.actionTarget === FALLBACK_TARGET &&
+                action.actionTargetSelector === FALLBACK_SELECTOR)).toEqual(true);
+        });
+        (0, vitest_1.test)('with action', async () => {
+            const call = await (0, smart_sessions_2.getEnableSessionCall)(chains_1.mainnet, {
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA],
+                },
+                actions: [
+                    {
+                        target: TARGET,
+                        selector: SELECTOR,
+                    },
+                ],
+            });
+            const sessionData = toSessionData(call);
+            // Should have the action
+            (0, vitest_1.expect)(sessionData.actions.some((action) => action.actionTarget === TARGET &&
+                action.actionTargetSelector === SELECTOR)).toEqual(true);
+            // Should not have the fallback action
+            (0, vitest_1.expect)(sessionData.actions.some((action) => action.actionTarget === FALLBACK_TARGET &&
+                action.actionTargetSelector === FALLBACK_SELECTOR)).toEqual(false);
+        });
+        (0, vitest_1.test)('with policy', async () => {
+            const call = await (0, smart_sessions_2.getEnableSessionCall)(chains_1.mainnet, {
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA],
+                },
+                policies: [
+                    {
+                        type: 'sudo',
+                    },
+                    {
+                        type: 'universal-action',
+                        rules: [
+                            {
+                                condition: 'equal',
+                                calldataOffset: 0n,
+                                referenceValue: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
+                            },
+                        ],
+                    },
+                ],
+            });
+            const sessionData = toSessionData(call);
+            // Should have two policies
+            (0, vitest_1.expect)(sessionData.userOpPolicies.length).toEqual(2);
+            (0, vitest_1.expect)((0, viem_1.isAddress)(sessionData.userOpPolicies[0].policy)).toEqual(true);
+            (0, vitest_1.expect)((0, viem_1.isHex)(sessionData.userOpPolicies[0].initData)).toEqual(true);
+            (0, vitest_1.expect)((0, viem_1.isAddress)(sessionData.userOpPolicies[1].policy)).toEqual(true);
+            (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, {
+                owners: {
+                    type: 'ecdsa',
+                    accounts: [consts_1.accountA],
+                },
+                actions: [
+                    {
+                        target: TARGET,
+                        selector: SELECTOR,
+                        policies: [
+                            {
+                                type: 'sudo',
+                            },
+                            {
+                                type: 'universal-action',
+                                rules: [
+                                    {
+                                        condition: 'equal',
+                                        calldataOffset: 0n,
+                                        referenceValue: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            });
+            const sessionData = toSessionData(call);
+            // Should have the action
+            const action = sessionData.actions.find((action) => action.actionTarget === TARGET &&
+                action.actionTargetSelector === SELECTOR);
+            (0, vitest_1.expect)(action).toBeDefined();
+            if (!action) {
+                throw new Error('No action');
+            }
+            // Should have 2 policies
+            const actionPolicies = action.actionPolicies;
+            (0, vitest_1.expect)(actionPolicies.length).toEqual(2);
+            (0, vitest_1.expect)((0, viem_1.isAddress)(actionPolicies[0].policy)).toEqual(true);
+            (0, vitest_1.expect)((0, viem_1.isHex)(actionPolicies[0].initData)).toEqual(true);
+            (0, vitest_1.expect)((0, viem_1.isAddress)(actionPolicies[1].policy)).toEqual(true);
+            (0, vitest_1.expect)((0, viem_1.isHex)(actionPolicies[1].initData)).toEqual(true);
+        });
+        function toSessionData(call) {
+            (0, vitest_1.expect)((0, viem_1.isHex)(call.data)).toEqual(true);
+            (0, vitest_1.expect)((0, viem_1.isAddress)(call.to)).toEqual(true);
+            const decoded = (0, viem_1.decodeFunctionData)({
+                abi: smart_sessions_1.enableSessionsAbi,
+                data: call.data,
+            });
+            (0, vitest_1.expect)(decoded.functionName).toEqual('enableSessions');
+            (0, vitest_1.expect)(decoded.args.length).toEqual(1);
+            (0, vitest_1.expect)(decoded.args[0].length).toEqual(1);
+            const session = decoded.args[0][0];
+            return session;
+        }
+    });
+    (0, vitest_1.describe)('Encode Smart Session Signature', () => {
+        (0, vitest_1.test)('use mode', () => {
+            const permissionId = '0x4ad46f8661acf29090a7635877ff94953e0ea05b0583d32de3839acc49739182';
+            const signature = '0xabcdef';
+            const sessionSignature = (0, smart_sessions_2.encodeSmartSessionSignature)(smart_sessions_2.SMART_SESSION_MODE_USE, permissionId, signature);
+            (0, vitest_1.expect)(sessionSignature).toEqual('0x004ad46f8661acf29090a7635877ff94953e0ea05b0583d32de3839acc49739182abcdef');
+        });
+    });
+});

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

@@ -0,0 +1,21 @@
+import { type Address } from 'viem';
+import type { IntentCost, IntentInput, IntentOpStatus, IntentResult, IntentRoute, Portfolio, SignedIntentOp } from './types';
+export declare class Orchestrator {
+    private serverUrl;
+    private apiKey;
+    constructor(serverUrl: string, apiKey: string);
+    getPortfolio(userAddress: Address, filter?: {
+        chainIds?: number[];
+        tokens?: {
+            [chainId: number]: Address[];
+        };
+    }): Promise<Portfolio>;
+    getMaxTokenAmount(userAddress: Address, destinationChainId: number, destinationTokenAddress: Address, destinationGasUnits: bigint): Promise<bigint>;
+    getIntentCost(input: IntentInput): Promise<IntentCost>;
+    getIntentRoute(input: IntentInput): Promise<IntentRoute>;
+    submitIntent(signedIntentOp: SignedIntentOp): Promise<IntentResult>;
+    getIntentOpStatus(intentId: bigint): Promise<IntentOpStatus>;
+    private parseError;
+    private parseErrorMessage;
+}
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +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,CAAQ;gBAEV,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAKvC,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,GAC1B,OAAO,CAAC,MAAM,CAAC;IA0CZ,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC;IA0BtD,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAqBxD,YAAY,CAAC,cAAc,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;IAqBnE,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAkBlE,OAAO,CAAC,UAAU;IA0ElB,OAAO,CAAC,iBAAiB;CAmD1B"}

package/dist/src/orchestrator/client.js

@@ -0,0 +1,284 @@
+"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");
+class Orchestrator {
+    serverUrl;
+    apiKey;
+    constructor(serverUrl, apiKey) {
+        this.serverUrl = serverUrl;
+        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;
+        }
+        catch (error) {
+            this.parseError(error);
+            throw new Error('Failed to get portfolio');
+        }
+    }
+    async getMaxTokenAmount(userAddress, destinationChainId, destinationTokenAddress, destinationGasUnits) {
+        const intentCost = await this.getIntentCost({
+            account: {
+                address: userAddress,
+                accountType: 'ERC7579',
+                setupOps: [
+                    {
+                        to: viem_1.zeroAddress,
+                        data: '0x',
+                    },
+                ],
+                delegations: {},
+            },
+            destinationExecutions: [],
+            destinationChainId,
+            destinationGasUnits,
+            tokenTransfers: [
+                {
+                    tokenAddress: destinationTokenAddress,
+                },
+            ],
+        });
+        if (!intentCost.hasFulfilledAll) {
+            return 0n;
+        }
+        const tokenReceived = intentCost.tokensReceived.find((token) => token.tokenAddress.toLowerCase() ===
+            destinationTokenAddress.toLowerCase());
+        if (!tokenReceived) {
+            return 0n;
+        }
+        const tokenAmount = tokenReceived.destinationAmount;
+        if (tokenAmount < 0n) {
+            throw new Error(`Balance not available. Make sure the account is deployed`);
+        }
+        return tokenReceived.destinationAmount;
+    }
+    async getIntentCost(input) {
+        try {
+            const response = await axios_1.default.post(`${this.serverUrl}/intents/cost`, {
+                ...(0, utils_1.convertBigIntFields)({
+                    ...input,
+                    tokenTransfers: input.tokenTransfers.map((transfer) => ({
+                        tokenAddress: transfer.tokenAddress,
+                    })),
+                }),
+            }, {
+                headers: {
+                    'x-api-key': this.apiKey,
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.parseError(error);
+            throw new Error('Failed to get intent cost');
+        }
+    }
+    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('Failed to get intent route');
+        }
+    }
+    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('Failed to submit intent');
+        }
+    }
+    async getIntentOpStatus(intentId) {
+        try {
+            const response = await axios_1.default.get(`${this.serverUrl}/intent-operation/${intentId.toString()}/status`, {
+                headers: {
+                    'x-api-key': this.apiKey,
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            this.parseError(error);
+            throw new Error('Failed to get intent op status');
+        }
+    }
+    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';
+                }
+            }
+            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;
+                    }
+                    console.error(errorMessage);
+                    if (err.context) {
+                        console.error(`Context: ${JSON.stringify(err.context, undefined, 4)}`);
+                    }
+                    context = { ...context, ...err.context };
+                    const message = err.message;
+                    const finalErrorParams = {
+                        context: { ...context, traceId },
+                        errorType,
+                        traceId,
+                    };
+                    this.parseErrorMessage(message, finalErrorParams);
+                }
+            }
+            else {
+                console.error(error);
+            }
+        }
+    }
+    parseErrorMessage(message, errorParams) {
+        if (message === 'Insufficient balance') {
+            throw new error_1.InsufficientBalanceError(errorParams);
+        }
+        else if (message === 'Unsupported chain id') {
+            throw new error_1.UnsupportedChainIdError(errorParams);
+        }
+        else if (message.startsWith('Unsupported chain ')) {
+            const chainIdMatch = message.match(/Unsupported chain (\d+)/);
+            if (chainIdMatch) {
+                const chainId = parseInt(chainIdMatch[1], 10);
+                throw new error_1.UnsupportedChainError(chainId, errorParams);
+            }
+            throw new error_1.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 error_1.UnsupportedTokenError(tokenSymbol, chainId, errorParams);
+            }
+            throw new error_1.OrchestratorError({ message, ...errorParams });
+        }
+        else if (message.includes('not supported on chain')) {
+            const tokenMatch = message.match(/Token (.+) not supported on chain (\d+)/);
+            if (tokenMatch) {
+                const tokenAddress = tokenMatch[1];
+                const chainId = parseInt(tokenMatch[2], 10);
+                throw new error_1.TokenNotSupportedError(tokenAddress, chainId, errorParams);
+            }
+            throw new error_1.OrchestratorError({ message, ...errorParams });
+        }
+        else if (message === 'Authentication is required') {
+            throw new error_1.AuthenticationRequiredError(errorParams);
+        }
+        else if (message === 'Invalid API key') {
+            throw new error_1.InvalidApiKeyError(errorParams);
+        }
+        else if (message === 'Invalid bundle signature') {
+            throw new error_1.InvalidIntentSignatureError(errorParams);
+        }
+        else if (message === 'Only one target token amount can be unset') {
+            throw new error_1.OnlyOneTargetTokenAmountCanBeUnsetError(errorParams);
+        }
+        else if (message === 'No Path Found') {
+            throw new error_1.NoPathFoundError(errorParams);
+        }
+        else if (message === 'Order bundle not found') {
+            throw new error_1.IntentNotFoundError(errorParams);
+        }
+        else {
+            throw new error_1.OrchestratorError({ message, ...errorParams });
+        }
+    }
+}
+exports.Orchestrator = Orchestrator;

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

@@ -0,0 +1,5 @@
+declare const PROD_ORCHESTRATOR_URL = "https://v1.orchestrator.rhinestone.dev";
+declare const STAGING_ORCHESTRATOR_URL = "https://staging.v1.orchestrator.rhinestone.dev";
+declare const RHINESTONE_SPOKE_POOL_ADDRESS = "0x000000000060f6e853447881951574cdd0663530";
+export { PROD_ORCHESTRATOR_URL, STAGING_ORCHESTRATOR_URL, RHINESTONE_SPOKE_POOL_ADDRESS, };
+//# sourceMappingURL=consts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../../../orchestrator/consts.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,qBAAqB,2CAA2C,CAAA;AACtE,QAAA,MAAM,wBAAwB,mDACoB,CAAA;AAClD,QAAA,MAAM,6BAA6B,+CACW,CAAA;AAE9C,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,6BAA6B,GAC9B,CAAA"}

package/dist/src/orchestrator/consts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RHINESTONE_SPOKE_POOL_ADDRESS = exports.STAGING_ORCHESTRATOR_URL = exports.PROD_ORCHESTRATOR_URL = void 0;
+const PROD_ORCHESTRATOR_URL = 'https://v1.orchestrator.rhinestone.dev';
+exports.PROD_ORCHESTRATOR_URL = PROD_ORCHESTRATOR_URL;
+const STAGING_ORCHESTRATOR_URL = 'https://staging.v1.orchestrator.rhinestone.dev';
+exports.STAGING_ORCHESTRATOR_URL = STAGING_ORCHESTRATOR_URL;
+const RHINESTONE_SPOKE_POOL_ADDRESS = '0x000000000060f6e853447881951574cdd0663530';
+exports.RHINESTONE_SPOKE_POOL_ADDRESS = RHINESTONE_SPOKE_POOL_ADDRESS;

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

@@ -0,0 +1,96 @@
+declare class OrchestratorError extends Error {
+    private readonly _message;
+    private readonly _context;
+    private readonly _errorType;
+    private readonly _traceId;
+    constructor(params?: {
+        message?: string;
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+    get message(): string;
+    get context(): any;
+    get errorType(): string;
+    get traceId(): string;
+}
+declare class InsufficientBalanceError extends OrchestratorError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class UnsupportedChainIdError extends OrchestratorError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class UnsupportedChainError extends OrchestratorError {
+    constructor(chainId: number, params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class UnsupportedTokenError extends OrchestratorError {
+    constructor(tokenSymbol: string, chainId: number, params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class TokenNotSupportedError extends OrchestratorError {
+    constructor(tokenAddress: string, chainId: number, params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class AuthenticationRequiredError extends OrchestratorError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class InvalidApiKeyError extends OrchestratorError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class InvalidIntentSignatureError extends OrchestratorError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class OnlyOneTargetTokenAmountCanBeUnsetError extends OrchestratorError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class NoPathFoundError extends OrchestratorError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class IntentNotFoundError extends OrchestratorError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare function isOrchestratorError(error: Error): error is OrchestratorError;
+export { isOrchestratorError, OrchestratorError, InsufficientBalanceError, UnsupportedChainIdError, UnsupportedChainError, UnsupportedTokenError, TokenNotSupportedError, AuthenticationRequiredError, InvalidApiKeyError, InvalidIntentSignatureError, OnlyOneTargetTokenAmountCanBeUnsetError, NoPathFoundError, IntentNotFoundError, };
+//# sourceMappingURL=error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../orchestrator/error.ts"],"names":[],"mappings":"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"}