@rhinestone/sdk 0.7.10 → 0.8.1

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

@@ -1,414 +0,0 @@
-import { createPublicClient, encodeAbiParameters, encodeFunctionData, encodePacked, http, isHex, keccak256, padHex, parseAbi, toHex, zeroHash, } from 'viem';
-import { getWethAddress, RHINESTONE_SPOKE_POOL_ADDRESS, } from '../../orchestrator/index.js';
-import { enableSessionsAbi } from '../abi/smart-sessions.js';
-import { MODULE_TYPE_ID_VALIDATOR } from '../common.js';
-import { HOOK_ADDRESS } from '../omni-account.js';
-import { getValidator } from './core.js';
-const SMART_SESSIONS_VALIDATOR_ADDRESS = '0x00000000002b0ecfbd0496ee71e01257da0e37de';
-const SMART_SESSION_MODE_USE = '0x00';
-const SMART_SESSION_MODE_ENABLE = '0x01';
-const SMART_SESSION_MODE_UNSAFE_ENABLE = '0x02';
-const SPENDING_LIMITS_POLICY_ADDRESS = '0x00000088D48cF102A8Cdb0137A9b173f957c6343';
-const TIME_FRAME_POLICY_ADDRESS = '0x8177451511dE0577b911C254E9551D981C26dc72';
-const SUDO_POLICY_ADDRESS = '0x0000003111cD8e92337C100F22B7A9dbf8DEE301';
-const UNIVERSAL_ACTION_POLICY_ADDRESS = '0x0000006DDA6c463511C4e9B05CFc34C1247fCF1F';
-const USAGE_LIMIT_POLICY_ADDRESS = '0x1F34eF8311345A3A4a4566aF321b313052F51493';
-const VALUE_LIMIT_POLICY_ADDRESS = '0x730DA93267E7E513e932301B47F2ac7D062abC83';
-const SMART_SESSIONS_FALLBACK_TARGET_FLAG = '0x0000000000000000000000000000000000000001';
-const SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG = '0x00000001';
-const ACTION_CONDITION_EQUAL = 0;
-const ACTION_CONDITION_GREATER_THAN = 1;
-const ACTION_CONDITION_LESS_THAN = 2;
-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 getEnableSessionCall(chain, session) {
-    const { appDomainSeparator, contentsType } = await getSessionAllowedERC7739Content(chain);
-    const allowedERC7739Content = [
-        {
-            appDomainSeparator,
-            contentName: [contentsType],
-        },
-    ];
-    const sessionData = await getSmartSessionData(chain, session, allowedERC7739Content);
-    return {
-        to: SMART_SESSIONS_VALIDATOR_ADDRESS,
-        data: encodeFunctionData({
-            abi: enableSessionsAbi,
-            functionName: 'enableSessions',
-            args: [[sessionData]],
-        }),
-    };
-}
-function getOmniAccountActions(chain) {
-    const wethAddress = getWethAddress(chain);
-    const omniActions = [
-        {
-            actionTarget: RHINESTONE_SPOKE_POOL_ADDRESS,
-            actionTargetSelector: '0xa2418864', // injected execution
-            actionPolicies: [getPolicyData({ type: 'sudo' })],
-        },
-        {
-            actionTarget: 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) {
-    const publicClient = createPublicClient({
-        chain,
-        transport: http(),
-    });
-    const appDomainSeparator = await publicClient.readContract({
-        address: HOOK_ADDRESS,
-        abi: 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,
-    };
-}
-async function getSmartSessionData(chain, session, allowedERC7739Content) {
-    const omniActions = getOmniAccountActions(chain);
-    const sessionValidator = getValidator(session.owners);
-    const userOpPolicies = (session.policies || [
-        {
-            type: 'sudo',
-        },
-    ]).map((policy) => {
-        return getPolicyData(policy);
-    });
-    return {
-        sessionValidator: sessionValidator.address,
-        sessionValidatorInitData: sessionValidator.initData,
-        salt: session.salt ?? zeroHash,
-        userOpPolicies,
-        // Using the fallback action by default (any transaction will pass)
-        actions: (session.actions || [
-            {
-                target: SMART_SESSIONS_FALLBACK_TARGET_FLAG,
-                selector: SMART_SESSIONS_FALLBACK_TARGET_SELECTOR_FLAG,
-            },
-        ])
-            .map((action) => {
-            const actionPolicies = (action.policies || [
-                {
-                    type: 'sudo',
-                },
-            ]).map((policy) => {
-                return getPolicyData(policy);
-            });
-            return {
-                actionTargetSelector: action.selector,
-                actionTarget: action.target,
-                actionPolicies,
-            };
-        })
-            .concat(omniActions),
-        erc7739Policies: {
-            allowedERC7739Content,
-            erc1271Policies: [getPolicyData({ type: 'sudo' })],
-        },
-        permitERC4337Paymaster: true,
-    };
-}
-function getSmartSessionValidator(config) {
-    if (!config.sessions) {
-        return null;
-    }
-    return {
-        address: SMART_SESSIONS_VALIDATOR_ADDRESS,
-        initData: '0x',
-        deInitData: '0x',
-        additionalContext: '0x',
-        type: MODULE_TYPE_ID_VALIDATOR,
-    };
-}
-function getPolicyData(policy) {
-    switch (policy.type) {
-        case 'sudo':
-            return {
-                policy: SUDO_POLICY_ADDRESS,
-                initData: '0x',
-            };
-        case 'universal-action': {
-            function getCondition(condition) {
-                switch (condition) {
-                    case 'equal':
-                        return ACTION_CONDITION_EQUAL;
-                    case 'greaterThan':
-                        return ACTION_CONDITION_GREATER_THAN;
-                    case 'lessThan':
-                        return ACTION_CONDITION_LESS_THAN;
-                    case 'greaterThanOrEqual':
-                        return ACTION_CONDITION_GREATER_THAN_OR_EQUAL;
-                    case 'lessThanOrEqual':
-                        return ACTION_CONDITION_LESS_THAN_OR_EQUAL;
-                    case 'notEqual':
-                        return ACTION_CONDITION_NOT_EQUAL;
-                    case 'inRange':
-                        return ACTION_CONDITION_IN_RANGE;
-                }
-            }
-            const MAX_RULES = 16;
-            const rules = createFixedArray(MAX_RULES, () => ({
-                condition: ACTION_CONDITION_EQUAL,
-                offset: 0n,
-                isLimited: false,
-                ref: zeroHash,
-                usage: { limit: 0n, used: 0n },
-            }));
-            for (let i = 0; i < policy.rules.length; i++) {
-                const rule = policy.rules[i];
-                const ref = isHex(rule.referenceValue)
-                    ? padHex(rule.referenceValue)
-                    : toHex(rule.referenceValue, { size: 32 });
-                rules[i] = {
-                    condition: getCondition(rule.condition),
-                    offset: rule.calldataOffset,
-                    isLimited: rule.usageLimit !== undefined,
-                    ref,
-                    usage: {
-                        limit: rule.usageLimit ? rule.usageLimit : 0n,
-                        used: 0n,
-                    },
-                };
-            }
-            return {
-                policy: UNIVERSAL_ACTION_POLICY_ADDRESS,
-                initData: encodeAbiParameters([
-                    {
-                        components: [
-                            {
-                                name: 'valueLimitPerUse',
-                                type: 'uint256',
-                            },
-                            {
-                                components: [
-                                    {
-                                        name: 'length',
-                                        type: 'uint256',
-                                    },
-                                    {
-                                        components: [
-                                            {
-                                                name: 'condition',
-                                                type: 'uint8',
-                                            },
-                                            {
-                                                name: 'offset',
-                                                type: 'uint64',
-                                            },
-                                            {
-                                                name: 'isLimited',
-                                                type: 'bool',
-                                            },
-                                            {
-                                                name: 'ref',
-                                                type: 'bytes32',
-                                            },
-                                            {
-                                                components: [
-                                                    {
-                                                        name: 'limit',
-                                                        type: 'uint256',
-                                                    },
-                                                    {
-                                                        name: 'used',
-                                                        type: 'uint256',
-                                                    },
-                                                ],
-                                                name: 'usage',
-                                                type: 'tuple',
-                                            },
-                                        ],
-                                        name: 'rules',
-                                        type: 'tuple[16]',
-                                    },
-                                ],
-                                name: 'paramRules',
-                                type: 'tuple',
-                            },
-                        ],
-                        name: 'ActionConfig',
-                        type: 'tuple',
-                    },
-                ], [
-                    {
-                        valueLimitPerUse: policy.valueLimitPerUse ?? 0n,
-                        paramRules: {
-                            length: BigInt(policy.rules.length),
-                            rules: rules,
-                        },
-                    },
-                ]),
-            };
-        }
-        case 'spending-limits': {
-            const tokens = policy.limits.map(({ token }) => token);
-            const limits = policy.limits.map(({ amount }) => amount);
-            return {
-                policy: SPENDING_LIMITS_POLICY_ADDRESS,
-                initData: encodeAbiParameters([{ type: 'address[]' }, { type: 'uint256[]' }], [tokens, limits]),
-            };
-        }
-        case 'time-frame': {
-            return {
-                policy: TIME_FRAME_POLICY_ADDRESS,
-                initData: encodePacked(['uint128', 'uint128'], [
-                    BigInt(policy.validUntil) / 1000n,
-                    BigInt(policy.validAfter) / 1000n,
-                ]),
-            };
-        }
-        case 'usage-limit': {
-            return {
-                policy: USAGE_LIMIT_POLICY_ADDRESS,
-                initData: encodePacked(['uint128'], [policy.limit]),
-            };
-        }
-        case 'value-limit': {
-            return {
-                policy: VALUE_LIMIT_POLICY_ADDRESS,
-                initData: encodeAbiParameters([{ type: 'uint256' }], [policy.limit]),
-            };
-        }
-    }
-}
-function createFixedArray(length, getValue) {
-    return Array.from({ length }, (_, i) => getValue(i));
-}
-async function isSessionEnabled(client, address, permissionId) {
-    return await client.readContract({
-        address: SMART_SESSIONS_VALIDATOR_ADDRESS,
-        abi: [
-            {
-                inputs: [
-                    {
-                        internalType: 'PermissionId',
-                        name: 'permissionId',
-                        type: 'bytes32',
-                    },
-                    {
-                        internalType: 'address',
-                        name: 'account',
-                        type: 'address',
-                    },
-                ],
-                name: 'isPermissionEnabled',
-                outputs: [
-                    {
-                        internalType: 'bool',
-                        name: '',
-                        type: 'bool',
-                    },
-                ],
-                stateMutability: 'view',
-                type: 'function',
-            },
-        ],
-        functionName: 'isPermissionEnabled',
-        args: [permissionId, address],
-    });
-}
-function encodeSmartSessionSignature(mode, permissionId, signature) {
-    switch (mode) {
-        case SMART_SESSION_MODE_USE:
-            return encodePacked(['bytes1', 'bytes32', 'bytes'], [mode, permissionId, signature]);
-        case SMART_SESSION_MODE_ENABLE:
-        case SMART_SESSION_MODE_UNSAFE_ENABLE:
-            throw new Error('Enable mode not implemented');
-        default:
-            throw new Error(`Unknown mode ${mode}`);
-    }
-}
-function getPermissionId(session) {
-    const sessionValidator = getValidator(session.owners);
-    return keccak256(encodeAbiParameters([
-        {
-            type: 'address',
-            name: 'sessionValidator',
-        },
-        {
-            type: 'bytes',
-            name: 'sessionValidatorInitData',
-        },
-        {
-            type: 'bytes32',
-            name: 'salt',
-        },
-    ], [
-        sessionValidator.address,
-        sessionValidator.initData,
-        session.salt ?? zeroHash,
-    ]));
-}
-async function getAccountEIP712Domain(client, account) {
-    const data = await client.readContract({
-        address: account,
-        abi: [
-            {
-                type: 'function',
-                name: 'eip712Domain',
-                inputs: [],
-                outputs: [
-                    {
-                        type: 'bytes1',
-                        name: 'fields,',
-                    },
-                    {
-                        type: 'string',
-                        name: 'name',
-                    },
-                    {
-                        type: 'string',
-                        name: 'version',
-                    },
-                    {
-                        type: 'uint256',
-                        name: 'chainId',
-                    },
-                    {
-                        type: 'address',
-                        name: 'verifyingContract',
-                    },
-                    {
-                        type: 'bytes32',
-                        name: 'salt',
-                    },
-                    {
-                        type: 'uint256[]',
-                        name: 'extensions',
-                    },
-                ],
-                stateMutability: 'view',
-                constant: true,
-            },
-        ],
-        functionName: 'eip712Domain',
-        args: [],
-    });
-    return {
-        name: data[1],
-        version: data[2],
-        chainId: data[3],
-        verifyingContract: data[4],
-        salt: data[5],
-    };
-}
-export { SMART_SESSION_MODE_USE, SMART_SESSION_MODE_ENABLE, SMART_SESSIONS_VALIDATOR_ADDRESS, getSmartSessionValidator, getEnableSessionCall, encodeSmartSessionSignature, getPermissionId, getAccountEIP712Domain, isSessionEnabled, getSessionAllowedERC7739Content, };

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

@@ -1,29 +0,0 @@
-import { type Address, type Hex } from 'viem';
-import type { UserOperation } from 'viem/account-abstraction';
-import type { BundleEvent, BundleResult, MetaIntent, OrderCostResult, OrderFeeInput, OrderPath, PostOrderBundleResult, SignedMultiChainCompact, UserTokenBalance } 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<UserTokenBalance[]>;
-    getMaxTokenAmount(userAddress: Address, targetChainId: number, targetTokenAddress: Address, targetGasUnits: bigint): Promise<bigint>;
-    getIntentCost(intent: OrderFeeInput, userAddress: Address): Promise<OrderCostResult>;
-    getOrderPath(intent: MetaIntent, userAddress: Address): Promise<OrderPath>;
-    postSignedOrderBundle(signedOrderBundles: {
-        signedOrderBundle: SignedMultiChainCompact;
-        initCode?: Hex;
-        userOp?: UserOperation;
-    }[]): Promise<PostOrderBundleResult>;
-    getBundleStatus(bundleId: bigint): Promise<BundleResult>;
-    getPendingBundles(count?: number, offset?: number): Promise<{
-        pendingBundles: BundleEvent[];
-        nextOffset?: number;
-    }>;
-    private parseError;
-}
-//# sourceMappingURL=client.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../orchestrator/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,OAAO,EAAU,KAAK,GAAG,EAAE,MAAM,MAAM,CAAA;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAG7D,OAAO,KAAK,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,aAAa,EACb,SAAS,EACT,qBAAqB,EACrB,uBAAuB,EACvB,gBAAgB,EACjB,MAAM,SAAS,CAAA;AAShB,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,gBAAgB,EAAE,CAAC;IAwCxB,iBAAiB,CACrB,WAAW,EAAE,OAAO,EACpB,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,OAAO,EAC3B,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,MAAM,CAAC;IAgCZ,aAAa,CACjB,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,eAAe,CAAC;IAqBrB,YAAY,CAChB,MAAM,EAAE,UAAU,EAClB,WAAW,EAAE,OAAO,GACnB,OAAO,CAAC,SAAS,CAAC;IAgCf,qBAAqB,CACzB,kBAAkB,EAAE;QAClB,iBAAiB,EAAE,uBAAuB,CAAA;QAC1C,QAAQ,CAAC,EAAE,GAAG,CAAA;QACd,MAAM,CAAC,EAAE,aAAa,CAAA;KACvB,EAAE,GACF,OAAO,CAAC,qBAAqB,CAAC;IA2C3B,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAyBxD,iBAAiB,CACrB,KAAK,GAAE,MAAW,EAClB,MAAM,GAAE,MAAU,GACjB,OAAO,CAAC;QAAE,cAAc,EAAE,WAAW,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAuBlE,OAAO,CAAC,UAAU;CA6DnB"}

package/dist/src/orchestrator/client.js

@@ -1,243 +0,0 @@
-import axios from 'axios';
-import { concat } from 'viem';
-import { OrchestratorError } from './error.js';
-import { convertBigIntFields, parseCompactResponse, parseOrderCost, parseOrderCostResult, parsePendingBundleEvent, } from './utils.js';
-export class Orchestrator {
-    serverUrl;
-    apiKey;
-    constructor(serverUrl, apiKey) {
-        this.serverUrl = serverUrl;
-        this.apiKey = apiKey;
-    }
-    async getPortfolio(userAddress, filter) {
-        try {
-            const response = await axios.get(`${this.serverUrl}/accounts/${userAddress}/portfolio`, {
-                params: {
-                    chainIds: filter?.chainIds,
-                    tokens: filter?.tokens
-                        ? Object.entries(filter.tokens)
-                            .map(([chainId, tokens]) => tokens.map((token) => `${chainId}:${token}`))
-                            .reduce(concat, [])
-                        : undefined,
-                },
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            return response.data.portfolio.map((balance) => {
-                return {
-                    ...balance,
-                    balance: BigInt(balance.balance),
-                    tokenChainBalance: balance.tokenChainBalance.map((chainBalance) => {
-                        return {
-                            ...chainBalance,
-                            balance: BigInt(chainBalance.balance),
-                        };
-                    }),
-                };
-            });
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new Error('Failed to get portfolio');
-        }
-    }
-    async getMaxTokenAmount(userAddress, targetChainId, targetTokenAddress, targetGasUnits) {
-        const intentCost = await this.getIntentCost({
-            targetChainId,
-            targetGasUnits,
-            tokenTransfers: [
-                {
-                    tokenAddress: targetTokenAddress,
-                },
-            ],
-        }, userAddress);
-        if (!intentCost.hasFulfilledAll) {
-            return 0n;
-        }
-        const tokenReceived = intentCost.tokensReceived.find((token) => token.tokenAddress.toLowerCase() === targetTokenAddress.toLowerCase());
-        if (!tokenReceived) {
-            return 0n;
-        }
-        const tokenAmount = tokenReceived.targetAmount;
-        if (tokenAmount < 0n) {
-            throw new Error(`Balance not available. Make sure the account is deployed`);
-        }
-        return tokenReceived.targetAmount;
-    }
-    async getIntentCost(intent, userAddress) {
-        try {
-            const response = await axios.post(`${this.serverUrl}/accounts/${userAddress}/bundles/cost`, {
-                ...convertBigIntFields(intent),
-            }, {
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            return parseOrderCostResult(response.data);
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new Error(error);
-        }
-    }
-    async getOrderPath(intent, userAddress) {
-        try {
-            const response = await axios.post(`${this.serverUrl}/accounts/${userAddress}/bundles/path`, {
-                ...convertBigIntFields(intent),
-            }, {
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            return response.data.orderBundles.map((orderPath) => {
-                return {
-                    orderBundle: parseCompactResponse(orderPath.orderBundle),
-                    injectedExecutions: orderPath.injectedExecutions.map((exec) => {
-                        return {
-                            ...exec,
-                            value: BigInt(exec.value),
-                        };
-                    }),
-                    intentCost: parseOrderCost(orderPath.intentCost),
-                };
-            });
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new Error(error);
-        }
-    }
-    async postSignedOrderBundle(signedOrderBundles) {
-        try {
-            const bundles = signedOrderBundles.map((signedOrderBundle) => {
-                return {
-                    signedOrderBundle: convertBigIntFields(signedOrderBundle.signedOrderBundle),
-                    initCode: signedOrderBundle.initCode,
-                    userOp: signedOrderBundle.userOp
-                        ? convertBigIntFields(signedOrderBundle.userOp)
-                        : undefined,
-                };
-            });
-            const response = await axios.post(`${this.serverUrl}/bundles`, {
-                bundles,
-            }, {
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            return response.data.bundleResults.map((bundleResult) => {
-                return {
-                    ...bundleResult,
-                    bundleId: BigInt(bundleResult.bundleId),
-                };
-            });
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new Error('Failed to post order bundle');
-        }
-    }
-    async getBundleStatus(bundleId) {
-        try {
-            const response = await axios.get(`${this.serverUrl}/bundles/${bundleId.toString()}`, {
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            response.data.claims = response.data.claims.map((claim) => {
-                return {
-                    ...claim,
-                    depositId: BigInt(claim.depositId),
-                };
-            });
-            return response.data;
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new Error('Failed to get bundle status');
-        }
-    }
-    async getPendingBundles(count = 20, offset = 0) {
-        try {
-            const response = await axios.get(`${this.serverUrl}/bundles/events`, {
-                params: {
-                    count,
-                    offset,
-                },
-                headers: {
-                    'x-api-key': this.apiKey,
-                },
-            });
-            const { events: pendingBundles, nextOffset } = response.data;
-            return {
-                pendingBundles: pendingBundles.map(parsePendingBundleEvent),
-                nextOffset,
-            };
-        }
-        catch (error) {
-            this.parseError(error);
-            throw new Error('Failed to get pending bundles');
-        }
-    }
-    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 } = error.response.data;
-                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 };
-                }
-            }
-            else {
-                console.error(error);
-            }
-            throw new OrchestratorError({
-                message: error.response.data.errors[0].message,
-                context,
-                errorType,
-                traceId: context.traceId,
-            });
-        }
-    }
-}

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

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