@charterlabs/rhinestone-sdk 0.2.7-dev.2 → 0.2.7-dev.4

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 utils_1 = require("../execution/utils");
+const index_1 = require("../index");
+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 index_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 index_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,11 +1,7 @@
-import { type Address } from 'viem';
+import { type Hex } from 'viem';
 import type { IntentOp } from '../orchestrator/types';
-import type { Call } from '../types';
-declare const COMPACT_ADDRESS = "0xa2E6C7Ba8613E1534dCB990e7e4962216C0a5d58";
-declare function getDepositEtherCall(account: Address, value: bigint): Call;
-declare function getDepositErc20Call(account: Address, tokenAddress: Address, amount: bigint): Call;
-declare function getApproveErc20Call(tokenAddress: Address, amount: bigint): Call;
-declare function getIntentData(intentOp: IntentOp): {
+declare const COMPACT_ADDRESS = "0x73d2dc0c21fca4ec1601895d50df7f5624f07d3f";
+declare function getCompactTypedData(intentOp: IntentOp): {
     readonly domain: {
         readonly name: "The Compact";
         readonly version: "1";
@@ -52,6 +48,12 @@ declare function getIntentData(intentOp: IntentOp): {
         readonly Mandate: readonly [{
             readonly name: "target";
             readonly type: "Target";
+        }, {
+            readonly name: "v";
+            readonly type: "uint8";
+        }, {
+            readonly name: "minGas";
+            readonly type: "uint128";
         }, {
             readonly name: "originOps";
             readonly type: "Op[]";
@@ -116,6 +118,8 @@ declare function getIntentData(intentOp: IntentOp): {
                     targetChain: bigint;
                     fillExpiry: bigint;
                 };
+                v: number;
+                minGas: bigint;
                 originOps: {
                     to: `0x${string}`;
                     value: bigint;
@@ -131,5 +135,17 @@ declare function getIntentData(intentOp: IntentOp): {
         }[];
     };
 };
-export { COMPACT_ADDRESS, getDepositEtherCall, getDepositErc20Call, getApproveErc20Call, getIntentData, };
+/**
+ * Get the compact digest for signing
+ * @param intentOp The intent operation
+ * @returns The digest hash
+ */
+declare function getCompactDigest(intentOp: IntentOp): Hex;
+/**
+ * Get the Permit2 digest for signing
+ * @param intentOp The intent operation
+ * @returns The digest hash
+ */
+declare function getPermit2Digest(intentOp: IntentOp): Hex;
+export { COMPACT_ADDRESS, getCompactTypedData, getCompactDigest, getPermit2Digest, };
 //# 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,EAOb,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,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAqBlE;AAED,iBAAS,mBAAmB,CAC1B,OAAO,EAAE,OAAO,EAChB,YAAY,EAAE,OAAO,EACrB,MAAM,EAAE,MAAM,GACb,IAAI,CA2BN;AAED,iBAAS,mBAAmB,CAAC,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAUxE;AA8ED,iBAAS,aAAa,CAAC,QAAQ,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiDxC;AAED,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,GACd,CAAA"}
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../execution/compact.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAA0C,MAAM,MAAM,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAGrD,QAAA,MAAM,eAAe,+CAA+C,CAAA;AA8CpE,iBAAS,mBAAmB,CAAC,QAAQ,EAAE,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmD9C;AAED;;;;GAIG;AACH,iBAAS,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,GAAG,CAGjD;AAED;;;;GAIG;AACH,iBAAS,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,GAAG,CAGjD;AAED,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,GACjB,CAAA"}

package/dist/src/execution/compact.js

@@ -1,109 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMPACT_ADDRESS = void 0;
-exports.getDepositEtherCall = getDepositEtherCall;
-exports.getDepositErc20Call = getDepositErc20Call;
-exports.getApproveErc20Call = getApproveErc20Call;
-exports.getIntentData = getIntentData;
+exports.getCompactTypedData = getCompactTypedData;
+exports.getCompactDigest = getCompactDigest;
+exports.getPermit2Digest = getPermit2Digest;
 const viem_1 = require("viem");
-const COMPACT_ADDRESS = '0xa2E6C7Ba8613E1534dCB990e7e4962216C0a5d58';
+const permit2_1 = require("./permit2");
+const COMPACT_ADDRESS = '0x73d2dc0c21fca4ec1601895d50df7f5624f07d3f';
 exports.COMPACT_ADDRESS = COMPACT_ADDRESS;
-const ALLOCATOR_ADDRESS = '0x9Ef7519F90C9B6828650Ff4913d663BB1f688507';
-const DEFAULT_RESET_PERIOD = 3;
-const DEFAULT_SCOPE = 0;
-function getDepositEtherCall(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: '', type: 'uint256', internalType: 'uint256' }],
-                    stateMutability: 'payable',
-                },
-            ],
-            functionName: 'depositNative',
-            args: [lockTag(), account],
-        }),
-        value,
-    };
-}
-function getDepositErc20Call(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 getApproveErc20Call(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: [
@@ -125,6 +29,8 @@ const COMPACT_TYPED_DATA_TYPES = {
     ],
     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' },
@@ -145,7 +51,7 @@ const COMPACT_TYPED_DATA_TYPES = {
         { name: 'data', type: 'bytes' },
     ],
 };
-function getIntentData(intentOp) {
+function getCompactTypedData(intentOp) {
     const typedData = {
         domain: {
             name: 'The Compact',
@@ -177,6 +83,8 @@ function getIntentData(intentOp) {
                         targetChain: BigInt(element.mandate.destinationChainId),
                         fillExpiry: BigInt(element.mandate.fillDeadline),
                     },
+                    v: element.mandate.v || 0,
+                    minGas: BigInt(element.mandate.minGas || '0'),
                     originOps: element.mandate.preClaimOps.map((op) => ({
                         to: op.to,
                         value: BigInt(op.value),
@@ -187,10 +95,28 @@ function getIntentData(intentOp) {
                         value: BigInt(op.value),
                         data: op.data,
                     })),
-                    q: (0, viem_1.keccak256)(element.mandate.qualifier?.encodedVal ?? '0x'),
+                    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(intentOp) {
+    const typedData = (0, permit2_1.getTypedData)(intentOp);
+    return (0, viem_1.hashTypedData)(typedData);
+}

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;
@@ -50,5 +43,5 @@ declare class IntentFailedError extends ExecutionError {
     });
 }
 declare function isExecutionError(error: Error): error is ExecutionError;
-export { isExecutionError, ExecutionError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError, OrderPathRequiredForIntentsError, SessionChainRequiredError, IntentFailedError, };
+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,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,GAClB,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.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({

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

@@ -1,24 +1,35 @@
-import { type Address, type Chain } from 'viem';
-import type { IntentOpStatus } from '../orchestrator';
-import type { RhinestoneAccountConfig, Transaction } from '../types';
-import { ExecutionError, IntentFailedError, isExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError } from './error';
-import type { IntentData, TransactionResult } from './utils';
+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 { 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 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): Promise<bigint>;
-declare function getPortfolio(config: RhinestoneAccountConfig, onTestnets: boolean): Promise<import("../orchestrator").Portfolio>;
-export { sendTransaction, waitForExecution, getMaxSpendableAmount, getPortfolio, isExecutionError, IntentFailedError, ExecutionError, SourceChainsNotAvailableForUserOpFlowError, UserOperationRequiredForSmartSessionsError, OrderPathRequiredForIntentsError, SessionChainRequiredError, };
-export type { IntentData, TransactionResult };
+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;
+    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, 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,EAAmC,MAAM,MAAM,CAAA;AAKhF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAQrD,OAAO,KAAK,EAEV,uBAAuB,EAGvB,WAAW,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,cAAc,EACd,iBAAiB,EACjB,gBAAgB,EAChB,gCAAgC,EAChC,yBAAyB,EACzB,0CAA0C,EAC1C,0CAA0C,EAC3C,MAAM,SAAS,CAAA;AAEhB,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAa5D,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,WAAW,EAAE,WAAW,8BA2BzB;AAyID,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,GACf,OAAO,CAAC,MAAM,CAAC,CAajB;AAED,iBAAe,YAAY,CACzB,MAAM,EAAE,uBAAuB,EAC/B,UAAU,EAAE,OAAO,gDAUpB;AAED,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,EAEZ,gBAAgB,EAChB,iBAAiB,EACjB,cAAc,EACd,0CAA0C,EAC1C,0CAA0C,EAC1C,gCAAgC,EAChC,yBAAyB,GAC1B,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,CAoDnD;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"}