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

package/dist/src/actions/compact.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depositEther = depositEther;
+exports.enableEtherWithdrawal = enableEtherWithdrawal;
+exports.disableEtherWithdrawal = disableEtherWithdrawal;
+exports.withdrawEther = withdrawEther;
+exports.depositErc20 = depositErc20;
+exports.enableErc20Withdrawal = enableErc20Withdrawal;
+exports.disableErc20Withdrawal = disableErc20Withdrawal;
+exports.withdrawErc20 = withdrawErc20;
+exports.approveErc20 = approveErc20;
+const viem_1 = require("viem");
+const compact_1 = require("../execution/compact");
+const ALLOCATOR_ADDRESS = '0xd93ed1dd9f1f0b523e4d77233809dc2ee22928c6';
+const DEFAULT_RESET_PERIOD = 6;
+const DEFAULT_SCOPE = 0;
+function depositEther(value) {
+    return {
+        async resolve({ accountAddress }) {
+            return {
+                to: compact_1.COMPACT_ADDRESS,
+                data: (0, viem_1.encodeFunctionData)({
+                    abi: [
+                        {
+                            type: 'function',
+                            name: 'depositNative',
+                            inputs: [
+                                { name: 'lockTag', type: 'bytes12', internalType: 'bytes12' },
+                                { name: 'recipient', type: 'address', internalType: 'address' },
+                            ],
+                            outputs: [
+                                { name: 'id', type: 'uint256', internalType: 'uint256' },
+                            ],
+                            stateMutability: 'payable',
+                        },
+                    ],
+                    functionName: 'depositNative',
+                    args: [lockTag(), accountAddress],
+                }),
+                value,
+            };
+        },
+    };
+}
+function enableEtherWithdrawal() {
+    const id = (0, viem_1.concat)([lockTag(), viem_1.zeroAddress]);
+    return enableForcedWithdrawal(BigInt(id));
+}
+function disableEtherWithdrawal() {
+    const id = (0, viem_1.concat)([lockTag(), viem_1.zeroAddress]);
+    return disableForcedWithdrawal(BigInt(id));
+}
+function withdrawEther(value) {
+    return {
+        async resolve({ accountAddress }) {
+            const id = (0, viem_1.concat)([lockTag(), viem_1.zeroAddress]);
+            return forcedWithdrawal(BigInt(id), accountAddress, value);
+        },
+    };
+}
+function depositErc20(tokenAddress, amount) {
+    return {
+        async resolve({ accountAddress }) {
+            return {
+                to: compact_1.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, accountAddress],
+                }),
+            };
+        },
+    };
+}
+function enableErc20Withdrawal(tokenAddress) {
+    const id = (0, viem_1.concat)([lockTag(), tokenAddress]);
+    return enableForcedWithdrawal(BigInt(id));
+}
+function disableErc20Withdrawal(tokenAddress) {
+    const id = (0, viem_1.concat)([lockTag(), tokenAddress]);
+    return disableForcedWithdrawal(BigInt(id));
+}
+function withdrawErc20(tokenAddress, amount) {
+    return {
+        async resolve({ accountAddress }) {
+            const id = (0, viem_1.concat)([lockTag(), tokenAddress]);
+            return forcedWithdrawal(BigInt(id), accountAddress, amount);
+        },
+    };
+}
+function enableForcedWithdrawal(id) {
+    return {
+        to: compact_1.COMPACT_ADDRESS,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    type: 'function',
+                    name: 'enableForcedWithdrawal',
+                    inputs: [{ name: 'id', type: 'uint256', internalType: 'uint256' }],
+                    outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+                    stateMutability: 'nonpayable',
+                },
+            ],
+            functionName: 'enableForcedWithdrawal',
+            args: [id],
+        }),
+        value: 0n,
+    };
+}
+function disableForcedWithdrawal(id) {
+    return {
+        to: compact_1.COMPACT_ADDRESS,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    type: 'function',
+                    name: 'disableForcedWithdrawal',
+                    inputs: [{ name: 'id', type: 'uint256', internalType: 'uint256' }],
+                    outputs: [{ name: '', type: 'uint256', internalType: 'uint256' }],
+                    stateMutability: 'nonpayable',
+                },
+            ],
+            functionName: 'disableForcedWithdrawal',
+            args: [id],
+        }),
+        value: 0n,
+    };
+}
+function forcedWithdrawal(id, recipient, amount) {
+    return {
+        to: compact_1.COMPACT_ADDRESS,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    type: 'function',
+                    name: 'forcedWithdrawal',
+                    inputs: [
+                        { name: 'id', type: 'uint256', internalType: 'uint256' },
+                        { name: 'recipient', type: 'address', internalType: 'address' },
+                        { name: 'amount', type: 'uint256', internalType: 'uint256' },
+                    ],
+                    outputs: [{ name: '', type: 'bool', internalType: 'bool' }],
+                    stateMutability: 'nonpayable',
+                },
+            ],
+            functionName: 'forcedWithdrawal',
+            args: [id, recipient, amount],
+        }),
+        value: 0n,
+    };
+}
+function approveErc20(tokenAddress, amount) {
+    return {
+        to: tokenAddress,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: viem_1.erc20Abi,
+            functionName: 'approve',
+            args: [compact_1.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}`;
+}

package/dist/src/actions/ecdsa.d.ts

@@ -0,0 +1,35 @@
+import { type Address } from 'viem';
+import type { CalldataInput, LazyCallInput } from '../types';
+/**
+ * Enable ECDSA authentication
+ * @param owners Owners to use for authentication
+ * @param threshold Threshold for the owners
+ * @returns Calls to enable ECDSA authentication
+ */
+declare function enable(owners: Address[], threshold?: number): LazyCallInput;
+/**
+ * Disable ECDSA authentication
+ * @returns Calls to disable ECDSA authentication
+ */
+declare function disable(): LazyCallInput;
+/**
+ * Add an ECDSA owner
+ * @param owner Owner address
+ * @returns Call to add the owner
+ */
+declare function addOwner(owner: Address): CalldataInput;
+/**
+ * Remove an ECDSA owner
+ * @param prevOwner Previous owner address
+ * @param ownerToRemove Owner to remove
+ * @returns Call to remove the owner
+ */
+declare function removeOwner(prevOwner: Address, ownerToRemove: Address): CalldataInput;
+/**
+ * Change an account's signer threshold (ECDSA)
+ * @param newThreshold New threshold
+ * @returns Call to change the threshold
+ */
+declare function changeThreshold(newThreshold: number): CalldataInput;
+export { addOwner, removeOwner, changeThreshold, disable, enable };
+//# sourceMappingURL=ecdsa.d.ts.map

package/dist/src/actions/ecdsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../actions/ecdsa.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAsB,MAAM,MAAM,CAAA;AASvD,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;GAKG;AACH,iBAAS,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,SAAS,SAAI,GAAG,aAAa,CAO/D;AAED;;;GAGG;AACH,iBAAS,OAAO,IAAI,aAAa,CAOhC;AAED;;;;GAIG;AACH,iBAAS,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,aAAa,CAkB/C;AAED;;;;;GAKG;AACH,iBAAS,WAAW,CAClB,SAAS,EAAE,OAAO,EAClB,aAAa,EAAE,OAAO,GACrB,aAAa,CAqBf;AAED;;;;GAIG;AACH,iBAAS,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAoB5D;AAED,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,CAAA"}

package/dist/src/actions/ecdsa.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOwner = addOwner;
+exports.removeOwner = removeOwner;
+exports.changeThreshold = changeThreshold;
+exports.disable = disable;
+exports.enable = enable;
+const viem_1 = require("viem");
+const accounts_1 = require("../accounts");
+const core_1 = require("../modules/validators/core");
+/**
+ * Enable ECDSA authentication
+ * @param owners Owners to use for authentication
+ * @param threshold Threshold for the owners
+ * @returns Calls to enable ECDSA authentication
+ */
+function enable(owners, threshold = 1) {
+    const module = (0, core_1.getOwnableValidator)(threshold, owners);
+    return {
+        async resolve({ config }) {
+            return (0, accounts_1.getModuleInstallationCalls)(config, module);
+        },
+    };
+}
+/**
+ * Disable ECDSA authentication
+ * @returns Calls to disable ECDSA authentication
+ */
+function disable() {
+    const module = (0, core_1.getOwnableValidator)(1, []);
+    return {
+        async resolve({ config }) {
+            return (0, accounts_1.getModuleUninstallationCalls)(config, module);
+        },
+    };
+}
+/**
+ * Add an ECDSA owner
+ * @param owner Owner address
+ * @returns Call to add the owner
+ */
+function addOwner(owner) {
+    return {
+        to: core_1.OWNABLE_VALIDATOR_ADDRESS,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    inputs: [{ internalType: 'address', name: 'owner', type: 'address' }],
+                    name: 'addOwner',
+                    outputs: [],
+                    stateMutability: 'nonpayable',
+                    type: 'function',
+                },
+            ],
+            functionName: 'addOwner',
+            args: [owner],
+        }),
+    };
+}
+/**
+ * Remove an ECDSA owner
+ * @param prevOwner Previous owner address
+ * @param ownerToRemove Owner to remove
+ * @returns Call to remove the owner
+ */
+function removeOwner(prevOwner, ownerToRemove) {
+    return {
+        to: core_1.OWNABLE_VALIDATOR_ADDRESS,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    inputs: [
+                        { internalType: 'address', name: 'prevOwner', type: 'address' },
+                        { internalType: 'address', name: 'owner', type: 'address' },
+                    ],
+                    name: 'removeOwner',
+                    outputs: [],
+                    stateMutability: 'nonpayable',
+                    type: 'function',
+                },
+            ],
+            functionName: 'removeOwner',
+            args: [prevOwner, ownerToRemove],
+        }),
+    };
+}
+/**
+ * Change an account's signer threshold (ECDSA)
+ * @param newThreshold New threshold
+ * @returns Call to change the threshold
+ */
+function changeThreshold(newThreshold) {
+    return {
+        to: core_1.OWNABLE_VALIDATOR_ADDRESS,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    inputs: [
+                        { internalType: 'uint256', name: '_threshold', type: 'uint256' },
+                    ],
+                    name: 'setThreshold',
+                    outputs: [],
+                    stateMutability: 'nonpayable',
+                    type: 'function',
+                },
+            ],
+            functionName: 'setThreshold',
+            args: [BigInt(newThreshold)],
+        }),
+    };
+}

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

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

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

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

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 ecdsa_1 = require("./ecdsa");
+const MOCK_OWNER_A = '0xd1aefebdceefc094f1805b241fa5e6db63a9181a';
+const MOCK_OWNER_B = '0xeddfcb50d18f6d3d51c4f7cbca5ed6bdebc59817';
+const MOCK_OWNER_C = '0xb31e76f19defe76edc4b7eceeb4b0a2d6ddaca39';
+const accountAddress = '0x36C03e7D593F7B2C6b06fC18B5f4E9a4A29C99b0';
+(0, vitest_1.describe)('ECDSA Actions', () => {
+    (0, vitest_1.describe)('Install Ownable Validator', async () => {
+        const rhinestone = new index_1.RhinestoneSDK();
+        const rhinestoneAccount = await rhinestone.createAccount({
+            owners: {
+                type: 'ecdsa',
+                accounts: [consts_1.accountA],
+            },
+        });
+        (0, vitest_1.test)('1/1 Owners', async () => {
+            const calls = await (0, utils_1.resolveCallInputs)([(0, ecdsa_1.enable)([MOCK_OWNER_A])], rhinestoneAccount.config, chains_1.base, accountAddress);
+            (0, vitest_1.expect)(calls).toEqual([
+                {
+                    to: accountAddress,
+                    value: 0n,
+                    data: '0x9517e29f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000013fdb5234e4e3162a810f54d9f7e9800000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000d1aefebdceefc094f1805b241fa5e6db63a9181a',
+                },
+            ]);
+        });
+        (0, vitest_1.test)('1/N Owners', async () => {
+            const calls = await (0, utils_1.resolveCallInputs)([(0, ecdsa_1.enable)([MOCK_OWNER_A, MOCK_OWNER_B])], rhinestoneAccount.config, chains_1.base, accountAddress);
+            (0, vitest_1.expect)(calls).toEqual([
+                {
+                    to: accountAddress,
+                    value: 0n,
+                    data: '0x9517e29f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000013fdb5234e4e3162a810f54d9f7e98000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000002000000000000000000000000d1aefebdceefc094f1805b241fa5e6db63a9181a000000000000000000000000eddfcb50d18f6d3d51c4f7cbca5ed6bdebc59817',
+                },
+            ]);
+        });
+        (0, vitest_1.test)('M/N Owners', async () => {
+            const calls = await (0, utils_1.resolveCallInputs)([(0, ecdsa_1.enable)([MOCK_OWNER_A, MOCK_OWNER_B, MOCK_OWNER_C], 2)], rhinestoneAccount.config, chains_1.base, accountAddress);
+            (0, vitest_1.expect)(calls).toEqual([
+                {
+                    to: accountAddress,
+                    value: 0n,
+                    data: '0x9517e29f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000013fdb5234e4e3162a810f54d9f7e98000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000003000000000000000000000000b31e76f19defe76edc4b7eceeb4b0a2d6ddaca39000000000000000000000000d1aefebdceefc094f1805b241fa5e6db63a9181a000000000000000000000000eddfcb50d18f6d3d51c4f7cbca5ed6bdebc59817',
+                },
+            ]);
+        });
+    });
+    (0, vitest_1.describe)('Uninstall Ownable Validator', async () => {
+        const rhinestone = new index_1.RhinestoneSDK();
+        const rhinestoneAccount = await rhinestone.createAccount({
+            owners: {
+                type: 'ecdsa',
+                accounts: [consts_1.accountA],
+            },
+        });
+        (0, vitest_1.test)('', async () => {
+            const calls = await (0, utils_1.resolveCallInputs)([(0, ecdsa_1.disable)()], rhinestoneAccount.config, chains_1.base, accountAddress);
+            (0, vitest_1.expect)(calls).toEqual([
+                {
+                    to: accountAddress,
+                    value: 0n,
+                    data: '0xa71763a80000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000013fdb5234e4e3162a810f54d9f7e9800000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000',
+                },
+            ]);
+        });
+    });
+    (0, vitest_1.describe)('Add Owner', () => {
+        (0, vitest_1.test)('', () => {
+            (0, vitest_1.expect)((0, ecdsa_1.addOwner)(MOCK_OWNER_A)).toEqual({
+                to: '0x000000000013fdb5234e4e3162a810f54d9f7e98',
+                value: 0n,
+                data: '0x7065cb48000000000000000000000000d1aefebdceefc094f1805b241fa5e6db63a9181a',
+            });
+        });
+    });
+    (0, vitest_1.describe)('Remove Owner', () => {
+        (0, vitest_1.test)('', () => {
+            (0, vitest_1.expect)((0, ecdsa_1.removeOwner)(MOCK_OWNER_A, MOCK_OWNER_B)).toEqual({
+                to: '0x000000000013fdb5234e4e3162a810f54d9f7e98',
+                value: 0n,
+                data: '0xfbe5ce0a000000000000000000000000d1aefebdceefc094f1805b241fa5e6db63a9181a000000000000000000000000eddfcb50d18f6d3d51c4f7cbca5ed6bdebc59817',
+            });
+        });
+    });
+    (0, vitest_1.describe)('Set Threshold', () => {
+        (0, vitest_1.test)('', () => {
+            (0, vitest_1.expect)((0, ecdsa_1.changeThreshold)(1)).toEqual({
+                to: '0x000000000013fdb5234e4e3162a810f54d9f7e98',
+                value: 0n,
+                data: '0x960bfe040000000000000000000000000000000000000000000000000000000000000001',
+            });
+        });
+    });
+});

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

@@ -1,167 +1,24 @@
-import { type Address, type Chain, type Hex } from 'viem';
-import type { RhinestoneAccount } from '..';
-import { type WebauthnCredential } from '../modules/validators/core';
-import type { Call, OwnableValidatorConfig, OwnerSet, ProviderConfig, Recovery, WebauthnValidatorConfig } from '../types';
-import { encodeSmartSessionSignature } from './smart-session';
-/**
- * Set up social recovery
- * @param rhinestoneAccount Account to set up social recovery on
- * @param guardians Guardians to use for recovery
- * @param threshold Threshold for the guardians
- * @returns Calls to set up social recovery
- */
-declare function setUpRecovery({ rhinestoneAccount, guardians, threshold, }: {
-    rhinestoneAccount: RhinestoneAccount;
-} & Recovery): Call[];
-/**
- * Recover an account's ownership
- * @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
- * @deprecated Use `recoverEcdsaOwnership` or `recoverPasskeyOwnership` instead
- */
-declare function recover(address: Address, newOwners: OwnerSet, chain: Chain, provider?: ProviderConfig): Promise<Call[]>;
-/**
- * Enable ECDSA authentication
- * @param rhinestoneAccount Account to enable ECDSA authentication on
- * @param owners Owners to use for authentication
- * @param threshold Threshold for the owners
- * @returns Calls to enable ECDSA authentication
- */
-declare function enableEcdsa({ rhinestoneAccount, owners, threshold, }: {
-    rhinestoneAccount: RhinestoneAccount;
-    owners: Address[];
-    threshold?: number;
-}): Call[];
-/**
- * Enable passkeys authentication
- * @param rhinestoneAccount Account to enable passkeys authentication on
- * @param pubKey Public key for the passkey
- * @param authenticatorId Authenticator ID for the passkey
- * @returns Calls to enable passkeys authentication
- */
-declare function enablePasskeys({ rhinestoneAccount, pubKey, authenticatorId, }: {
-    rhinestoneAccount: RhinestoneAccount;
-} & WebauthnCredential): Call[];
-/**
- * Disable ECDSA authentication
- * @param rhinestoneAccount Account to disable ECDSA authentication on
- * @returns Calls to disable ECDSA authentication
- */
-declare function disableEcdsa({ rhinestoneAccount, }: {
-    rhinestoneAccount: RhinestoneAccount;
-}): Call[];
-/**
- * Disable passkeys (WebAuthn) authentication
- * @param rhinestoneAccount Account to disable passkeys authentication on
- * @returns Calls to disable passkeys authentication
- */
-declare function disablePasskeys({ rhinestoneAccount, }: {
-    rhinestoneAccount: RhinestoneAccount;
-}): Call[];
-/**
- * Add an ECDSA owner
- * @param owner Owner address
- * @returns Call to add the owner
- */
-declare function addOwner(owner: Address): Call;
-/**
- * Remove an ECDSA owner
- * @param prevOwner Previous owner address
- * @param ownerToRemove Owner to remove
- * @returns Call to remove the owner
- */
-declare function removeOwner(prevOwner: Address, ownerToRemove: Address): Call;
-/**
- * Change an account's signer threshold (ECDSA)
- * @param newThreshold New threshold
- * @returns Call to change the threshold
- */
-declare function changeThreshold(newThreshold: number): Call;
-/**
- * Add a passkey owner
- * @param pubKeyX Public key X
- * @param pubKeyY Public key Y
- * @param requireUserVerification Whether to require user verification
- * @returns Call to add the passkey owner
- */
-declare function addPasskeyOwner(pubKeyX: bigint, pubKeyY: bigint, requireUserVerification: boolean): Call;
-/**
- * Remove a passkey owner
- * @param pubKeyX Public key X
- * @param pubKeyY Public key Y
- * @returns Call to remove the passkey owner
- */
-declare function removePasskeyOwner(pubKeyX: bigint, pubKeyY: bigint): Call;
-/**
- * Change an account's signer threshold (passkey)
- * @param newThreshold New threshold
- * @returns Call to change the threshold
- */
-declare function changePasskeyThreshold(newThreshold: number): Call;
-/**
- * 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
- */
-declare function recoverEcdsaOwnership(address: Address, newOwners: OwnableValidatorConfig, chain: Chain, provider?: ProviderConfig): Promise<Call[]>;
-/**
- * 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
- */
-declare function recoverPasskeyOwnership(address: Address, oldCredentials: {
-    pubKeyX: bigint;
-    pubKeyY: bigint;
-}[], newOwners: WebauthnValidatorConfig, chain: Chain, provider?: ProviderConfig): Promise<Call[]>;
-/**
- * Enable multi-factor authentication
- * @param rhinestoneAccount Account to enable multi-factor authentication on
- * @param validators List of validators to use
- * @param threshold Threshold for the validators
- * @returns Calls to enable multi-factor authentication
- */
-declare function enableMultiFactor({ rhinestoneAccount, validators, threshold, }: {
-    rhinestoneAccount: RhinestoneAccount;
-    validators: (OwnableValidatorConfig | WebauthnValidatorConfig | null)[];
-    threshold?: number;
-}): Call[];
-/**
- * Disable multi-factor authentication
- * @param rhinestoneAccount Account to disable multi-factor authentication on
- * @returns Calls to disable multi-factor authentication
- */
-declare function disableMultiFactor({ rhinestoneAccount, }: {
-    rhinestoneAccount: RhinestoneAccount;
-}): Call[];
-/**
- * Change the multi-factor threshold
- * @param newThreshold New threshold
- * @returns Call to change the threshold
- */
-declare function changeMultiFactorThreshold(newThreshold: number): Call;
-/**
- * Set a sub-validator (multi-factor)
- * @param id Validator ID
- * @param validator Validator module
- * @returns Call to set the sub-validator
- */
-declare function setSubValidator(id: Hex | number, validator: OwnableValidatorConfig | WebauthnValidatorConfig): Call;
-/**
- * Remove a sub-validator (multi-factor)
- * @param id Validator ID
- * @param validator Validator module
- * @returns Call to remove the sub-validator
- */
-declare function removeSubValidator(id: Hex | number, validator: OwnableValidatorConfig | WebauthnValidatorConfig): Call;
-export { enableEcdsa, enablePasskeys, disableEcdsa, disablePasskeys, addOwner, removeOwner, changeThreshold, addPasskeyOwner, removePasskeyOwner, changePasskeyThreshold, recover, recoverEcdsaOwnership, recoverPasskeyOwnership, setUpRecovery, encodeSmartSessionSignature, enableMultiFactor, disableMultiFactor, changeMultiFactorThreshold, setSubValidator, removeSubValidator, };
+import type { Address, Hex } from 'viem';
+import { type ModuleType } from '../modules/common';
+import type { LazyCallInput } from '../types';
+interface ModuleInput {
+    type: ModuleType;
+    address: Address;
+    initData?: Hex;
+    deInitData?: Hex;
+    additionalContext?: Hex;
+}
+/**
+ * Install a custom module
+ * @param module Module to install
+ * @returns Calls to install the module
+ */
+declare function installModule(module: ModuleInput): LazyCallInput;
+/**
+ * Uninstall a custom module
+ * @param module Module to uninstall
+ * @returns Calls to uninstall the module
+ */
+declare function uninstallModule(module: ModuleInput): LazyCallInput;
+export { installModule, uninstallModule };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../actions/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../actions/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAMxC,OAAO,EAAe,KAAK,UAAU,EAAkB,MAAM,mBAAmB,CAAA;AAChF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C,UAAU,WAAW;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,CAAC,EAAE,GAAG,CAAA;IACd,UAAU,CAAC,EAAE,GAAG,CAAA;IAChB,iBAAiB,CAAC,EAAE,GAAG,CAAA;CACxB;AAED;;;;GAIG;AACH,iBAAS,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa,CAOzD;AAED;;;;GAIG;AACH,iBAAS,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa,CAO3D;AAYD,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,CAAA"}