@rhinestone/sdk 1.5.0 → 2.0.0-beta.0

package/dist/src/execution/error.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignerNotSupportedError = exports.IntentStatusTimeoutError = exports.IntentFailedError = exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.Eip7702InitSignatureRequiredError = exports.ExecutionError = void 0;
-exports.isExecutionError = isExecutionError;
 class ExecutionError extends Error {
     _message;
     _context;
@@ -27,7 +23,6 @@ class ExecutionError extends Error {
         return this._traceId;
     }
 }
-exports.ExecutionError = ExecutionError;
 class SignerNotSupportedError extends ExecutionError {
     constructor(params) {
         super({
@@ -36,7 +31,6 @@ class SignerNotSupportedError extends ExecutionError {
         });
     }
 }
-exports.SignerNotSupportedError = SignerNotSupportedError;
 class OrderPathRequiredForIntentsError extends ExecutionError {
     constructor(params) {
         super({
@@ -45,7 +39,6 @@ class OrderPathRequiredForIntentsError extends ExecutionError {
         });
     }
 }
-exports.OrderPathRequiredForIntentsError = OrderPathRequiredForIntentsError;
 class SessionChainRequiredError extends ExecutionError {
     constructor(params) {
         super({
@@ -54,7 +47,6 @@ class SessionChainRequiredError extends ExecutionError {
         });
     }
 }
-exports.SessionChainRequiredError = SessionChainRequiredError;
 class IntentFailedError extends ExecutionError {
     constructor(params) {
         super({
@@ -63,7 +55,6 @@ class IntentFailedError extends ExecutionError {
         });
     }
 }
-exports.IntentFailedError = IntentFailedError;
 class IntentStatusTimeoutError extends ExecutionError {
     constructor(params) {
         super({
@@ -72,7 +63,6 @@ class IntentStatusTimeoutError extends ExecutionError {
         });
     }
 }
-exports.IntentStatusTimeoutError = IntentStatusTimeoutError;
 class Eip7702InitSignatureRequiredError extends ExecutionError {
     constructor(params) {
         super({
@@ -81,7 +71,7 @@ class Eip7702InitSignatureRequiredError extends ExecutionError {
         });
     }
 }
-exports.Eip7702InitSignatureRequiredError = Eip7702InitSignatureRequiredError;
 function isExecutionError(error) {
     return error instanceof ExecutionError;
 }
+export { isExecutionError, ExecutionError, Eip7702InitSignatureRequiredError, OrderPathRequiredForIntentsError, SessionChainRequiredError, IntentFailedError, IntentStatusTimeoutError, SignerNotSupportedError, };

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

@@ -1,11 +1,11 @@
 import { type Address, type Chain, type Hex } from 'viem';
 import type { UserOperationReceipt } from 'viem/_types/account-abstraction';
-import { type AuthProvider } from '../auth/provider';
-import { type IntentOpStatus, type SplitIntentsInput } 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';
+import { type AuthProvider } from '../auth/provider.js';
+import { type IntentOpStatus, type SplitIntentsInput } from '../orchestrator/index.js';
+import type { SettlementLayer } from '../orchestrator/types.js';
+import type { CalldataInput, CallInput, RhinestoneAccountConfig, RhinestoneConfig, SignerSet, SourceAssetInput, Sponsorship, TokenRequest, TokenSymbol, Transaction, UserOperationTransaction } from '../types.js';
+import { ExecutionError, IntentFailedError, IntentStatusTimeoutError, isExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError } from './error.js';
+import type { TransactionResult, UserOperationResult } from './utils.js';
 interface TransactionStatus {
     fill: {
         hash: Hex | undefined;
@@ -33,11 +33,11 @@ declare function sendTransactionInternal(config: RhinestoneConfig, sourceChains:
 }): 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 getPortfolio(config: RhinestoneConfig, onTestnets: boolean): Promise<import("../orchestrator").Portfolio>;
+declare function getPortfolio(config: RhinestoneConfig, onTestnets: boolean): Promise<import("../orchestrator/index.js").Portfolio>;
 declare function getIntentStatus(authProvider: AuthProvider, endpointUrl: string | undefined, intentId: bigint, headers?: Record<string, string>): Promise<TransactionStatus & {
     status: IntentOpStatus['status'];
 }>;
-declare function splitIntents(authProvider: AuthProvider, endpointUrl: string | undefined, input: SplitIntentsInput, headers?: Record<string, string>): Promise<import("../orchestrator").SplitIntentsResult>;
+declare function splitIntents(authProvider: AuthProvider, endpointUrl: string | undefined, input: SplitIntentsInput, headers?: Record<string, string>): Promise<import("../orchestrator/index.js").SplitIntentsResult>;
 export { sendTransaction, sendTransactionInternal, sendUserOperation, sendUserOperationInternal, waitForExecution, getPortfolio, getIntentStatus, splitIntents, isExecutionError, ExecutionError, IntentFailedError, IntentStatusTimeoutError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError, };
 export type { TransactionStatus, TransactionResult, UserOperationResult };
 //# sourceMappingURL=index.d.ts.map

package/dist/src/execution/index.js

@@ -1,29 +1,11 @@
-"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.getPortfolio = getPortfolio;
-exports.getIntentStatus = getIntentStatus;
-exports.splitIntents = splitIntents;
-const viem_1 = require("viem");
-const accounts_1 = require("../accounts");
-const utils_1 = require("../accounts/utils");
-const provider_1 = require("../auth/provider");
-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 utils_2 = require("./utils");
+import { createPublicClient } from 'viem';
+import { deploy, getAddress } from '../accounts/index.js';
+import { createTransport, getBundlerClient } from '../accounts/utils.js';
+import { createAuthProvider } from '../auth/provider.js';
+import { getOrchestrator, INTENT_STATUS_COMPLETED, INTENT_STATUS_FAILED, INTENT_STATUS_FILLED, INTENT_STATUS_PRECONFIRMED, isRateLimited, isRetryable, } from '../orchestrator/index.js';
+import { getChainById, getSupportedChainIds, isTestnet, } from '../orchestrator/registry.js';
+import { ExecutionError, IntentFailedError, IntentStatusTimeoutError, isExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError, } from './error.js';
+import { getTargetExecutionSignature, getTokenRequests, getValidatorAccount, parseCalls, prepareTransactionAsIntent, resolveCallInputs, signAuthorizationsInternal, signIntent, submitIntentInternal, } from './utils.js';
 const POLL_INITIAL_MS = 500;
 const POLL_SLOW_AFTER_MS = 15000;
 const POLL_SLOW_MS = 2000;
@@ -36,7 +18,7 @@ async function sendTransaction(config, transaction) {
     const { calls, gasLimit, tokenRequests, recipient, signers, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, } = transaction;
     const isUserOpSigner = signers?.type === 'guardians';
     if (isUserOpSigner) {
-        throw new error_1.SignerNotSupportedError();
+        throw new SignerNotSupportedError();
     }
     return await sendTransactionInternal(config, sourceChains, targetChain, {
         callInputs: calls,
@@ -52,17 +34,17 @@ async function sendTransaction(config, transaction) {
     });
 }
 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 accountAddress = getAddress(config);
+    const resolvedCalls = await resolveCallInputs(transaction.calls, config, transaction.chain, accountAddress);
     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)(targetChain, options.initialTokenRequests);
+    const accountAddress = getAddress(config);
+    const resolvedCalls = await resolveCallInputs(options.callInputs, config, targetChain, accountAddress);
+    const tokenRequests = getTokenRequests(targetChain, options.initialTokenRequests);
     const sendAsUserOp = options.signers?.type === 'guardians';
     if (sendAsUserOp) {
-        throw new error_1.SignerNotSupportedError();
+        throw new SignerNotSupportedError();
     }
     else {
         return await sendTransactionAsIntent(config, sourceChains, targetChain, resolvedCalls, options.gasLimit, tokenRequests, options.recipient, options.signers, options.sponsored, options.eip7702InitSignature, options.settlementLayers, options.sourceAssets, options.feeAsset, options.lockFunds);
@@ -70,17 +52,17 @@ async function sendTransactionInternal(config, sourceChains, targetChain, option
 }
 async function sendUserOperationInternal(config, chain, callInputs, signers) {
     // Make sure the account is deployed
-    await (0, accounts_1.deploy)(config, chain);
-    const publicClient = (0, viem_1.createPublicClient)({
+    await deploy(config, chain);
+    const publicClient = createPublicClient({
         chain,
-        transport: (0, utils_1.createTransport)(chain, config.provider),
+        transport: createTransport(chain, config.provider),
     });
-    const validatorAccount = await (0, utils_2.getValidatorAccount)(config, signers, publicClient, chain);
+    const validatorAccount = await getValidatorAccount(config, signers, publicClient, chain);
     if (!validatorAccount) {
         throw new Error('No validator account found');
     }
-    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
-    const calls = (0, utils_2.parseCalls)(callInputs, chain.id);
+    const bundlerClient = getBundlerClient(config, publicClient);
+    const calls = parseCalls(callInputs, chain.id);
     const hash = await bundlerClient.sendUserOperation({
         account: validatorAccount,
         calls,
@@ -92,26 +74,26 @@ async function sendUserOperationInternal(config, chain, callInputs, signers) {
     };
 }
 async function sendTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipient, signers, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds) {
-    const prepared = await (0, utils_2.prepareTransactionAsIntent)(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipient, sponsored ?? false, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds, undefined, undefined, signers);
+    const prepared = await prepareTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, recipient, sponsored ?? false, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds, undefined, undefined, signers);
     if (!prepared) {
-        throw new error_1.OrderPathRequiredForIntentsError();
+        throw new OrderPathRequiredForIntentsError();
     }
     const { intentRoute, intentInput } = prepared;
-    const { originSignatures, destinationSignature } = await (0, utils_2.signIntent)(config, intentRoute.intentOp, targetChain, signers);
-    const targetExecutionSignature = await (0, utils_2.getTargetExecutionSignature)(config, intentRoute.intentOp, targetChain, signers);
+    const { originSignatures, destinationSignature } = await signIntent(config, intentRoute.intentOp, targetChain, signers);
+    const targetExecutionSignature = await getTargetExecutionSignature(config, intentRoute.intentOp, targetChain, signers);
     const authorizations = config.eoa
-        ? await (0, utils_2.signAuthorizationsInternal)(config, intentRoute)
+        ? await signAuthorizationsInternal(config, intentRoute)
         : [];
-    return await (0, utils_2.submitIntentInternal)(config, sourceChains, targetChain, intentRoute.intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations, false, intentInput);
+    return await submitIntentInternal(config, sourceChains, targetChain, intentRoute.intentOp, originSignatures, destinationSignature, targetExecutionSignature, authorizations, false, intentInput);
 }
 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,
+        INTENT_STATUS_FAILED,
+        INTENT_STATUS_COMPLETED,
+        INTENT_STATUS_FILLED,
     ]);
     if (acceptsPreconfirmations) {
-        validStatuses.add(orchestrator_1.INTENT_STATUS_PRECONFIRMED);
+        validStatuses.add(INTENT_STATUS_PRECONFIRMED);
     }
     switch (result.type) {
         case 'intent': {
@@ -122,13 +104,13 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
             while (intentStatus === null || !validStatuses.has(intentStatus.status)) {
                 const now = Date.now();
                 if (now - startTs >= POLL_MAX_WAIT_MS) {
-                    throw new error_1.IntentStatusTimeoutError({
+                    throw new IntentStatusTimeoutError({
                         context: {
                             intentId: result.id.toString(),
                         },
                     });
                 }
-                const orchestrator = (0, orchestrator_1.getOrchestrator)(config._authProvider ?? (0, provider_1.createAuthProvider)(config), config.endpointUrl, config.headers);
+                const orchestrator = getOrchestrator(config._authProvider ?? createAuthProvider(config), config.endpointUrl, config.headers);
                 try {
                     intentStatus = await orchestrator.getIntentOpStatus(result.id);
                     // reset error backoff on success
@@ -139,7 +121,7 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
                     await new Promise((resolve) => setTimeout(resolve, nextDelayMs));
                 }
                 catch (err) {
-                    if ((0, orchestrator_1.isRateLimited)(err)) {
+                    if (isRateLimited(err)) {
                         const retryAfter = err?.context?.retryAfter;
                         let retryMs = nextDelayMs;
                         if (retryAfter) {
@@ -160,7 +142,7 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
                         await new Promise((resolve) => setTimeout(resolve, retryMs));
                         continue;
                     }
-                    if ((0, orchestrator_1.isRetryable)(err)) {
+                    if (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));
@@ -169,9 +151,9 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
                     throw err;
                 }
             }
-            if (intentStatus.status === orchestrator_1.INTENT_STATUS_FAILED) {
+            if (intentStatus.status === INTENT_STATUS_FAILED) {
                 const intentId = result.id.toString();
-                throw new error_1.IntentFailedError({
+                throw new IntentFailedError({
                     context: {
                         intentId,
                     },
@@ -189,12 +171,12 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
             };
         }
         case 'userop': {
-            const targetChain = (0, registry_1.getChainById)(result.chain);
-            const publicClient = (0, viem_1.createPublicClient)({
+            const targetChain = getChainById(result.chain);
+            const publicClient = createPublicClient({
                 chain: targetChain,
-                transport: (0, utils_1.createTransport)(targetChain, config.provider),
+                transport: createTransport(targetChain, config.provider),
             });
-            const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+            const bundlerClient = getBundlerClient(config, publicClient);
             const receipt = await bundlerClient.waitForUserOperationReceipt({
                 hash: result.hash,
             });
@@ -203,12 +185,12 @@ async function waitForExecution(config, result, acceptsPreconfirmations) {
     }
 }
 async function getPortfolio(config, onTestnets) {
-    const address = (0, accounts_1.getAddress)(config);
-    const orchestrator = (0, orchestrator_1.getOrchestrator)(config._authProvider ?? (0, provider_1.createAuthProvider)(config), config.endpointUrl, config.headers);
-    const supportedChainIds = (0, registry_1.getSupportedChainIds)();
+    const address = getAddress(config);
+    const orchestrator = getOrchestrator(config._authProvider ?? createAuthProvider(config), config.endpointUrl, config.headers);
+    const supportedChainIds = getSupportedChainIds();
     const filteredChainIds = supportedChainIds.filter((id) => {
         try {
-            return (0, registry_1.isTestnet)(id) === onTestnets;
+            return isTestnet(id) === onTestnets;
         }
         catch {
             return false;
@@ -217,7 +199,7 @@ async function getPortfolio(config, onTestnets) {
     return orchestrator.getPortfolio(address, { chainIds: filteredChainIds });
 }
 async function getIntentStatus(authProvider, endpointUrl, intentId, headers) {
-    const orchestrator = (0, orchestrator_1.getOrchestrator)(authProvider, endpointUrl, headers);
+    const orchestrator = getOrchestrator(authProvider, endpointUrl, headers);
     const internalStatus = await orchestrator.getIntentOpStatus(intentId);
     return {
         status: internalStatus.status,
@@ -232,6 +214,9 @@ async function getIntentStatus(authProvider, endpointUrl, intentId, headers) {
     };
 }
 async function splitIntents(authProvider, endpointUrl, input, headers) {
-    const orchestrator = (0, orchestrator_1.getOrchestrator)(authProvider, endpointUrl, headers);
+    const orchestrator = getOrchestrator(authProvider, endpointUrl, headers);
     return orchestrator.splitIntents(input);
 }
+export { sendTransaction, sendTransactionInternal, sendUserOperation, sendUserOperationInternal, waitForExecution, getPortfolio, getIntentStatus, splitIntents, 
+// Errors
+isExecutionError, ExecutionError, IntentFailedError, IntentStatusTimeoutError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError, };

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

@@ -1,7 +1,7 @@
 import { type Address, type Chain } from 'viem';
-import type { IntentOpElement } from '../orchestrator/types';
-import type { RhinestoneConfig } from '../types';
-import type { BatchPermit2Result, MultiChainPermit2Config, MultiChainPermit2Result, TokenPermissions } from './types';
+import type { IntentOpElement } from '../orchestrator/types.js';
+import type { RhinestoneConfig } from '../types.js';
+import type { BatchPermit2Result, MultiChainPermit2Config, MultiChainPermit2Result, TokenPermissions } from './types.js';
 declare function getTypedData(element: IntentOpElement, nonce: bigint, expires: bigint): {
     readonly domain: {
         readonly name: "Permit2";
@@ -103,8 +103,8 @@ declare function getTypedData(element: IntentOpElement, nonce: bigint, expires:
                 readonly fillExpiry: bigint;
             };
             readonly minGas: bigint;
-            readonly originOps: import("../orchestrator/types").Op;
-            readonly destOps: import("../orchestrator/types").Op;
+            readonly originOps: import("../orchestrator/types.js").Op;
+            readonly destOps: import("../orchestrator/types.js").Op;
             readonly q: `0x${string}`;
         };
     };

package/dist/src/execution/permit2.js

@@ -1,13 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypedData = getTypedData;
-exports.checkERC20Allowance = checkERC20Allowance;
-exports.checkERC20AllowanceDirect = checkERC20AllowanceDirect;
-exports.getPermit2Address = getPermit2Address;
-exports.signPermit2Batch = signPermit2Batch;
-exports.signPermit2Sequential = signPermit2Sequential;
-const viem_1 = require("viem");
-const utils_1 = require("../accounts/utils");
+import { createPublicClient, keccak256, } from 'viem';
+import { createTransport } from '../accounts/utils.js';
 const PERMIT2_ADDRESS = '0x000000000022D473030F116dDEE9F6B43aC78BA3';
 function toToken(id) {
     return `0x${(id & ((1n << 160n) - 1n)).toString(16).padStart(40, '0')}`;
@@ -90,7 +82,7 @@ function getTypedData(element, nonce, expires) {
                 minGas: BigInt(mandate.minGas),
                 originOps: mandate.preClaimOps,
                 destOps: mandate.destinationOps,
-                q: (0, viem_1.keccak256)(mandate.qualifier.encodedVal),
+                q: keccak256(mandate.qualifier.encodedVal),
             },
         },
     };
@@ -124,9 +116,9 @@ async function checkERC20AllowanceDirect(owner, spender, tokenAddress, publicCli
 }
 async function checkERC20Allowance(tokenAddress, chain, config) {
     try {
-        const publicClient = (0, viem_1.createPublicClient)({
+        const publicClient = createPublicClient({
             chain,
-            transport: (0, utils_1.createTransport)(chain, config.provider),
+            transport: createTransport(chain, config.provider),
         });
         // Get the account owner from the config
         const owner = config.eoa?.address;
@@ -283,3 +275,6 @@ async function signPermit2Sequential(configs, onProgress) {
         allSuccessful: failedSignatures === 0,
     };
 }
+export { getTypedData, checkERC20Allowance, checkERC20AllowanceDirect, getPermit2Address, 
+// Multi-chain permit2 signing methods
+signPermit2Batch, signPermit2Sequential, };

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

@@ -1,5 +1,5 @@
 import type { Address } from 'viem';
-import type { IntentOpElement } from '../orchestrator/types';
+import type { IntentOpElement } from '../orchestrator/types.js';
 declare function getTypedData(account: Address, intentExecutorAddress: Address, element: IntentOpElement, nonce: bigint): {
     domain: {
         name: string;
@@ -29,7 +29,7 @@ declare function getTypedData(account: Address, intentExecutorAddress: Address,
     message: {
         account: `0x${string}`;
         nonce: bigint;
-        op: import("../orchestrator/types").Op;
+        op: import("../orchestrator/types.js").Op;
         gasRefund: {
             token: Address;
             exchangeRate: bigint;

package/dist/src/execution/singleChainOps.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTypedData = getTypedData;
 function getTypedData(account, intentExecutorAddress, element, nonce) {
     const { destinationChainId, destinationOps } = element.mandate;
     const gasRefund = element.mandate.qualifier.settlementContext.gasRefund;
@@ -42,3 +39,4 @@ function getTypedData(account, intentExecutorAddress, element, nonce) {
         },
     };
 }
+export { getTypedData };

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

@@ -1,5 +1,5 @@
 import type { Account, Address, Chain, Hex } from 'viem';
-import type { IntentOp } from '../orchestrator/types';
+import type { IntentOp } from '../orchestrator/types.js';
 interface TokenPermissions {
     token: Address;
     amount: bigint;

package/dist/src/execution/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

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

@@ -1,9 +1,9 @@
 import { type Address, type Chain, type HashTypedDataParameters, type Hex, type PublicClient, type SignableMessage, type SignedAuthorization, type SignedAuthorizationList, type TypedData, type TypedDataDefinition, type TypedDataDomain } from 'viem';
 import { type UserOperation } from 'viem/account-abstraction';
-import type { ResolvedSessionSignerSet } from '../modules/validators/smart-sessions';
-import { type IntentOp, type IntentRoute } from '../orchestrator';
-import { type AuxiliaryFunds, type OriginSignature, type SettlementLayer } from '../orchestrator/types';
-import type { Call, CalldataInput, CallInput, RhinestoneAccountConfig, RhinestoneConfig, Session, SessionEnableData, SessionSignerSet, SignerSet, SourceAssetInput, Sponsorship, TokenRequest, TokenSymbol, Transaction, UserOperationTransaction } from '../types';
+import type { ResolvedSessionSignerSet } from '../modules/validators/smart-sessions.js';
+import { type IntentOp, type IntentRoute } from '../orchestrator/index.js';
+import { type AuxiliaryFunds, type OriginSignature, type SettlementLayer } from '../orchestrator/types.js';
+import type { Call, CalldataInput, CallInput, RhinestoneAccountConfig, RhinestoneConfig, Session, SessionEnableData, SessionSignerSet, SignerSet, SourceAssetInput, Sponsorship, TokenRequest, TokenSymbol, Transaction, UserOperationTransaction } from '../types.js';
 type InternalSignerSet = Exclude<SignerSet, SessionSignerSet> | ResolvedSessionSignerSet;
 declare function resolveSessionForChain(signers: SessionSignerSet, chainId: number): {
     session: Session;