@rhinestone/sdk 1.0.41-alpha.0 → 1.0.41

package/dist/src/actions/recovery.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enable = enable;
+exports.recoverEcdsaOwnership = recoverEcdsaOwnership;
+exports.recoverPasskeyOwnership = recoverPasskeyOwnership;
+const viem_1 = require("viem");
+const accounts_1 = require("../accounts");
+const json_rpc_1 = require("../accounts/json-rpc");
+const utils_1 = require("../execution/utils");
+const core_1 = require("../modules/validators/core");
+const ecdsa_1 = require("./ecdsa");
+const passkeys_1 = require("./passkeys");
+/**
+ * Set up social recovery
+ * @param guardians Guardians to use for recovery
+ * @param threshold Threshold for the guardians
+ * @returns Calls to set up social recovery
+ */
+function enable(guardians, threshold = 1) {
+    const module = (0, core_1.getSocialRecoveryValidator)(guardians, threshold);
+    return {
+        async resolve({ config }) {
+            return (0, accounts_1.getModuleInstallationCalls)(config, module);
+        },
+    };
+}
+/**
+ * Recover an account's ownership (ECDSA)
+ * @param address Account address
+ * @param newOwners New owners
+ * @param chain Chain to recover ownership on
+ * @param provider Provider to use for the recovery
+ * @returns Calls to recover ownership
+ */
+async function recoverEcdsaOwnership(address, newOwners, chain, config) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, json_rpc_1.createTransport)(chain, config.provider),
+    });
+    // Read the existing config
+    const results = await publicClient.multicall({
+        contracts: [
+            {
+                address: core_1.OWNABLE_VALIDATOR_ADDRESS,
+                abi: [
+                    {
+                        inputs: [
+                            { internalType: 'address', name: 'account', type: 'address' },
+                        ],
+                        name: 'getOwners',
+                        outputs: [
+                            {
+                                internalType: 'address[]',
+                                name: 'ownersArray',
+                                type: 'address[]',
+                            },
+                        ],
+                        stateMutability: 'view',
+                        type: 'function',
+                    },
+                ],
+                functionName: 'getOwners',
+                args: [address],
+            },
+            {
+                address: core_1.OWNABLE_VALIDATOR_ADDRESS,
+                abi: [
+                    {
+                        inputs: [
+                            { internalType: 'address', name: 'account', type: 'address' },
+                        ],
+                        name: 'threshold',
+                        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+                        stateMutability: 'view',
+                        type: 'function',
+                    },
+                ],
+                functionName: 'threshold',
+                args: [address],
+            },
+        ],
+    });
+    const existingOwnersResult = results[0];
+    const existingThresholdResult = results[1];
+    if (existingOwnersResult.error || existingThresholdResult.error) {
+        throw new Error('Failed to read existing owners or threshold');
+    }
+    const existingOwners = existingOwnersResult.result;
+    const existingThreshold = existingThresholdResult.result;
+    const normalizedExistingOwners = existingOwners.map((owner) => owner.toLowerCase());
+    const callInputs = [];
+    // Convert new owners config to addresses and threshold
+    const newOwnerAddresses = newOwners.accounts
+        .map((account) => account.address.toLowerCase())
+        .sort();
+    const newThreshold = newOwners.threshold ?? 1;
+    // Check if threshold needs to be updated
+    if (Number(existingThreshold) !== newThreshold) {
+        callInputs.push((0, ecdsa_1.changeThreshold)(newThreshold));
+    }
+    const ownersToAdd = newOwnerAddresses.filter((owner) => !normalizedExistingOwners.includes(owner));
+    const ownersToRemove = normalizedExistingOwners.filter((owner) => !newOwnerAddresses.includes(owner));
+    // Maintain the list as making changes to keep track of the previous owner for removals
+    // Note: new owners are added to the START of the linked list
+    let currentOwners = [...normalizedExistingOwners];
+    for (const owner of ownersToAdd) {
+        callInputs.push((0, ecdsa_1.addOwner)(owner));
+        currentOwners.unshift(owner);
+    }
+    for (const ownerToRemove of ownersToRemove) {
+        const ownerIndex = currentOwners.indexOf(ownerToRemove);
+        let prevOwner;
+        if (ownerIndex === 0) {
+            // If it's the first owner, use the sentinel address
+            prevOwner = '0x0000000000000000000000000000000000000001';
+        }
+        else {
+            prevOwner = currentOwners[ownerIndex - 1];
+        }
+        callInputs.push((0, ecdsa_1.removeOwner)(prevOwner, ownerToRemove));
+        currentOwners = currentOwners.filter((owner) => owner !== ownerToRemove);
+    }
+    const calls = await (0, utils_1.resolveCallInputs)(callInputs, config, chain, address);
+    return calls;
+}
+/**
+ * Recover an account's ownership (Passkey)
+ * @param address Account address
+ * @param oldCredentials Old credentials to be replaced (with pubKeyX, pubKeyY)
+ * @param newOwners New passkey owners
+ * @param chain Chain to recover ownership on
+ * @param provider Provider to use for the recovery
+ * @returns Calls to recover ownership
+ */
+async function recoverPasskeyOwnership(address, oldCredentials, newOwners, chain, config) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, json_rpc_1.createTransport)(chain, config.provider),
+    });
+    const existingThreshold = await publicClient.readContract({
+        address: core_1.WEBAUTHN_VALIDATOR_ADDRESS,
+        abi: [
+            {
+                inputs: [{ internalType: 'address', name: 'account', type: 'address' }],
+                name: 'threshold',
+                outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+                stateMutability: 'view',
+                type: 'function',
+            },
+        ],
+        functionName: 'threshold',
+        args: [address],
+    });
+    const callInputs = [];
+    // Convert new owners config to credentials and threshold
+    const newCredentials = newOwners.accounts.map((account) => {
+        const publicKey = account.publicKey;
+        // Parse the public key hex string to extract x and y coordinates
+        const publicKeyBytes = publicKey.startsWith('0x')
+            ? publicKey.slice(2)
+            : publicKey;
+        // The public key is 64 bytes: 32 bytes for x, 32 bytes for y
+        const x = BigInt(`0x${publicKeyBytes.slice(0, 64)}`);
+        const y = BigInt(`0x${publicKeyBytes.slice(64, 128)}`);
+        return {
+            pubKeyX: x,
+            pubKeyY: y,
+            requireUV: false, // Default to false for now
+        };
+    });
+    const newThreshold = newOwners.threshold ?? 1;
+    // Check if threshold needs to be updated
+    if (Number(existingThreshold) !== newThreshold) {
+        callInputs.push((0, passkeys_1.changeThreshold)(newThreshold));
+    }
+    // Compare existing and new credentials to determine what to add/remove
+    const existingCredentialKeys = oldCredentials.map((cred) => `${cred.pubKeyX.toString()}-${cred.pubKeyY.toString()}`);
+    const newCredentialKeys = newCredentials.map((cred) => `${cred.pubKeyX.toString()}-${cred.pubKeyY.toString()}`);
+    // Find credentials to add (new ones not in existing)
+    const credentialsToAdd = newCredentials.filter((cred) => !existingCredentialKeys.includes(`${cred.pubKeyX.toString()}-${cred.pubKeyY.toString()}`));
+    // Find credentials to remove (existing ones not in new)
+    const credentialsToRemove = oldCredentials.filter((cred) => !newCredentialKeys.includes(`${cred.pubKeyX.toString()}-${cred.pubKeyY.toString()}`));
+    // Remove old credentials first (important for security in recovery scenarios)
+    for (const credential of credentialsToRemove) {
+        callInputs.push((0, passkeys_1.removeOwner)(credential.pubKeyX, credential.pubKeyY));
+    }
+    // Then add new credentials
+    for (const credential of credentialsToAdd) {
+        callInputs.push((0, passkeys_1.addOwner)(credential.pubKeyX, credential.pubKeyY, credential.requireUV));
+    }
+    const calls = await (0, utils_1.resolveCallInputs)(callInputs, config, chain, address);
+    return calls;
+}

package/dist/src/actions/recovery.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=recovery.test.d.ts.map

package/dist/src/actions/recovery.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.test.d.ts","sourceRoot":"","sources":["../../../actions/recovery.test.ts"],"names":[],"mappings":""}

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-sessions.d.ts

@@ -0,0 +1,14 @@
+import type { Session } from '../types';
+/**
+ * Enable a smart session
+ * @param session session to enable
+ * @returns Calls to enable the smart session
+ */
+declare function enableSession(session: Session): {
+    resolve(): Promise<{
+        to: `0x${string}`;
+        data: `0x${string}`;
+    }>;
+};
+export { enableSession };
+//# sourceMappingURL=smart-sessions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../actions/smart-sessions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAEvC;;;;GAIG;AACH,iBAAS,aAAa,CAAC,OAAO,EAAE,OAAO;;;;;EAMtC;AAED,OAAO,EAAE,aAAa,EAAE,CAAA"}

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableSession = enableSession;
+const smart_sessions_1 = require("../modules/validators/smart-sessions");
+/**
+ * Enable a smart session
+ * @param session session to enable
+ * @returns Calls to enable the smart session
+ */
+function enableSession(session) {
+    return {
+        async resolve() {
+            return (0, smart_sessions_1.getEnableSessionCall)(session);
+        },
+    };
+}

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

@@ -0,0 +1,5 @@
+import { AccountConfigurationNotSupportedError, AccountError, Eip712DomainNotAvailableError, Eip7702AccountMustHaveEoaError, Eip7702NotSupportedForAccountError, EoaAccountMustHaveAccountError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, isAccountError, SigningNotSupportedForAccountError, SmartSessionsNotEnabledError, WalletClientNoConnectedAccountError } from '../accounts';
+import { ExecutionError, IntentFailedError, isExecutionError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError } from '../execution';
+import { AuthenticationRequiredError, BadRequestError, BodyParserError, ConflictError, ForbiddenError, InsufficientBalanceError, IntentNotFoundError, InternalServerError, InvalidApiKeyError, InvalidIntentSignatureError, isAuthError, isOrchestratorError, isRateLimited, isRetryable, isValidationError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, RateLimitedError, ResourceNotFoundError, SchemaValidationError, ServiceUnavailableError, SimulationFailedError, TokenNotSupportedError, UnauthorizedError, UnprocessableEntityError, UnsupportedChainError, UnsupportedChainIdError, UnsupportedTokenError } from '../orchestrator';
+export { isAccountError, AccountError, AccountConfigurationNotSupportedError, Eip712DomainNotAvailableError, Eip7702AccountMustHaveEoaError, EoaAccountMustHaveAccountError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, SmartSessionsNotEnabledError, SigningNotSupportedForAccountError, Eip7702NotSupportedForAccountError, WalletClientNoConnectedAccountError, isExecutionError, ExecutionError, IntentFailedError, OrderPathRequiredForIntentsError, SessionChainRequiredError, SignerNotSupportedError, isOrchestratorError, isRetryable, isAuthError, isValidationError, isRateLimited, AuthenticationRequiredError, BadRequestError, BodyParserError, ConflictError, ForbiddenError, InsufficientBalanceError, InvalidApiKeyError, InvalidIntentSignatureError, NoPathFoundError, OnlyOneTargetTokenAmountCanBeUnsetError, OrchestratorError, IntentNotFoundError, InternalServerError, ResourceNotFoundError, RateLimitedError, SchemaValidationError, ServiceUnavailableError, SimulationFailedError, UnprocessableEntityError, UnauthorizedError, 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,6BAA6B,EAC7B,8BAA8B,EAC9B,kCAAkC,EAClC,8BAA8B,EAC9B,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,eAAe,EACf,eAAe,EACf,aAAa,EACb,cAAc,EACd,wBAAwB,EACxB,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,2BAA2B,EAC3B,WAAW,EACX,mBAAmB,EACnB,aAAa,EACb,WAAW,EACX,iBAAiB,EACjB,gBAAgB,EAChB,uCAAuC,EACvC,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACrB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,sBAAsB,EACtB,iBAAiB,EACjB,wBAAwB,EACxB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,iBAAiB,CAAA;AAExB,OAAO,EAEL,cAAc,EACd,YAAY,EACZ,qCAAqC,EACrC,6BAA6B,EAC7B,8BAA8B,EAC9B,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,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,aAAa,EACb,2BAA2B,EAC3B,eAAe,EACf,eAAe,EACf,aAAa,EACb,cAAc,EACd,wBAAwB,EACxB,kBAAkB,EAClB,2BAA2B,EAC3B,gBAAgB,EAChB,uCAAuC,EACvC,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,EACrB,wBAAwB,EACxB,iBAAiB,EACjB,sBAAsB,EACtB,qBAAqB,EACrB,uBAAuB,EACvB,qBAAqB,GACtB,CAAA"}

package/dist/src/errors/index.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedTokenError = exports.UnsupportedChainIdError = exports.UnsupportedChainError = exports.TokenNotSupportedError = exports.UnauthorizedError = exports.UnprocessableEntityError = exports.SimulationFailedError = exports.ServiceUnavailableError = exports.SchemaValidationError = exports.RateLimitedError = exports.ResourceNotFoundError = exports.InternalServerError = exports.IntentNotFoundError = exports.OrchestratorError = exports.OnlyOneTargetTokenAmountCanBeUnsetError = exports.NoPathFoundError = exports.InvalidIntentSignatureError = exports.InvalidApiKeyError = exports.InsufficientBalanceError = exports.ForbiddenError = exports.ConflictError = exports.BodyParserError = exports.BadRequestError = exports.AuthenticationRequiredError = exports.isRateLimited = exports.isValidationError = exports.isAuthError = exports.isRetryable = 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.EoaAccountMustHaveAccountError = exports.Eip7702AccountMustHaveEoaError = exports.Eip712DomainNotAvailableError = 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, "Eip712DomainNotAvailableError", { enumerable: true, get: function () { return accounts_1.Eip712DomainNotAvailableError; } });
+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, "EoaAccountMustHaveAccountError", { enumerable: true, get: function () { return accounts_1.EoaAccountMustHaveAccountError; } });
+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, "BadRequestError", { enumerable: true, get: function () { return orchestrator_1.BadRequestError; } });
+Object.defineProperty(exports, "BodyParserError", { enumerable: true, get: function () { return orchestrator_1.BodyParserError; } });
+Object.defineProperty(exports, "ConflictError", { enumerable: true, get: function () { return orchestrator_1.ConflictError; } });
+Object.defineProperty(exports, "ForbiddenError", { enumerable: true, get: function () { return orchestrator_1.ForbiddenError; } });
+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, "InternalServerError", { enumerable: true, get: function () { return orchestrator_1.InternalServerError; } });
+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, "isAuthError", { enumerable: true, get: function () { return orchestrator_1.isAuthError; } });
+Object.defineProperty(exports, "isOrchestratorError", { enumerable: true, get: function () { return orchestrator_1.isOrchestratorError; } });
+Object.defineProperty(exports, "isRateLimited", { enumerable: true, get: function () { return orchestrator_1.isRateLimited; } });
+Object.defineProperty(exports, "isRetryable", { enumerable: true, get: function () { return orchestrator_1.isRetryable; } });
+Object.defineProperty(exports, "isValidationError", { enumerable: true, get: function () { return orchestrator_1.isValidationError; } });
+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, "RateLimitedError", { enumerable: true, get: function () { return orchestrator_1.RateLimitedError; } });
+Object.defineProperty(exports, "ResourceNotFoundError", { enumerable: true, get: function () { return orchestrator_1.ResourceNotFoundError; } });
+Object.defineProperty(exports, "SchemaValidationError", { enumerable: true, get: function () { return orchestrator_1.SchemaValidationError; } });
+Object.defineProperty(exports, "ServiceUnavailableError", { enumerable: true, get: function () { return orchestrator_1.ServiceUnavailableError; } });
+Object.defineProperty(exports, "SimulationFailedError", { enumerable: true, get: function () { return orchestrator_1.SimulationFailedError; } });
+Object.defineProperty(exports, "TokenNotSupportedError", { enumerable: true, get: function () { return orchestrator_1.TokenNotSupportedError; } });
+Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return orchestrator_1.UnauthorizedError; } });
+Object.defineProperty(exports, "UnprocessableEntityError", { enumerable: true, get: function () { return orchestrator_1.UnprocessableEntityError; } });
+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

@@ -0,0 +1,151 @@
+import { type Hex } from 'viem';
+import type { IntentOp, IntentOpElement } from '../orchestrator/types';
+declare const COMPACT_ADDRESS = "0x00000000000000171ede64904551eeDF3C6C9788";
+declare function getCompactTypedData(intentOp: IntentOp): {
+    readonly domain: {
+        readonly name: "The Compact";
+        readonly version: "1";
+        readonly chainId: number;
+        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(element: IntentOpElement, nonce: bigint, expires: bigint): Hex;
+export { COMPACT_ADDRESS, getCompactTypedData, getCompactDigest, getPermit2Digest, };
+//# sourceMappingURL=compact.d.ts.map

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

@@ -0,0 +1 @@
+{"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,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAGtE,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,CACvB,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GACd,GAAG,CAGL;AAED,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,gBAAgB,GACjB,CAAA"}