@rhinestone/sdk 1.0.41-alpha.0 → 1.0.41

package/dist/src/execution/compact.js

@@ -0,0 +1,122 @@
+"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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,87 @@
+"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

@@ -0,0 +1,41 @@
+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

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

package/dist/src/execution/index.js

@@ -0,0 +1,233 @@
+"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,
+        })),
+    };
+}