@rhinestone/sdk 1.0.0-alpha.9 → 1.0.0-beta.38

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/actions/smart-session.d.ts

@@ -1,5 +1,11 @@
 import type { Hex } from 'viem';
 import type { SessionDetails } from '../execution/smart-session';
+/**
+ * Encode a smart session signature
+ * @param sessionDetails Session details
+ * @param sessionSignature Session signature
+ * @returns Encoded smart session signature
+ */
 declare function encodeSmartSessionSignature(sessionDetails: SessionDetails, sessionSignature: Hex): `0x${string}`;
 export { encodeSmartSessionSignature };
 //# sourceMappingURL=smart-session.d.ts.map

package/dist/src/actions/smart-session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"smart-session.d.ts","sourceRoot":"","sources":["../../../actions/smart-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAGhE,iBAAS,2BAA2B,CAClC,cAAc,EAAE,cAAc,EAC9B,gBAAgB,EAAE,GAAG,iBAQtB;AAED,OAAO,EAAE,2BAA2B,EAAE,CAAA"}
+{"version":3,"file":"smart-session.d.ts","sourceRoot":"","sources":["../../../actions/smart-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAGhE;;;;;GAKG;AACH,iBAAS,2BAA2B,CAClC,cAAc,EAAE,cAAc,EAC9B,gBAAgB,EAAE,GAAG,iBAQtB;AAED,OAAO,EAAE,2BAA2B,EAAE,CAAA"}

package/dist/src/actions/smart-session.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.encodeSmartSessionSignature = encodeSmartSessionSignature;
 const smart_sessions_1 = require("../modules/validators/smart-sessions");
+/**
+ * Encode a smart session signature
+ * @param sessionDetails Session details
+ * @param sessionSignature Session signature
+ * @returns Encoded smart session signature
+ */
 function encodeSmartSessionSignature(sessionDetails, sessionSignature) {
     return (0, smart_sessions_1.encodeSmartSessionSignature)(sessionDetails.mode, sessionDetails.enableSessionData.permissionId, sessionSignature, sessionDetails.enableSessionData);
 }

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,8 +1,151 @@
-import { type Address } from 'viem';
-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;
-export { COMPACT_ADDRESS, getDepositEtherCall, getDepositErc20Call, getApproveErc20Call, };
+import { type Hex } from 'viem';
+import type { IntentOp } from '../orchestrator/types';
+declare const COMPACT_ADDRESS = "0x73d2dc0c21fca4ec1601895d50df7f5624f07d3f";
+declare function getCompactTypedData(intentOp: IntentOp): {
+    readonly domain: {
+        readonly name: "The Compact";
+        readonly version: "1";
+        readonly chainId: bigint;
+        readonly verifyingContract: "0x73d2dc0c21fca4ec1601895d50df7f5624f07d3f";
+    };
+    readonly types: {
+        readonly MultichainCompact: readonly [{
+            readonly name: "sponsor";
+            readonly type: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "expires";
+            readonly type: "uint256";
+        }, {
+            readonly name: "elements";
+            readonly type: "Element[]";
+        }];
+        readonly Element: readonly [{
+            readonly name: "arbiter";
+            readonly type: "address";
+        }, {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly name: "commitments";
+            readonly type: "Lock[]";
+        }, {
+            readonly name: "mandate";
+            readonly type: "Mandate";
+        }];
+        readonly Lock: readonly [{
+            readonly name: "lockTag";
+            readonly type: "bytes12";
+        }, {
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        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[]";
+        }, {
+            readonly name: "destOps";
+            readonly type: "Op[]";
+        }, {
+            readonly name: "q";
+            readonly type: "bytes32";
+        }];
+        readonly Target: readonly [{
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "tokenOut";
+            readonly type: "Token[]";
+        }, {
+            readonly name: "targetChain";
+            readonly type: "uint256";
+        }, {
+            readonly name: "fillExpiry";
+            readonly type: "uint256";
+        }];
+        readonly Token: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+        readonly Op: readonly [{
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+    };
+    readonly primaryType: "MultichainCompact";
+    readonly message: {
+        readonly sponsor: `0x${string}`;
+        readonly nonce: bigint;
+        readonly expires: bigint;
+        readonly elements: {
+            arbiter: `0x${string}`;
+            chainId: bigint;
+            commitments: {
+                lockTag: `0x${string}`;
+                token: `0x${string}`;
+                amount: bigint;
+            }[];
+            mandate: {
+                target: {
+                    recipient: `0x${string}`;
+                    tokenOut: {
+                        token: `0x${string}`;
+                        amount: bigint;
+                    }[];
+                    targetChain: bigint;
+                    fillExpiry: bigint;
+                };
+                v: number;
+                minGas: bigint;
+                originOps: {
+                    to: `0x${string}`;
+                    value: bigint;
+                    data: `0x${string}`;
+                }[];
+                destOps: {
+                    to: `0x${string}`;
+                    value: bigint;
+                    data: `0x${string}`;
+                }[];
+                q: `0x${string}`;
+            };
+        }[];
+    };
+};
+/**
+ * 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,EAAE,KAAK,OAAO,EAA0C,MAAM,MAAM,CAAA;AAC3E,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;AAoCD,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,GACpB,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,105 +1,122 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMPACT_ADDRESS = void 0;
-exports.getDepositEtherCall = getDepositEtherCall;
-exports.getDepositErc20Call = getDepositErc20Call;
-exports.getApproveErc20Call = getApproveErc20Call;
+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',
+// Define the typed data structure as const to preserve type safety
+const COMPACT_TYPED_DATA_TYPES = {
+    MultichainCompact: [
+        { name: 'sponsor', type: 'address' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'expires', type: 'uint256' },
+        { name: 'elements', type: 'Element[]' },
+    ],
+    Element: [
+        { name: 'arbiter', type: 'address' },
+        { name: 'chainId', type: 'uint256' },
+        { name: 'commitments', type: 'Lock[]' },
+        { name: 'mandate', type: 'Mandate' },
+    ],
+    Lock: [
+        { name: 'lockTag', type: 'bytes12' },
+        { name: 'token', type: 'address' },
+        { name: 'amount', type: 'uint256' },
+    ],
+    Mandate: [
+        { name: 'target', type: 'Target' },
+        { name: 'v', type: 'uint8' },
+        { name: 'minGas', type: 'uint128' },
+        { name: 'originOps', type: 'Op[]' },
+        { name: 'destOps', type: 'Op[]' },
+        { name: 'q', type: 'bytes32' },
+    ],
+    Target: [
+        { name: 'recipient', type: 'address' },
+        { name: 'tokenOut', type: 'Token[]' },
+        { name: 'targetChain', type: 'uint256' },
+        { name: 'fillExpiry', type: 'uint256' },
+    ],
+    Token: [
+        { name: 'token', type: 'address' },
+        { name: 'amount', type: 'uint256' },
+    ],
+    Op: [
+        { name: 'to', type: 'address' },
+        { name: 'value', type: 'uint256' },
+        { name: 'data', type: 'bytes' },
+    ],
+};
+function getCompactTypedData(intentOp) {
+    const typedData = {
+        domain: {
+            name: 'The Compact',
+            version: '1',
+            chainId: BigInt(intentOp.elements[0].chainId),
+            verifyingContract: '0x73d2dc0c21fca4ec1601895d50df7f5624f07d3f',
+        },
+        types: COMPACT_TYPED_DATA_TYPES,
+        primaryType: 'MultichainCompact',
+        message: {
+            sponsor: intentOp.sponsor,
+            nonce: BigInt(intentOp.nonce),
+            expires: BigInt(intentOp.expires),
+            elements: intentOp.elements.map((element) => ({
+                arbiter: element.arbiter,
+                chainId: BigInt(element.chainId),
+                commitments: element.idsAndAmounts.map((token) => ({
+                    lockTag: (0, viem_1.slice)((0, viem_1.toHex)(BigInt(token[0])), 0, 12),
+                    token: (0, viem_1.slice)((0, viem_1.toHex)(BigInt(token[0])), 12, 32),
+                    amount: BigInt(token[1]),
+                })),
+                mandate: {
+                    target: {
+                        recipient: element.mandate.recipient,
+                        tokenOut: element.mandate.tokenOut.map((token) => ({
+                            token: (0, viem_1.slice)((0, viem_1.toHex)(BigInt(token[0])), 12, 32),
+                            amount: BigInt(token[1]),
+                        })),
+                        targetChain: BigInt(element.mandate.destinationChainId),
+                        fillExpiry: BigInt(element.mandate.fillDeadline),
+                    },
+                    v: element.mandate.v || 0,
+                    minGas: BigInt(element.mandate.minGas || '0'),
+                    originOps: element.mandate.preClaimOps.map((op) => ({
+                        to: op.to,
+                        value: BigInt(op.value),
+                        data: op.data,
+                    })),
+                    destOps: element.mandate.destinationOps.map((op) => ({
+                        to: op.to,
+                        value: BigInt(op.value),
+                        data: op.data,
+                    })),
+                    q: (0, viem_1.keccak256)(element.mandate.qualifier.encodedVal),
                 },
-            ],
-            functionName: 'depositNative',
-            args: [lockTag(), account],
-        }),
-        value,
+            })),
+        },
     };
+    return typedData;
 }
-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;
+/**
+ * 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);
 }
-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}`;
+/**
+ * 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);
 }