@rhinestone/sdk 1.0.40 → 1.0.41-alpha.0

package/dist/src/execution/compact.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COMPACT_ADDRESS = void 0;
-exports.getCompactTypedData = getCompactTypedData;
-exports.getCompactDigest = getCompactDigest;
-exports.getPermit2Digest = getPermit2Digest;
-const viem_1 = require("viem");
-const permit2_1 = require("./permit2");
-const COMPACT_ADDRESS = '0x00000000000000171ede64904551eeDF3C6C9788';
-exports.COMPACT_ADDRESS = COMPACT_ADDRESS;
-// Define the typed data structure as const to preserve type safety
-const COMPACT_TYPED_DATA_TYPES = {
-    MultichainCompact: [
-        { name: 'sponsor', type: 'address' },
-        { name: 'nonce', type: 'uint256' },
-        { name: 'expires', type: 'uint256' },
-        { name: 'elements', type: 'Element[]' },
-    ],
-    Element: [
-        { name: 'arbiter', type: 'address' },
-        { name: 'chainId', type: 'uint256' },
-        { name: 'commitments', type: 'Lock[]' },
-        { name: 'mandate', type: 'Mandate' },
-    ],
-    Lock: [
-        { name: 'lockTag', type: 'bytes12' },
-        { name: 'token', type: 'address' },
-        { name: 'amount', type: 'uint256' },
-    ],
-    Mandate: [
-        { name: 'target', type: 'Target' },
-        { name: 'v', type: 'uint8' },
-        { name: 'minGas', type: 'uint128' },
-        { name: 'originOps', type: 'Op[]' },
-        { name: 'destOps', type: 'Op[]' },
-        { name: 'q', type: 'bytes32' },
-    ],
-    Target: [
-        { name: 'recipient', type: 'address' },
-        { name: 'tokenOut', type: 'Token[]' },
-        { name: 'targetChain', type: 'uint256' },
-        { name: 'fillExpiry', type: 'uint256' },
-    ],
-    Token: [
-        { name: 'token', type: 'address' },
-        { name: 'amount', type: 'uint256' },
-    ],
-    Op: [
-        { name: 'to', type: 'address' },
-        { name: 'value', type: 'uint256' },
-        { name: 'data', type: 'bytes' },
-    ],
-};
-function getCompactTypedData(intentOp) {
-    const typedData = {
-        domain: {
-            name: 'The Compact',
-            version: '1',
-            chainId: Number(intentOp.elements[0].chainId),
-            verifyingContract: '0x73d2dc0c21fca4ec1601895d50df7f5624f07d3f',
-        },
-        types: COMPACT_TYPED_DATA_TYPES,
-        primaryType: 'MultichainCompact',
-        message: {
-            sponsor: intentOp.sponsor,
-            nonce: BigInt(intentOp.nonce),
-            expires: BigInt(intentOp.expires),
-            elements: intentOp.elements.map((element) => ({
-                arbiter: element.arbiter,
-                chainId: BigInt(element.chainId),
-                commitments: element.idsAndAmounts.map((token) => ({
-                    lockTag: (0, viem_1.slice)((0, viem_1.toHex)(BigInt(token[0])), 0, 12),
-                    token: (0, viem_1.slice)((0, viem_1.toHex)(BigInt(token[0])), 12, 32),
-                    amount: BigInt(token[1]),
-                })),
-                mandate: {
-                    target: {
-                        recipient: element.mandate.recipient,
-                        tokenOut: element.mandate.tokenOut.map((token) => ({
-                            token: (0, viem_1.slice)((0, viem_1.toHex)(BigInt(token[0])), 12, 32),
-                            amount: BigInt(token[1]),
-                        })),
-                        targetChain: BigInt(element.mandate.destinationChainId),
-                        fillExpiry: BigInt(element.mandate.fillDeadline),
-                    },
-                    v: element.mandate.v,
-                    minGas: BigInt(element.mandate.minGas),
-                    originOps: element.mandate.preClaimOps.map((op) => ({
-                        to: op.to,
-                        value: BigInt(op.value),
-                        data: op.data,
-                    })),
-                    destOps: element.mandate.destinationOps.map((op) => ({
-                        to: op.to,
-                        value: BigInt(op.value),
-                        data: op.data,
-                    })),
-                    q: (0, viem_1.keccak256)(element.mandate.qualifier.encodedVal),
-                },
-            })),
-        },
-    };
-    return typedData;
-}
-/**
- * Get the compact digest for signing
- * @param intentOp The intent operation
- * @returns The digest hash
- */
-function getCompactDigest(intentOp) {
-    const typedData = getCompactTypedData(intentOp);
-    return (0, viem_1.hashTypedData)(typedData);
-}
-/**
- * Get the Permit2 digest for signing
- * @param intentOp The intent operation
- * @returns The digest hash
- */
-function getPermit2Digest(element, nonce, expires) {
-    const typedData = (0, permit2_1.getTypedData)(element, nonce, expires);
-    return (0, viem_1.hashTypedData)(typedData);
-}

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

@@ -1,61 +0,0 @@
-declare class ExecutionError 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 SignerNotSupportedError extends ExecutionError {
-    constructor(params?: {
-        context?: any;
-        errorType?: string;
-        traceId?: string;
-    });
-}
-declare class CallsNotSupportedError extends ExecutionError {
-    constructor(params?: {
-        context?: any;
-        errorType?: string;
-        traceId?: string;
-    });
-}
-declare class OrderPathRequiredForIntentsError extends ExecutionError {
-    constructor(params?: {
-        context?: any;
-        errorType?: string;
-        traceId?: string;
-    });
-}
-declare class SessionChainRequiredError extends ExecutionError {
-    constructor(params?: {
-        context?: any;
-        errorType?: string;
-        traceId?: string;
-    });
-}
-declare class IntentFailedError extends ExecutionError {
-    constructor(params?: {
-        context?: any;
-        errorType?: string;
-        traceId?: string;
-    });
-}
-declare class IntentStatusTimeoutError extends ExecutionError {
-    constructor(params?: {
-        context?: any;
-        errorType?: string;
-        traceId?: string;
-    });
-}
-declare function isExecutionError(error: Error): error is ExecutionError;
-export { isExecutionError, ExecutionError, OrderPathRequiredForIntentsError, CallsNotSupportedError, SessionChainRequiredError, IntentFailedError, IntentStatusTimeoutError, SignerNotSupportedError, };
-//# sourceMappingURL=error.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../execution/error.ts"],"names":[],"mappings":"AAAA,cAAM,cAAe,SAAQ,KAAK;IAChC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAK;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;IAQD,IAAI,OAAO,WAEV;IAED,IAAI,OAAO,QAEV;IAED,IAAI,SAAS,WAEZ;IAED,IAAI,OAAO,WAEV;CACF;AAED,cAAM,uBAAwB,SAAQ,cAAc;gBACtC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAOF;AAED,cAAM,sBAAuB,SAAQ,cAAc;gBACrC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,gCAAiC,SAAQ,cAAc;gBAC/C,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,yBAA0B,SAAQ,cAAc;gBACxC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAOF;AAED,cAAM,iBAAkB,SAAQ,cAAc;gBAChC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,wBAAyB,SAAQ,cAAc;gBACvC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,iBAAS,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,cAAc,CAE/D;AAED,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,gCAAgC,EAChC,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,wBAAwB,EACxB,uBAAuB,GACxB,CAAA"}

package/dist/src/execution/error.js

@@ -1,87 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignerNotSupportedError = exports.IntentStatusTimeoutError = exports.IntentFailedError = exports.SessionChainRequiredError = exports.CallsNotSupportedError = exports.OrderPathRequiredForIntentsError = exports.ExecutionError = void 0;
-exports.isExecutionError = isExecutionError;
-class ExecutionError extends Error {
-    _message;
-    _context;
-    _errorType;
-    _traceId;
-    constructor(params) {
-        super();
-        this._message = params?.message || 'ExecutionError';
-        this._context = params?.context || {};
-        this._errorType = params?.errorType || 'Unknown';
-        this._traceId = params?.traceId || '';
-    }
-    get message() {
-        return this._message;
-    }
-    get context() {
-        return this._context;
-    }
-    get errorType() {
-        return this._errorType;
-    }
-    get traceId() {
-        return this._traceId;
-    }
-}
-exports.ExecutionError = ExecutionError;
-class SignerNotSupportedError extends ExecutionError {
-    constructor(params) {
-        super({
-            message: 'Sending a transaction is not supported for this type of signers. Use user operations instead.',
-            ...params,
-        });
-    }
-}
-exports.SignerNotSupportedError = SignerNotSupportedError;
-class CallsNotSupportedError extends ExecutionError {
-    constructor(params) {
-        super({
-            message: 'Target chain calls are not supported for this account type',
-            ...params,
-        });
-    }
-}
-exports.CallsNotSupportedError = CallsNotSupportedError;
-class OrderPathRequiredForIntentsError extends ExecutionError {
-    constructor(params) {
-        super({
-            message: 'Order path is required when using intents',
-            ...params,
-        });
-    }
-}
-exports.OrderPathRequiredForIntentsError = OrderPathRequiredForIntentsError;
-class SessionChainRequiredError extends ExecutionError {
-    constructor(params) {
-        super({
-            message: 'Specifying a chain is required when using multi-chain smart sessions',
-            ...params,
-        });
-    }
-}
-exports.SessionChainRequiredError = SessionChainRequiredError;
-class IntentFailedError extends ExecutionError {
-    constructor(params) {
-        super({
-            message: 'Intent failed',
-            ...params,
-        });
-    }
-}
-exports.IntentFailedError = IntentFailedError;
-class IntentStatusTimeoutError extends ExecutionError {
-    constructor(params) {
-        super({
-            message: 'Intent status polling timed out',
-            ...params,
-        });
-    }
-}
-exports.IntentStatusTimeoutError = IntentStatusTimeoutError;
-function isExecutionError(error) {
-    return error instanceof ExecutionError;
-}

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

@@ -1,41 +0,0 @@
-import { type Address, type Chain, type Hex } from 'viem';
-import type { UserOperationReceipt } from 'viem/_types/account-abstraction';
-import type { IntentOpStatus } from '../orchestrator';
-import type { SettlementLayer } from '../orchestrator/types';
-import type { CalldataInput, CallInput, RhinestoneAccountConfig, RhinestoneConfig, SignerSet, SourceAssetInput, Sponsorship, TokenRequest, TokenSymbol, Transaction, UserOperationTransaction } from '../types';
-import { ExecutionError, IntentFailedError, IntentStatusTimeoutError, isExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError } from './error';
-import type { TransactionResult, UserOperationResult } from './utils';
-interface TransactionStatus {
-    fill: {
-        hash: Hex | undefined;
-        chainId: number;
-    };
-    claims: {
-        hash: Hex | undefined;
-        chainId: number;
-    }[];
-}
-declare function sendTransaction(config: RhinestoneAccountConfig, transaction: Transaction): Promise<TransactionResult>;
-declare function sendUserOperation(config: RhinestoneAccountConfig, transaction: UserOperationTransaction): Promise<UserOperationResult>;
-declare function sendTransactionInternal(config: RhinestoneConfig, sourceChains: Chain[] | undefined, targetChain: Chain, options: {
-    callInputs?: CallInput[];
-    gasLimit?: bigint;
-    initialTokenRequests?: TokenRequest[];
-    recipient?: RhinestoneAccountConfig | Address;
-    signers?: SignerSet;
-    sponsored?: Sponsorship;
-    settlementLayers?: SettlementLayer[];
-    sourceAssets?: SourceAssetInput;
-    lockFunds?: boolean;
-    feeAsset?: Address | TokenSymbol;
-}): Promise<TransactionResult>;
-declare function sendUserOperationInternal(config: RhinestoneConfig, chain: Chain, callInputs: CalldataInput[], signers?: SignerSet): Promise<UserOperationResult>;
-declare function waitForExecution(config: RhinestoneConfig, result: TransactionResult | UserOperationResult, acceptsPreconfirmations: boolean): Promise<TransactionStatus | UserOperationReceipt>;
-declare function getMaxSpendableAmount(config: RhinestoneConfig, chain: Chain, token: Address | TokenSymbol, gasUnits: bigint, sponsored?: boolean): Promise<bigint>;
-declare function getPortfolio(config: RhinestoneConfig, onTestnets: boolean): Promise<import("../orchestrator").Portfolio>;
-declare function getIntentStatus(apiKey: string | undefined, endpointUrl: string | undefined, intentId: bigint): Promise<TransactionStatus & {
-    status: IntentOpStatus['status'];
-}>;
-export { sendTransaction, sendTransactionInternal, sendUserOperation, sendUserOperationInternal, waitForExecution, getMaxSpendableAmount, getPortfolio, getIntentStatus, isExecutionError, ExecutionError, IntentFailedError, IntentStatusTimeoutError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError, };
-export type { TransactionStatus, TransactionResult, UserOperationResult };
-//# sourceMappingURL=index.d.ts.map

package/dist/src/execution/index.d.ts.map

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

package/dist/src/execution/index.js

@@ -1,233 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignerNotSupportedError = exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.IntentStatusTimeoutError = exports.IntentFailedError = exports.ExecutionError = exports.isExecutionError = void 0;
-exports.sendTransaction = sendTransaction;
-exports.sendTransactionInternal = sendTransactionInternal;
-exports.sendUserOperation = sendUserOperation;
-exports.sendUserOperationInternal = sendUserOperationInternal;
-exports.waitForExecution = waitForExecution;
-exports.getMaxSpendableAmount = getMaxSpendableAmount;
-exports.getPortfolio = getPortfolio;
-exports.getIntentStatus = getIntentStatus;
-const viem_1 = require("viem");
-const chains_1 = require("viem/chains");
-const accounts_1 = require("../accounts");
-const utils_1 = require("../accounts/utils");
-const orchestrator_1 = require("../orchestrator");
-const registry_1 = require("../orchestrator/registry");
-const error_1 = require("./error");
-Object.defineProperty(exports, "ExecutionError", { enumerable: true, get: function () { return error_1.ExecutionError; } });
-Object.defineProperty(exports, "IntentFailedError", { enumerable: true, get: function () { return error_1.IntentFailedError; } });
-Object.defineProperty(exports, "IntentStatusTimeoutError", { enumerable: true, get: function () { return error_1.IntentStatusTimeoutError; } });
-Object.defineProperty(exports, "isExecutionError", { enumerable: true, get: function () { return error_1.isExecutionError; } });
-Object.defineProperty(exports, "OrderPathRequiredForIntentsError", { enumerable: true, get: function () { return error_1.OrderPathRequiredForIntentsError; } });
-Object.defineProperty(exports, "SessionChainRequiredError", { enumerable: true, get: function () { return error_1.SessionChainRequiredError; } });
-Object.defineProperty(exports, "SignerNotSupportedError", { enumerable: true, get: function () { return error_1.SignerNotSupportedError; } });
-const smart_session_1 = require("./smart-session");
-const utils_2 = require("./utils");
-const POLL_INITIAL_MS = 500;
-const POLL_SLOW_AFTER_MS = 15000;
-const POLL_SLOW_MS = 2000;
-const POLL_MAX_WAIT_MS = 180000;
-const POLL_ERROR_BACKOFF_MS = 1000;
-const POLL_ERROR_BACKOFF_MAX_MS = 10000;
-async function sendTransaction(config, transaction) {
-    const sourceChains = 'chain' in transaction ? [transaction.chain] : transaction.sourceChains;
-    const targetChain = 'chain' in transaction ? transaction.chain : transaction.targetChain;
-    const { calls, gasLimit, tokenRequests, recipient, signers, sponsored, settlementLayers, sourceAssets, feeAsset, } = transaction;
-    const isUserOpSigner = signers?.type === 'guardians' || signers?.type === 'session';
-    if (isUserOpSigner) {
-        throw new error_1.SignerNotSupportedError();
-    }
-    return await sendTransactionInternal(config, sourceChains, targetChain, {
-        callInputs: calls,
-        gasLimit,
-        initialTokenRequests: tokenRequests,
-        recipient,
-        signers,
-        sponsored,
-        settlementLayers,
-        sourceAssets,
-        feeAsset,
-    });
-}
-async function sendUserOperation(config, transaction) {
-    const accountAddress = (0, accounts_1.getAddress)(config);
-    const resolvedCalls = await (0, utils_2.resolveCallInputs)(transaction.calls, config, transaction.chain, accountAddress);
-    const userOpSigner = transaction.signers?.type === 'session' ? transaction.signers.session : null;
-    if (userOpSigner) {
-        await (0, smart_session_1.enableSmartSession)(transaction.chain, config, userOpSigner);
-    }
-    // Smart sessions require a UserOp flow
-    return await sendUserOperationInternal(config, transaction.chain, resolvedCalls, transaction.signers);
-}
-async function sendTransactionInternal(config, sourceChains, targetChain, options) {
-    const accountAddress = (0, accounts_1.getAddress)(config);
-    const resolvedCalls = await (0, utils_2.resolveCallInputs)(options.callInputs, config, targetChain, accountAddress);
-    const tokenRequests = (0, utils_2.getTokenRequests)(sourceChains, targetChain, options.initialTokenRequests, options.settlementLayers);
-    const sendAsUserOp = options.signers?.type === 'guardians' || options.signers?.type === 'session';
-    if (sendAsUserOp) {
-        throw new error_1.SignerNotSupportedError();
-    }
-    else {
-        return await sendTransactionAsIntent(config, sourceChains, targetChain, resolvedCalls, options.gasLimit, tokenRequests, options.recipient, options.signers, options.sponsored, options.settlementLayers, options.sourceAssets, options.feeAsset, options.lockFunds);
-    }
-}
-async function sendUserOperationInternal(config, chain, callInputs, signers) {
-    // Make sure the account is deployed
-    await (0, accounts_1.deploy)(config, chain);
-    const withSession = signers?.type === 'session' ? signers.session : null;
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
-    });
-    const validatorAccount = await (0, utils_2.getValidatorAccount)(config, signers, publicClient, chain);
-    if (!validatorAccount) {
-        throw new Error('No validator account found');
-    }
-    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
-    if (withSession) {
-        await (0, smart_session_1.enableSmartSession)(chain, config, withSession);
-    }
-    const calls = (0, utils_2.parseCalls)(callInputs, chain.id);
-    const hash = await bundlerClient.sendUserOperation({
-        account: validatorAccount,
-        calls,
-    });
-    return {
-        type: 'userop',
-        hash,
-        chain: chain.id,
-    };
-}
-async function sendTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipient, signers, sponsored, settlementLayers, sourceAssets, feeAsset, lockFunds) {
-    const intentRoute = await (0, utils_2.prepareTransactionAsIntent)(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipient, sponsored ?? false, undefined, settlementLayers, sourceAssets, feeAsset, lockFunds, undefined);
-    if (!intentRoute) {
-        throw new error_1.OrderPathRequiredForIntentsError();
-    }
-    const { originSignatures, destinationSignature } = await (0, utils_2.signIntent)(config, intentRoute.intentOp, signers);
-    const authorizations = config.eoa
-        ? await (0, utils_2.signAuthorizationsInternal)(config, intentRoute)
-        : [];
-    return await (0, utils_2.submitIntentInternal)(config, sourceChains, targetChain, intentRoute.intentOp, originSignatures, destinationSignature, authorizations, false);
-}
-async function waitForExecution(config, result, acceptsPreconfirmations) {
-    const validStatuses = new Set([
-        orchestrator_1.INTENT_STATUS_FAILED,
-        orchestrator_1.INTENT_STATUS_COMPLETED,
-        orchestrator_1.INTENT_STATUS_FILLED,
-    ]);
-    if (acceptsPreconfirmations) {
-        validStatuses.add(orchestrator_1.INTENT_STATUS_PRECONFIRMED);
-    }
-    switch (result.type) {
-        case 'intent': {
-            let intentStatus = null;
-            const startTs = Date.now();
-            let nextDelayMs = POLL_INITIAL_MS;
-            let errorBackoffMs = POLL_ERROR_BACKOFF_MS;
-            while (intentStatus === null || !validStatuses.has(intentStatus.status)) {
-                const now = Date.now();
-                if (now - startTs >= POLL_MAX_WAIT_MS) {
-                    throw new error_1.IntentStatusTimeoutError({
-                        context: { waitedMs: now - startTs },
-                    });
-                }
-                const orchestrator = (0, utils_2.getOrchestratorByChain)(result.targetChain, config.apiKey, config.endpointUrl);
-                try {
-                    intentStatus = await orchestrator.getIntentOpStatus(result.id);
-                    // reset error backoff on success
-                    errorBackoffMs = POLL_ERROR_BACKOFF_MS;
-                    const elapsed = Date.now() - startTs;
-                    nextDelayMs =
-                        elapsed >= POLL_SLOW_AFTER_MS ? POLL_SLOW_MS : POLL_INITIAL_MS;
-                    await new Promise((resolve) => setTimeout(resolve, nextDelayMs));
-                }
-                catch (err) {
-                    if ((0, orchestrator_1.isRateLimited)(err)) {
-                        const retryAfter = err?.context?.retryAfter;
-                        let retryMs = nextDelayMs;
-                        if (retryAfter) {
-                            const parsed = Number(retryAfter);
-                            if (!Number.isNaN(parsed)) {
-                                retryMs = Math.max(parsed * 1000, nextDelayMs);
-                            }
-                            else {
-                                const asDate = Date.parse(retryAfter);
-                                if (!Number.isNaN(asDate)) {
-                                    retryMs = Math.max(asDate - Date.now(), nextDelayMs);
-                                }
-                            }
-                        }
-                        else {
-                            retryMs = Math.max(POLL_SLOW_MS, nextDelayMs);
-                        }
-                        await new Promise((resolve) => setTimeout(resolve, retryMs));
-                        continue;
-                    }
-                    if ((0, orchestrator_1.isRetryable)(err)) {
-                        const backoff = Math.min(errorBackoffMs, POLL_ERROR_BACKOFF_MAX_MS);
-                        errorBackoffMs = Math.min(errorBackoffMs * 2, POLL_ERROR_BACKOFF_MAX_MS);
-                        await new Promise((resolve) => setTimeout(resolve, backoff));
-                        continue;
-                    }
-                    throw err;
-                }
-            }
-            if (intentStatus.status === orchestrator_1.INTENT_STATUS_FAILED) {
-                throw new error_1.IntentFailedError();
-            }
-            return {
-                fill: {
-                    hash: intentStatus.fillTransactionHash,
-                    chainId: result.targetChain,
-                },
-                claims: intentStatus.claims.map((claim) => ({
-                    hash: claim.claimTransactionHash,
-                    chainId: claim.chainId,
-                })),
-            };
-        }
-        case 'userop': {
-            const targetChain = (0, registry_1.getChainById)(result.chain);
-            const publicClient = (0, viem_1.createPublicClient)({
-                chain: targetChain,
-                transport: (0, utils_1.createTransport)(targetChain, config.provider),
-            });
-            const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
-            const receipt = await bundlerClient.waitForUserOperationReceipt({
-                hash: result.hash,
-            });
-            return receipt;
-        }
-    }
-}
-async function getMaxSpendableAmount(config, chain, token, gasUnits, sponsored = false) {
-    const orchestrator = (0, utils_2.getOrchestratorByChain)(chain.id, config.apiKey, config.endpointUrl);
-    const tokenAddress = (0, registry_1.resolveTokenAddress)(token, chain.id);
-    const account = (0, utils_2.getIntentAccount)(config, undefined, undefined);
-    return orchestrator.getMaxTokenAmount(account, chain.id, tokenAddress, gasUnits, sponsored);
-}
-async function getPortfolio(config, onTestnets) {
-    const address = (0, accounts_1.getAddress)(config);
-    const chainId = onTestnets ? chains_1.baseSepolia.id : chains_1.base.id;
-    const orchestrator = (0, utils_2.getOrchestratorByChain)(chainId, config.apiKey, config.endpointUrl);
-    return orchestrator.getPortfolio(address);
-}
-async function getIntentStatus(apiKey, endpointUrl, intentId) {
-    const environment = BigInt(intentId.toString().slice(0, 1));
-    const chainId = environment === 4n ? chains_1.base.id : chains_1.baseSepolia.id;
-    const orchestrator = (0, utils_2.getOrchestratorByChain)(chainId, apiKey, endpointUrl);
-    const internalStatus = await orchestrator.getIntentOpStatus(intentId);
-    return {
-        status: internalStatus.status,
-        fill: {
-            hash: internalStatus.fillTransactionHash,
-            chainId: chainId,
-        },
-        claims: internalStatus.claims.map((claim) => ({
-            hash: claim.claimTransactionHash,
-            chainId: claim.chainId,
-        })),
-    };
-}