@rhinestone/sdk 1.0.0-alpha.32 → 1.0.0-alpha.33

package/dist/src/actions/recovery.test.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const vitest_1 = require("vitest");
+const consts_1 = require("../../test/consts");
+const __1 = require("..");
+const utils_1 = require("../execution/utils");
+const recovery_1 = require("./recovery");
+const accountAddress = '0x36C03e7D593F7B2C6b06fC18B5f4E9a4A29C99b0';
+// Mock viem
+vitest_1.vi.mock('viem', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        // @ts-ignore
+        ...actual,
+        createPublicClient: vitest_1.vi.fn(),
+    };
+});
+(0, vitest_1.describe)('Recovery Actions', () => {
+    (0, vitest_1.describe)('Set Up Recovery', async () => {
+        const rhinestone = new __1.RhinestoneSDK();
+        const rhinestoneAccount = await rhinestone.createAccount({
+            owners: {
+                type: 'ecdsa',
+                accounts: [consts_1.accountA],
+            },
+        });
+        (0, vitest_1.test)('Single Guardian', async () => {
+            const calls = await (0, utils_1.resolveCallInputs)([(0, recovery_1.enable)([consts_1.accountB], 1)], rhinestoneAccount.config, chains_1.base, accountAddress);
+            (0, vitest_1.expect)(calls).toEqual([
+                {
+                    to: accountAddress,
+                    value: 0n,
+                    data: '0x9517e29f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a04d053b3c8021e8d5bf641816c42daa75d8b597000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000010000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7',
+                },
+            ]);
+        });
+        (0, vitest_1.test)('Guardian Multi-Sig', async () => {
+            const calls = await (0, utils_1.resolveCallInputs)([(0, recovery_1.enable)([consts_1.accountB, consts_1.accountC, consts_1.accountD], 2)], rhinestoneAccount.config, chains_1.base, accountAddress);
+            (0, vitest_1.expect)(calls).toEqual([
+                {
+                    to: accountAddress,
+                    value: 0n,
+                    data: '0x9517e29f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000a04d053b3c8021e8d5bf641816c42daa75d8b597000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000030000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000c27b7578151c5ef713c62c65db09763d57ac3596000000000000000000000000c5587d912c862252599b61926adaef316ba06da0',
+                },
+            ]);
+        });
+    });
+    (0, vitest_1.describe)('Recover', () => {
+        const rhinestone = new __1.RhinestoneSDK();
+        const accountPromise = rhinestone.createAccount({
+            owners: {
+                type: 'ecdsa',
+                accounts: [consts_1.accountA],
+            },
+        });
+        const mockPublicClient = {
+            readContract: vitest_1.vi.fn(),
+            multicall: vitest_1.vi.fn(),
+        };
+        (0, vitest_1.beforeEach)(() => {
+            const createPublicClientMock = viem_1.createPublicClient;
+            createPublicClientMock.mockReturnValue(mockPublicClient);
+            vitest_1.vi.clearAllMocks();
+        });
+        (0, vitest_1.test)('1/1 Owners - Single owner to different single owner', async () => {
+            const rhinestoneAccount = await accountPromise;
+            // Initial state
+            mockPublicClient.multicall.mockResolvedValueOnce([
+                { result: [consts_1.accountA.address.toLowerCase()], status: 'success' },
+                { result: 1n, status: 'success' },
+            ]);
+            const newOwners = {
+                type: 'ecdsa',
+                accounts: [consts_1.accountB],
+                threshold: 1,
+            };
+            const result = await (0, recovery_1.recoverEcdsaOwnership)(accountAddress, newOwners, chains_1.base, rhinestoneAccount.config);
+            (0, vitest_1.expect)(mockPublicClient.multicall).toHaveBeenCalledTimes(1);
+            (0, vitest_1.expect)(result).toEqual([
+                {
+                    to: '0x000000000013fdb5234e4e3162a810f54d9f7e98',
+                    value: 0n,
+                    data: '0x7065cb480000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7',
+                },
+                {
+                    to: '0x000000000013fdb5234e4e3162a810f54d9f7e98',
+                    value: 0n,
+                    data: '0xfbe5ce0a0000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000f6c02c78ded62973b43bfa523b247da099486936',
+                },
+            ]);
+        });
+        (0, vitest_1.test)('1/N Owners - Single owner to multiple owners', async () => {
+            const rhinestoneAccount = await accountPromise;
+            // Initial state
+            mockPublicClient.multicall.mockResolvedValueOnce([
+                {
+                    result: [
+                        consts_1.accountA.address.toLowerCase(),
+                        consts_1.accountB.address.toLowerCase(),
+                        consts_1.accountC.address.toLowerCase(),
+                    ],
+                    status: 'success',
+                },
+                { result: 1n, status: 'success' },
+            ]);
+            const newOwners = {
+                type: 'ecdsa',
+                accounts: [consts_1.accountB, consts_1.accountC, consts_1.accountD],
+                threshold: 1,
+            };
+            const result = await (0, recovery_1.recoverEcdsaOwnership)(accountAddress, newOwners, chains_1.base, rhinestoneAccount.config);
+            (0, vitest_1.expect)(mockPublicClient.multicall).toHaveBeenCalledTimes(1);
+            (0, vitest_1.expect)(result).toEqual([
+                {
+                    to: '0x000000000013fdb5234e4e3162a810f54d9f7e98',
+                    value: 0n,
+                    data: '0x7065cb48000000000000000000000000c5587d912c862252599b61926adaef316ba06da0',
+                },
+                {
+                    to: '0x000000000013fdb5234e4e3162a810f54d9f7e98',
+                    value: 0n,
+                    data: '0xfbe5ce0a000000000000000000000000c5587d912c862252599b61926adaef316ba06da0000000000000000000000000f6c02c78ded62973b43bfa523b247da099486936',
+                },
+            ]);
+        });
+        (0, vitest_1.test)('M/N Owners - Multiple owners to different multiple owners', async () => {
+            const rhinestoneAccount = await accountPromise;
+            // Initial state
+            mockPublicClient.multicall.mockResolvedValueOnce([
+                {
+                    result: [
+                        consts_1.accountA.address.toLowerCase(),
+                        consts_1.accountB.address.toLowerCase(),
+                        consts_1.accountC.address.toLowerCase(),
+                    ],
+                    status: 'success',
+                },
+                { result: 2n, status: 'success' },
+            ]);
+            const newOwners = {
+                type: 'ecdsa',
+                accounts: [consts_1.accountB, consts_1.accountD],
+                threshold: 2,
+            };
+            const result = await (0, recovery_1.recoverEcdsaOwnership)(accountAddress, newOwners, chains_1.base, rhinestoneAccount.config);
+            (0, vitest_1.expect)(mockPublicClient.multicall).toHaveBeenCalledTimes(1);
+            (0, vitest_1.expect)(result).toEqual([
+                {
+                    to: '0x000000000013fdb5234e4e3162a810f54d9f7e98',
+                    value: 0n,
+                    data: '0x7065cb48000000000000000000000000c5587d912c862252599b61926adaef316ba06da0',
+                },
+                {
+                    to: '0x000000000013fdb5234e4e3162a810f54d9f7e98',
+                    value: 0n,
+                    data: '0xfbe5ce0a000000000000000000000000c5587d912c862252599b61926adaef316ba06da0000000000000000000000000f6c02c78ded62973b43bfa523b247da099486936',
+                },
+                {
+                    to: '0x000000000013fdb5234e4e3162a810f54d9f7e98',
+                    value: 0n,
+                    data: '0xfbe5ce0a0000000000000000000000006092086a3dc0020cd604a68fcf5d430007d51bb7000000000000000000000000c27b7578151c5ef713c62c65db09763d57ac3596',
+                },
+            ]);
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+import { AccountConfigurationNotSupportedError, AccountError, Eip7702AccountMustHaveEoaError, Eip7702NotSupportedForAccountError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, isAccountError, SigningNotSupportedForAccountError, SmartSessionsNotEnabledError, WalletClientNoConnectedAccountError } from '../accounts';
+import { ExecutionError, IntentFailedError, isExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError } from '../execution';
+import { AuthenticationRequiredError, InsufficientBalanceError, IntentNotFoundError, InvalidApiKeyError, InvalidIntentSignatureError, isOrchestratorError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, TokenNotSupportedError, UnsupportedChainError, UnsupportedChainIdError, UnsupportedTokenError } from '../orchestrator';
+export { isAccountError, AccountError, AccountConfigurationNotSupportedError, Eip7702AccountMustHaveEoaError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, SmartSessionsNotEnabledError, SigningNotSupportedForAccountError, Eip7702NotSupportedForAccountError, WalletClientNoConnectedAccountError, isExecutionError, ExecutionError, IntentFailedError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError, isOrchestratorError, AuthenticationRequiredError, InsufficientBalanceError, InvalidApiKeyError, InvalidIntentSignatureError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, IntentNotFoundError, TokenNotSupportedError, UnsupportedChainError, UnsupportedChainIdError, UnsupportedTokenError, };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qCAAqC,EACrC,YAAY,EACZ,8BAA8B,EAC9B,kCAAkC,EAClC,wCAAwC,EACxC,4BAA4B,EAC5B,cAAc,EACd,kCAAkC,EAClC,4BAA4B,EAC5B,mCAAmC,EACpC,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,gCAAgC,EAChC,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,2BAA2B,EAC3B,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,2BAA2B,EAC3B,mBAAmB,EACnB,gBAAgB,EAChB,uCAAuC,EACvC,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,iBAAiB,CAAA;AAExB,OAAO,EAEL,cAAc,EACd,YAAY,EACZ,qCAAqC,EACrC,8BAA8B,EAC9B,wCAAwC,EACxC,4BAA4B,EAC5B,4BAA4B,EAC5B,kCAAkC,EAClC,kCAAkC,EAClC,mCAAmC,EAEnC,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,gCAAgC,EAChC,yBAAyB,EACzB,uBAAuB,EAEvB,mBAAmB,EACnB,2BAA2B,EAC3B,wBAAwB,EACxB,kBAAkB,EAClB,2BAA2B,EAC3B,gBAAgB,EAChB,uCAAuC,EACvC,iBAAiB,EACjB,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,GACtB,CAAA"}

package/dist/src/errors/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedTokenError = exports.UnsupportedChainIdError = exports.UnsupportedChainError = exports.TokenNotSupportedError = exports.IntentNotFoundError = exports.OrchestratorError = exports.OnlyOneTargetTokenAmountCanBeUnsetError = exports.NoPathFoundError = exports.InvalidIntentSignatureError = exports.InvalidApiKeyError = exports.InsufficientBalanceError = exports.AuthenticationRequiredError = exports.isOrchestratorError = exports.SignerNotSupportedError = exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.IntentFailedError = exports.ExecutionError = exports.isExecutionError = exports.WalletClientNoConnectedAccountError = exports.Eip7702NotSupportedForAccountError = exports.SigningNotSupportedForAccountError = exports.SmartSessionsNotEnabledError = exports.FactoryArgsNotAvailableError = exports.ExistingEip7702AccountsNotSupportedError = exports.Eip7702AccountMustHaveEoaError = exports.AccountConfigurationNotSupportedError = exports.AccountError = exports.isAccountError = void 0;
+const accounts_1 = require("../accounts");
+Object.defineProperty(exports, "AccountConfigurationNotSupportedError", { enumerable: true, get: function () { return accounts_1.AccountConfigurationNotSupportedError; } });
+Object.defineProperty(exports, "AccountError", { enumerable: true, get: function () { return accounts_1.AccountError; } });
+Object.defineProperty(exports, "Eip7702AccountMustHaveEoaError", { enumerable: true, get: function () { return accounts_1.Eip7702AccountMustHaveEoaError; } });
+Object.defineProperty(exports, "Eip7702NotSupportedForAccountError", { enumerable: true, get: function () { return accounts_1.Eip7702NotSupportedForAccountError; } });
+Object.defineProperty(exports, "ExistingEip7702AccountsNotSupportedError", { enumerable: true, get: function () { return accounts_1.ExistingEip7702AccountsNotSupportedError; } });
+Object.defineProperty(exports, "FactoryArgsNotAvailableError", { enumerable: true, get: function () { return accounts_1.FactoryArgsNotAvailableError; } });
+Object.defineProperty(exports, "isAccountError", { enumerable: true, get: function () { return accounts_1.isAccountError; } });
+Object.defineProperty(exports, "SigningNotSupportedForAccountError", { enumerable: true, get: function () { return accounts_1.SigningNotSupportedForAccountError; } });
+Object.defineProperty(exports, "SmartSessionsNotEnabledError", { enumerable: true, get: function () { return accounts_1.SmartSessionsNotEnabledError; } });
+Object.defineProperty(exports, "WalletClientNoConnectedAccountError", { enumerable: true, get: function () { return accounts_1.WalletClientNoConnectedAccountError; } });
+const execution_1 = require("../execution");
+Object.defineProperty(exports, "ExecutionError", { enumerable: true, get: function () { return execution_1.ExecutionError; } });
+Object.defineProperty(exports, "IntentFailedError", { enumerable: true, get: function () { return execution_1.IntentFailedError; } });
+Object.defineProperty(exports, "isExecutionError", { enumerable: true, get: function () { return execution_1.isExecutionError; } });
+Object.defineProperty(exports, "OrderPathRequiredForIntentsError", { enumerable: true, get: function () { return execution_1.OrderPathRequiredForIntentsError; } });
+Object.defineProperty(exports, "SessionChainRequiredError", { enumerable: true, get: function () { return execution_1.SessionChainRequiredError; } });
+Object.defineProperty(exports, "SignerNotSupportedError", { enumerable: true, get: function () { return execution_1.SignerNotSupportedError; } });
+const orchestrator_1 = require("../orchestrator");
+Object.defineProperty(exports, "AuthenticationRequiredError", { enumerable: true, get: function () { return orchestrator_1.AuthenticationRequiredError; } });
+Object.defineProperty(exports, "InsufficientBalanceError", { enumerable: true, get: function () { return orchestrator_1.InsufficientBalanceError; } });
+Object.defineProperty(exports, "IntentNotFoundError", { enumerable: true, get: function () { return orchestrator_1.IntentNotFoundError; } });
+Object.defineProperty(exports, "InvalidApiKeyError", { enumerable: true, get: function () { return orchestrator_1.InvalidApiKeyError; } });
+Object.defineProperty(exports, "InvalidIntentSignatureError", { enumerable: true, get: function () { return orchestrator_1.InvalidIntentSignatureError; } });
+Object.defineProperty(exports, "isOrchestratorError", { enumerable: true, get: function () { return orchestrator_1.isOrchestratorError; } });
+Object.defineProperty(exports, "NoPathFoundError", { enumerable: true, get: function () { return orchestrator_1.NoPathFoundError; } });
+Object.defineProperty(exports, "OnlyOneTargetTokenAmountCanBeUnsetError", { enumerable: true, get: function () { return orchestrator_1.OnlyOneTargetTokenAmountCanBeUnsetError; } });
+Object.defineProperty(exports, "OrchestratorError", { enumerable: true, get: function () { return orchestrator_1.OrchestratorError; } });
+Object.defineProperty(exports, "TokenNotSupportedError", { enumerable: true, get: function () { return orchestrator_1.TokenNotSupportedError; } });
+Object.defineProperty(exports, "UnsupportedChainError", { enumerable: true, get: function () { return orchestrator_1.UnsupportedChainError; } });
+Object.defineProperty(exports, "UnsupportedChainIdError", { enumerable: true, get: function () { return orchestrator_1.UnsupportedChainIdError; } });
+Object.defineProperty(exports, "UnsupportedTokenError", { enumerable: true, get: function () { return orchestrator_1.UnsupportedTokenError; } });

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

@@ -1,16 +1,5 @@
-import { type Address } from 'viem';
 import type { IntentOp } from '../orchestrator/types';
-import type { Call } from '../types';
 declare const COMPACT_ADDRESS = "0x73d2dc0c21fca4ec1601895d50df7f5624f07d3f";
-declare function depositEther(account: Address, value: bigint): Call;
-declare function enableEtherWithdrawal(): Call;
-declare function disableEtherWithdrawal(): Call;
-declare function withdrawEther(account: Address, value: bigint): Call;
-declare function depositErc20(account: Address, tokenAddress: Address, amount: bigint): Call;
-declare function enableErc20Withdrawal(tokenAddress: Address): Call;
-declare function disableErc20Withdrawal(tokenAddress: Address): Call;
-declare function withdrawErc20(account: Address, tokenAddress: Address, amount: bigint): Call;
-declare function approveErc20(tokenAddress: Address, amount: bigint): Call;
 declare function getCompactTypedData(intentOp: IntentOp): {
     readonly domain: {
         readonly name: "The Compact";
@@ -137,5 +126,5 @@ declare function getCompactTypedData(intentOp: IntentOp): {
         }[];
     };
 };
-export { COMPACT_ADDRESS, depositEther, enableEtherWithdrawal, disableEtherWithdrawal, withdrawEther, depositErc20, enableErc20Withdrawal, disableErc20Withdrawal, withdrawErc20, approveErc20, getCompactTypedData, };
+export { COMPACT_ADDRESS, getCompactTypedData };
 //# sourceMappingURL=compact.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../execution/compact.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EASb,MAAM,MAAM,CAAA;AACb,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AACrD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAA;AAcpC,QAAA,MAAM,eAAe,+CAA+C,CAAA;AAKpE,iBAAS,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAqB3D;AAED,iBAAS,qBAAqB,IAAI,IAAI,CAGrC;AAED,iBAAS,sBAAsB,IAAI,IAAI,CAGtC;AAED,iBAAS,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAG5D;AAED,iBAAS,YAAY,CACnB,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,OAAO,EACrB,MAAM,EAAE,MAAM,GACb,IAAI,CA2BN;AAED,iBAAS,qBAAqB,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI,CAG1D;AAED,iBAAS,sBAAsB,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI,CAG3D;AAED,iBAAS,aAAa,CACpB,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,OAAO,EACrB,MAAM,EAAE,MAAM,GACb,IAAI,CAGN;AAsED,iBAAS,YAAY,CAAC,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAUjE;AA8ED,iBAAS,mBAAmB,CAAC,QAAQ,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiD9C;AAED,OAAO,EACL,eAAe,EACf,YAAY,EACZ,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,YAAY,EACZ,qBAAqB,EACrB,sBAAsB,EACtB,aAAa,EACb,YAAY,EACZ,mBAAmB,GACpB,CAAA"}
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../execution/compact.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAErD,QAAA,MAAM,eAAe,+CAA+C,CAAA;AA4CpE,iBAAS,mBAAmB,CAAC,QAAQ,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiD9C;AAED,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/src/execution/compact.js

@@ -1,200 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMPACT_ADDRESS = void 0;
-exports.depositEther = depositEther;
-exports.enableEtherWithdrawal = enableEtherWithdrawal;
-exports.disableEtherWithdrawal = disableEtherWithdrawal;
-exports.withdrawEther = withdrawEther;
-exports.depositErc20 = depositErc20;
-exports.enableErc20Withdrawal = enableErc20Withdrawal;
-exports.disableErc20Withdrawal = disableErc20Withdrawal;
-exports.withdrawErc20 = withdrawErc20;
-exports.approveErc20 = approveErc20;
 exports.getCompactTypedData = getCompactTypedData;
 const viem_1 = require("viem");
 const COMPACT_ADDRESS = '0x73d2dc0c21fca4ec1601895d50df7f5624f07d3f';
 exports.COMPACT_ADDRESS = COMPACT_ADDRESS;
-const ALLOCATOR_ADDRESS = '0xd93ed1dd9f1f0b523e4d77233809dc2ee22928c6';
-const DEFAULT_RESET_PERIOD = 6;
-const DEFAULT_SCOPE = 0;
-function depositEther(account, value) {
-    return {
-        to: COMPACT_ADDRESS,
-        data: (0, viem_1.encodeFunctionData)({
-            abi: [
-                {
-                    type: 'function',
-                    name: 'depositNative',
-                    inputs: [
-                        { name: 'lockTag', type: 'bytes12', internalType: 'bytes12' },
-                        { name: 'recipient', type: 'address', internalType: 'address' },
-                    ],
-                    outputs: [{ name: 'id', type: 'uint256', internalType: 'uint256' }],
-                    stateMutability: 'payable',
-                },
-            ],
-            functionName: 'depositNative',
-            args: [lockTag(), account],
-        }),
-        value,
-    };
-}
-function enableEtherWithdrawal() {
-    const id = (0, viem_1.concat)([lockTag(), viem_1.zeroAddress]);
-    return enableForcedWithdrawal(BigInt(id));
-}
-function disableEtherWithdrawal() {
-    const id = (0, viem_1.concat)([lockTag(), viem_1.zeroAddress]);
-    return disableForcedWithdrawal(BigInt(id));
-}
-function withdrawEther(account, value) {
-    const id = (0, viem_1.concat)([lockTag(), viem_1.zeroAddress]);
-    return forcedWithdrawal(BigInt(id), account, value);
-}
-function depositErc20(account, tokenAddress, amount) {
-    return {
-        to: COMPACT_ADDRESS,
-        value: 0n,
-        data: (0, viem_1.encodeFunctionData)({
-            abi: [
-                {
-                    type: 'function',
-                    name: 'depositERC20',
-                    inputs: [
-                        {
-                            name: 'token',
-                            type: 'address',
-                            internalType: 'address',
-                        },
-                        { name: 'lockTag', type: 'bytes12', internalType: 'bytes12' },
-                        { name: 'amount', type: 'uint256', internalType: 'uint256' },
-                        { name: 'recipient', type: 'address', internalType: 'address' },
-                    ],
-                    outputs: [{ name: 'id', type: 'uint256', internalType: 'uint256' }],
-                    stateMutability: 'nonpayable',
-                },
-            ],
-            functionName: 'depositERC20',
-            args: [tokenAddress, lockTag(), amount, account],
-        }),
-    };
-}
-function enableErc20Withdrawal(tokenAddress) {
-    const id = (0, viem_1.concat)([lockTag(), tokenAddress]);
-    return enableForcedWithdrawal(BigInt(id));
-}
-function disableErc20Withdrawal(tokenAddress) {
-    const id = (0, viem_1.concat)([lockTag(), tokenAddress]);
-    return disableForcedWithdrawal(BigInt(id));
-}
-function withdrawErc20(account, tokenAddress, amount) {
-    const id = (0, viem_1.concat)([lockTag(), tokenAddress]);
-    return forcedWithdrawal(BigInt(id), account, amount);
-}
-function enableForcedWithdrawal(id) {
-    return {
-        to: COMPACT_ADDRESS,
-        data: (0, viem_1.encodeFunctionData)({
-            abi: [
-                {
-                    type: 'function',
-                    name: 'enableForcedWithdrawal',
-                    inputs: [{ name: 'id', type: 'uint256', internalType: 'uint256' }],
-                    outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
-                    stateMutability: 'nonpayable',
-                },
-            ],
-            functionName: 'enableForcedWithdrawal',
-            args: [id],
-        }),
-        value: 0n,
-    };
-}
-function disableForcedWithdrawal(id) {
-    return {
-        to: COMPACT_ADDRESS,
-        data: (0, viem_1.encodeFunctionData)({
-            abi: [
-                {
-                    type: 'function',
-                    name: 'disableForcedWithdrawal',
-                    inputs: [{ name: 'id', type: 'uint256', internalType: 'uint256' }],
-                    outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
-                    stateMutability: 'nonpayable',
-                },
-            ],
-            functionName: 'disableForcedWithdrawal',
-            args: [id],
-        }),
-        value: 0n,
-    };
-}
-function forcedWithdrawal(id, recipient, amount) {
-    return {
-        to: COMPACT_ADDRESS,
-        data: (0, viem_1.encodeFunctionData)({
-            abi: [
-                {
-                    type: 'function',
-                    name: 'forcedWithdrawal',
-                    inputs: [
-                        { name: 'id', type: 'uint256', internalType: 'uint256' },
-                        { name: 'recipient', type: 'address', internalType: 'address' },
-                        { name: 'amount', type: 'uint256', internalType: 'uint256' },
-                    ],
-                    outputs: [{ name: '', type: 'bool', internalType: 'bool' }],
-                    stateMutability: 'nonpayable',
-                },
-            ],
-            functionName: 'forcedWithdrawal',
-            args: [id, recipient, amount],
-        }),
-        value: 0n,
-    };
-}
-function approveErc20(tokenAddress, amount) {
-    return {
-        to: tokenAddress,
-        value: 0n,
-        data: (0, viem_1.encodeFunctionData)({
-            abi: viem_1.erc20Abi,
-            functionName: 'approve',
-            args: [COMPACT_ADDRESS, amount],
-        }),
-    };
-}
-function toCompactFlag(allocator) {
-    const addrBytes = Buffer.from(allocator.slice(2), 'hex');
-    let leadingZeroNibbles = 0;
-    for (const byte of addrBytes) {
-        if (byte === 0) {
-            leadingZeroNibbles += 2;
-        }
-        else {
-            if (byte >> 4 === 0)
-                leadingZeroNibbles += 1;
-            break;
-        }
-    }
-    if (leadingZeroNibbles >= 18)
-        return 15;
-    if (leadingZeroNibbles >= 4)
-        return leadingZeroNibbles - 3;
-    return 0;
-}
-function usingAllocatorId(allocator = ALLOCATOR_ADDRESS) {
-    const compactFlag = BigInt(toCompactFlag(allocator));
-    const last88Bits = BigInt(`0x${allocator.slice(-22)}`); // Extract last 88 bits (11 bytes * 2 hex chars per byte)
-    return (compactFlag << 88n) | last88Bits;
-}
-function lockTag() {
-    const allocatorId = usingAllocatorId(ALLOCATOR_ADDRESS);
-    const tagBig = (BigInt(DEFAULT_SCOPE) << 255n) |
-        (BigInt(DEFAULT_RESET_PERIOD) << 252n) |
-        (allocatorId << 160n);
-    const hex = tagBig.toString(16).slice(0, 24);
-    return `0x${hex}`;
-}
 // Define the typed data structure as const to preserve type safety
 const COMPACT_TYPED_DATA_TYPES = {
     MultichainCompact: [

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

@@ -14,14 +14,7 @@ declare class ExecutionError extends Error {
     get errorType(): string;
     get traceId(): string;
 }
-declare class SourceChainsNotAvailableForUserOpFlowError extends ExecutionError {
-    constructor(params?: {
-        context?: any;
-        errorType?: string;
-        traceId?: string;
-    });
-}
-declare class UserOperationRequiredForSmartSessionsError extends ExecutionError {
+declare class SignerNotSupportedError extends ExecutionError {
     constructor(params?: {
         context?: any;
         errorType?: string;
@@ -42,13 +35,6 @@ declare class SessionChainRequiredError extends ExecutionError {
         traceId?: string;
     });
 }
-declare class SimulationNotSupportedForUserOpFlowError extends ExecutionError {
-    constructor(params?: {
-        context?: any;
-        errorType?: string;
-        traceId?: string;
-    });
-}
 declare class IntentFailedError extends ExecutionError {
     constructor(params?: {
         context?: any;
@@ -57,5 +43,5 @@ declare class IntentFailedError extends ExecutionError {
     });
 }
 declare function isExecutionError(error: Error): error is ExecutionError;
-export { isExecutionError, ExecutionError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError, OrderPathRequiredForIntentsError, SessionChainRequiredError, IntentFailedError, SimulationNotSupportedForUserOpFlowError, };
+export { isExecutionError, ExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, IntentFailedError, SignerNotSupportedError, };
 //# sourceMappingURL=error.d.ts.map

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

@@ -1 +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,0CAA2C,SAAQ,cAAc;gBACzD,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,0CAA2C,SAAQ,cAAc;gBACzD,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,wCAAyC,SAAQ,cAAc;gBACvD,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,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,iBAAS,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,cAAc,CAE/D;AAED,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,0CAA0C,EAC1C,0CAA0C,EAC1C,gCAAgC,EAChC,yBAAyB,EACzB,iBAAiB,EACjB,wCAAwC,GACzC,CAAA"}
+{"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,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,iBAAS,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,cAAc,CAE/D;AAED,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,gCAAgC,EAChC,yBAAyB,EACzB,iBAAiB,EACjB,uBAAuB,GACxB,CAAA"}

package/dist/src/execution/error.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimulationNotSupportedForUserOpFlowError = exports.IntentFailedError = exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.UserOperationRequiredForSmartSessionsError = exports.SourceChainsNotAvailableForUserOpFlowError = exports.ExecutionError = void 0;
+exports.SignerNotSupportedError = exports.IntentFailedError = exports.SessionChainRequiredError = exports.OrderPathRequiredForIntentsError = exports.ExecutionError = void 0;
 exports.isExecutionError = isExecutionError;
 class ExecutionError extends Error {
     _message;
@@ -28,24 +28,15 @@ class ExecutionError extends Error {
     }
 }
 exports.ExecutionError = ExecutionError;
-class SourceChainsNotAvailableForUserOpFlowError extends ExecutionError {
+class SignerNotSupportedError extends ExecutionError {
     constructor(params) {
         super({
-            message: "Can't specify the source chains when using user operations",
+            message: 'Sending a transaction is not supported for this type of signers. Use user operations instead.',
             ...params,
         });
     }
 }
-exports.SourceChainsNotAvailableForUserOpFlowError = SourceChainsNotAvailableForUserOpFlowError;
-class UserOperationRequiredForSmartSessionsError extends ExecutionError {
-    constructor(params) {
-        super({
-            message: 'User operation is required when using smart sessions',
-            ...params,
-        });
-    }
-}
-exports.UserOperationRequiredForSmartSessionsError = UserOperationRequiredForSmartSessionsError;
+exports.SignerNotSupportedError = SignerNotSupportedError;
 class OrderPathRequiredForIntentsError extends ExecutionError {
     constructor(params) {
         super({
@@ -64,15 +55,6 @@ class SessionChainRequiredError extends ExecutionError {
     }
 }
 exports.SessionChainRequiredError = SessionChainRequiredError;
-class SimulationNotSupportedForUserOpFlowError extends ExecutionError {
-    constructor(params) {
-        super({
-            message: 'Simulation not supported for user operation flow',
-            ...params,
-        });
-    }
-}
-exports.SimulationNotSupportedForUserOpFlowError = SimulationNotSupportedForUserOpFlowError;
 class IntentFailedError extends ExecutionError {
     constructor(params) {
         super({

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

@@ -1,36 +1,35 @@
-import { type Address, type Chain } from 'viem';
-import type { IntentOpStatus } from '../orchestrator';
+import { type Address, type Chain, type Hex } from 'viem';
+import type { UserOperationReceipt } from 'viem/_types/account-abstraction';
 import type { SettlementLayer } from '../orchestrator/types';
-import type { CallInput, RhinestoneAccountConfig, SignerSet, SourceAssetInput, TokenRequest, TokenSymbol, Transaction } from '../types';
-import { ExecutionError, IntentFailedError, isExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SimulationNotSupportedForUserOpFlowError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError } from './error';
-import type { IntentData, TransactionResult } from './utils';
+import type { CalldataInput, CallInput, RhinestoneAccountConfig, RhinestoneConfig, SignerSet, SourceAssetInput, TokenRequest, TokenSymbol, Transaction, UserOperationTransaction } from '../types';
+import { ExecutionError, IntentFailedError, 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 sendTransactionInternal(config: RhinestoneAccountConfig, sourceChains: Chain[], targetChain: Chain, callInputs: CallInput[], options: {
+declare function sendUserOperation(config: RhinestoneAccountConfig, transaction: UserOperationTransaction): Promise<UserOperationResult>;
+declare function sendTransactionInternal(config: RhinestoneConfig, sourceChains: Chain[], targetChain: Chain, callInputs: CallInput[], options: {
     gasLimit?: bigint;
     initialTokenRequests?: TokenRequest[];
     signers?: SignerSet;
     sponsored?: boolean;
     settlementLayers?: SettlementLayer[];
     sourceAssets?: SourceAssetInput;
-    asUserOp?: boolean;
     lockFunds?: boolean;
     feeAsset?: Address | TokenSymbol;
 }): Promise<TransactionResult>;
-declare function waitForExecution(config: RhinestoneAccountConfig, result: TransactionResult, acceptsPreconfirmations: boolean): Promise<IntentOpStatus | {
-    actualGasCost: bigint;
-    actualGasUsed: bigint;
-    entryPoint: Address;
-    logs: import("viem").Log<bigint, number, false>[];
-    nonce: bigint;
-    paymaster?: `0x${string}` | undefined;
-    reason?: string | undefined | undefined;
-    receipt: import("viem").TransactionReceipt<bigint, number, "success" | "reverted">;
-    sender: Address;
-    success: boolean;
-    userOpHash: import("viem").Hash;
-}>;
-declare function getMaxSpendableAmount(config: RhinestoneAccountConfig, chain: Chain, tokenAddress: Address, gasUnits: bigint, sponsored?: boolean): Promise<bigint>;
-declare function getPortfolio(config: RhinestoneAccountConfig, onTestnets: boolean): Promise<import("../orchestrator").Portfolio>;
-export { sendTransaction, sendTransactionInternal, waitForExecution, getMaxSpendableAmount, getPortfolio, isExecutionError, ExecutionError, IntentFailedError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SimulationNotSupportedForUserOpFlowError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError, };
-export type { IntentData, 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, tokenAddress: Address, gasUnits: bigint, sponsored?: boolean): Promise<bigint>;
+declare function getPortfolio(config: RhinestoneConfig, onTestnets: boolean): Promise<import("../orchestrator").Portfolio>;
+export { sendTransaction, sendTransactionInternal, sendUserOperation, sendUserOperationInternal, waitForExecution, getMaxSpendableAmount, getPortfolio, isExecutionError, ExecutionError, IntentFailedError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError, };
+export type { TransactionStatus, TransactionResult, UserOperationResult };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../execution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,EAAsB,MAAM,MAAM,CAAA;AAKnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAQrD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EACV,SAAS,EACT,uBAAuB,EACvB,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,WAAW,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,gCAAgC,EAChC,yBAAyB,EACzB,wCAAwC,EACxC,0CAA0C,EAC1C,0CAA0C,EAC3C,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAc5D,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BAiCzB;AAED,iBAAe,uBAAuB,CACpC,MAAM,EAAE,uBAAuB,EAC/B,YAAY,EAAE,KAAK,EAAE,EACrB,WAAW,EAAE,KAAK,EAClB,UAAU,EAAE,SAAS,EAAE,EACvB,OAAO,EAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oBAAoB,CAAC,EAAE,YAAY,EAAE,CAAA;IACrC,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAA;IACpC,YAAY,CAAC,EAAE,gBAAgB,CAAA;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,QAAQ,CAAC,EAAE,OAAO,GAAG,WAAW,CAAA;CACjC,8BA4CF;AA+FD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,iBAAiB,EACzB,uBAAuB,EAAE,OAAO;;;;;;;;;;;;GAyCjC;AAED,iBAAe,qBAAqB,CAClC,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,OAAe,GACzB,OAAO,CAAC,MAAM,CAAC,CAcjB;AAED,iBAAe,YAAY,CACzB,MAAM,EAAE,uBAAuB,EAC/B,UAAU,EAAE,OAAO,gDAUpB;AAED,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,EAEZ,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,gCAAgC,EAChC,yBAAyB,EACzB,wCAAwC,EACxC,0CAA0C,EAC1C,0CAA0C,GAC3C,CAAA;AACD,YAAY,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../execution/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,KAAK,EAAsB,KAAK,GAAG,EAAE,MAAM,MAAM,CAAA;AAC7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAA;AAY3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,KAAK,EACV,aAAa,EACb,SAAS,EACT,uBAAuB,EACvB,gBAAgB,EAChB,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,WAAW,EACX,wBAAwB,EACzB,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,gCAAgC,EAChC,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAerE,UAAU,iBAAiB;IACzB,IAAI,EAAE;QACJ,IAAI,EAAE,GAAG,GAAG,SAAS,CAAA;QACrB,OAAO,EAAE,MAAM,CAAA;KAChB,CAAA;IACD,MAAM,EAAE;QACN,IAAI,EAAE,GAAG,GAAG,SAAS,CAAA;QACrB,OAAO,EAAE,MAAM,CAAA;KAChB,EAAE,CAAA;CACJ;AAED,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BAsCzB;AAED,iBAAe,iBAAiB,CAC9B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,wBAAwB,gCAqBtC;AAED,iBAAe,uBAAuB,CACpC,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,KAAK,EAAE,EACrB,WAAW,EAAE,KAAK,EAClB,UAAU,EAAE,SAAS,EAAE,EACvB,OAAO,EAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,oBAAoB,CAAC,EAAE,YAAY,EAAE,CAAA;IACrC,OAAO,CAAC,EAAE,SAAS,CAAA;IACnB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAA;IACpC,YAAY,CAAC,EAAE,gBAAgB,CAAA;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,QAAQ,CAAC,EAAE,OAAO,GAAG,WAAW,CAAA;CACjC,8BAqCF;AAED,iBAAe,yBAAyB,CACtC,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE,aAAa,EAAE,EAC3B,OAAO,CAAC,EAAE,SAAS,gCAgCpB;AAsDD,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,iBAAiB,GAAG,mBAAmB,EAC/C,uBAAuB,EAAE,OAAO,GAC/B,OAAO,CAAC,iBAAiB,GAAG,oBAAoB,CAAC,CAiDnD;AAED,iBAAe,qBAAqB,CAClC,MAAM,EAAE,gBAAgB,EACxB,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,OAAe,GACzB,OAAO,CAAC,MAAM,CAAC,CAcjB;AAED,iBAAe,YAAY,CAAC,MAAM,EAAE,gBAAgB,EAAE,UAAU,EAAE,OAAO,gDASxE;AAED,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,iBAAiB,EACjB,yBAAyB,EACzB,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,EAEZ,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,gCAAgC,EAChC,yBAAyB,EACzB,uBAAuB,GACxB,CAAA;AACD,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,CAAA"}