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

package/dist/src/actions/index.js

@@ -1,306 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeSmartSessionSignature = void 0;
-exports.enableEcdsa = enableEcdsa;
-exports.enablePasskeys = enablePasskeys;
-exports.disableEcdsa = disableEcdsa;
-exports.disablePasskeys = disablePasskeys;
-exports.addOwner = addOwner;
-exports.removeOwner = removeOwner;
-exports.changeThreshold = changeThreshold;
-exports.recover = recover;
-exports.setUpRecovery = setUpRecovery;
-exports.enableMultiFactor = enableMultiFactor;
-exports.disableMultiFactor = disableMultiFactor;
-exports.changeMultiFactorThreshold = changeMultiFactorThreshold;
-exports.setSubValidator = setSubValidator;
-exports.removeSubValidator = removeSubValidator;
-const viem_1 = require("viem");
+exports.installModule = installModule;
+exports.uninstallModule = uninstallModule;
 const accounts_1 = require("../accounts");
-const utils_1 = require("../accounts/utils");
-const core_1 = require("../modules/validators/core");
-const smart_session_1 = require("./smart-session");
-Object.defineProperty(exports, "encodeSmartSessionSignature", { enumerable: true, get: function () { return smart_session_1.encodeSmartSessionSignature; } });
-function setUpRecovery({ rhinestoneAccount, guardians, threshold = 1, }) {
-    const module = (0, core_1.getSocialRecoveryValidator)(guardians, threshold);
-    const calls = (0, accounts_1.getModuleInstallationCalls)(rhinestoneAccount.config, module);
-    return calls;
-}
-async function recover(address, newOwners, chain, provider) {
-    switch (newOwners.type) {
-        case 'ecdsa': {
-            return recoverEcdsaOwnership(address, newOwners, chain, provider);
-        }
-        case 'passkey': {
-            throw new Error('Passkey ownership recovery is not yet supported');
-        }
-        case 'multi-factor': {
-            throw new Error('Multi-factor ownership recovery is not yet supported');
-        }
-    }
-}
-function enableEcdsa({ rhinestoneAccount, owners, threshold = 1, }) {
-    const module = (0, core_1.getOwnableValidator)(threshold, owners);
-    const calls = (0, accounts_1.getModuleInstallationCalls)(rhinestoneAccount.config, module);
-    return calls;
-}
-function enablePasskeys({ rhinestoneAccount, pubKey, authenticatorId, }) {
-    const module = (0, core_1.getWebAuthnValidator)({ pubKey, authenticatorId });
-    const calls = (0, accounts_1.getModuleInstallationCalls)(rhinestoneAccount.config, module);
-    return calls;
-}
-function disableEcdsa({ rhinestoneAccount, }) {
-    const module = (0, core_1.getOwnableValidator)(1, []);
-    const calls = (0, accounts_1.getModuleUninstallationCalls)(rhinestoneAccount.config, module);
-    return calls;
-}
-function disablePasskeys({ rhinestoneAccount, }) {
-    const module = (0, core_1.getWebAuthnValidator)({
-        // Mocked values
-        pubKey: '0x580a9af0569ad3905b26a703201b358aa0904236642ebe79b22a19d00d3737637d46f725a5427ae45a9569259bf67e1e16b187d7b3ad1ed70138c4f0409677d1',
-        authenticatorId: '0x',
-    });
-    const calls = (0, accounts_1.getModuleUninstallationCalls)(rhinestoneAccount.config, module);
-    return calls;
-}
-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],
-        }),
-    };
-}
-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],
-        }),
-    };
-}
-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)],
-        }),
-    };
-}
-async function recoverEcdsaOwnership(address, newOwners, chain, provider) {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain,
-        transport: (0, utils_1.createTransport)(chain, 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 calls = [];
-    // 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) {
-        calls.push(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) {
-        calls.push(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];
-        }
-        calls.push(removeOwner(prevOwner, ownerToRemove));
-        currentOwners = currentOwners.filter((owner) => owner !== ownerToRemove);
-    }
-    return calls;
-}
-function enableMultiFactor({ rhinestoneAccount, validators, threshold = 1, }) {
-    const module = (0, core_1.getMultiFactorValidator)(threshold, validators);
-    const calls = (0, accounts_1.getModuleInstallationCalls)(rhinestoneAccount.config, module);
-    return calls;
-}
-function disableMultiFactor({ rhinestoneAccount, }) {
-    const module = (0, core_1.getMultiFactorValidator)(1, []);
-    const calls = (0, accounts_1.getModuleUninstallationCalls)(rhinestoneAccount.config, module);
-    return calls;
-}
-function changeMultiFactorThreshold(newThreshold) {
+const common_1 = require("../modules/common");
+/**
+ * Install a custom module
+ * @param module Module to install
+ * @returns Calls to install the module
+ */
+function installModule(module) {
+    const moduleData = getModule(module);
     return {
-        to: core_1.MULTI_FACTOR_VALIDATOR_ADDRESS,
-        value: 0n,
-        data: (0, viem_1.encodeFunctionData)({
-            abi: [
-                {
-                    inputs: [{ internalType: 'uint8', name: 'threshold', type: 'uint8' }],
-                    name: 'setThreshold',
-                    outputs: [],
-                    stateMutability: 'nonpayable',
-                    type: 'function',
-                },
-            ],
-            functionName: 'setThreshold',
-            args: [newThreshold],
-        }),
+        async resolve({ config }) {
+            return (0, accounts_1.getModuleInstallationCalls)(config, moduleData);
+        },
     };
 }
-function setSubValidator(id, validator) {
-    const validatorId = (0, viem_1.padHex)((0, viem_1.toHex)(id), { size: 12 });
-    const validatorModule = (0, core_1.getValidator)(validator);
+/**
+ * Uninstall a custom module
+ * @param module Module to uninstall
+ * @returns Calls to uninstall the module
+ */
+function uninstallModule(module) {
+    const moduleData = getModule(module);
     return {
-        to: core_1.MULTI_FACTOR_VALIDATOR_ADDRESS,
-        value: 0n,
-        data: (0, viem_1.encodeFunctionData)({
-            abi: [
-                {
-                    type: 'function',
-                    name: 'setValidator',
-                    inputs: [
-                        {
-                            type: 'address',
-                            name: 'validatorAddress',
-                        },
-                        {
-                            type: 'bytes12',
-                            name: 'validatorId',
-                        },
-                        {
-                            type: 'bytes',
-                            name: 'newValidatorData',
-                        },
-                    ],
-                },
-            ],
-            functionName: 'setValidator',
-            args: [validatorModule.address, validatorId, validatorModule.initData],
-        }),
+        async resolve({ config }) {
+            return (0, accounts_1.getModuleUninstallationCalls)(config, moduleData);
+        },
     };
 }
-function removeSubValidator(id, validator) {
-    const validatorId = (0, viem_1.padHex)((0, viem_1.toHex)(id), { size: 12 });
-    const validatorModule = (0, core_1.getValidator)(validator);
+function getModule(module) {
     return {
-        to: core_1.MULTI_FACTOR_VALIDATOR_ADDRESS,
-        value: 0n,
-        data: (0, viem_1.encodeFunctionData)({
-            abi: [
-                {
-                    type: 'function',
-                    name: 'removeValidator',
-                    inputs: [
-                        {
-                            type: 'address',
-                            name: 'validatorAddress',
-                        },
-                        {
-                            type: 'bytes12',
-                            name: 'validatorId',
-                        },
-                    ],
-                },
-            ],
-            functionName: 'removeValidator',
-            args: [validatorModule.address, validatorId],
-        }),
+        type: (0, common_1.toModuleTypeId)(module.type),
+        address: module.address,
+        initData: module.initData ?? '0x',
+        deInitData: module.deInitData ?? '0x',
+        additionalContext: module.additionalContext ?? '0x',
     };
 }

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

@@ -0,0 +1,37 @@
+import { type Hex } from 'viem';
+import type { CalldataInput, LazyCallInput, OwnableValidatorConfig, WebauthnValidatorConfig } from '../types';
+/**
+ * Enable multi-factor authentication
+ * @param validators List of validators to use
+ * @param threshold Threshold for the validators
+ * @returns Calls to enable multi-factor authentication
+ */
+declare function enable(validators: (OwnableValidatorConfig | WebauthnValidatorConfig | null)[], threshold?: number): LazyCallInput;
+/**
+ * Change the multi-factor threshold
+ * @param newThreshold New threshold
+ * @returns Call to change the threshold
+ */
+declare function changeThreshold(newThreshold: number): CalldataInput;
+/**
+ * Disable multi-factor authentication
+ * @param rhinestoneAccount Account to disable multi-factor authentication on
+ * @returns Calls to disable multi-factor authentication
+ */
+declare function disable(): LazyCallInput;
+/**
+ * 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): CalldataInput;
+/**
+ * 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): CalldataInput;
+export { enable, changeThreshold, disable, setSubValidator, removeSubValidator };
+//# sourceMappingURL=mfa.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mfa.d.ts","sourceRoot":"","sources":["../../../actions/mfa.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,GAAG,EAAiB,MAAM,MAAM,CAAA;AAUlE,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACb,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,UAAU,CAAA;AAEjB;;;;;GAKG;AACH,iBAAS,MAAM,CACb,UAAU,EAAE,CAAC,sBAAsB,GAAG,uBAAuB,GAAG,IAAI,CAAC,EAAE,EACvE,SAAS,SAAI,GACZ,aAAa,CAOf;AAED;;;;GAIG;AACH,iBAAS,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,aAAa,CAkB5D;AAED;;;;GAIG;AACH,iBAAS,OAAO,IAAI,aAAa,CAOhC;AAED;;;;;GAKG;AACH,iBAAS,eAAe,CACtB,EAAE,EAAE,GAAG,GAAG,MAAM,EAChB,SAAS,EAAE,sBAAsB,GAAG,uBAAuB,GAC1D,aAAa,CA+Bf;AAED;;;;;GAKG;AACH,iBAAS,kBAAkB,CACzB,EAAE,EAAE,GAAG,GAAG,MAAM,EAChB,SAAS,EAAE,sBAAsB,GAAG,uBAAuB,GAC1D,aAAa,CA2Bf;AAED,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,CAAA"}

package/dist/src/actions/mfa.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enable = enable;
+exports.changeThreshold = changeThreshold;
+exports.disable = disable;
+exports.setSubValidator = setSubValidator;
+exports.removeSubValidator = removeSubValidator;
+const viem_1 = require("viem");
+const accounts_1 = require("../accounts");
+const core_1 = require("../modules/validators/core");
+/**
+ * Enable multi-factor authentication
+ * @param validators List of validators to use
+ * @param threshold Threshold for the validators
+ * @returns Calls to enable multi-factor authentication
+ */
+function enable(validators, threshold = 1) {
+    const module = (0, core_1.getMultiFactorValidator)(threshold, validators);
+    return {
+        async resolve({ config }) {
+            return (0, accounts_1.getModuleInstallationCalls)(config, module);
+        },
+    };
+}
+/**
+ * Change the multi-factor threshold
+ * @param newThreshold New threshold
+ * @returns Call to change the threshold
+ */
+function changeThreshold(newThreshold) {
+    return {
+        to: core_1.MULTI_FACTOR_VALIDATOR_ADDRESS,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    inputs: [{ internalType: 'uint8', name: 'threshold', type: 'uint8' }],
+                    name: 'setThreshold',
+                    outputs: [],
+                    stateMutability: 'nonpayable',
+                    type: 'function',
+                },
+            ],
+            functionName: 'setThreshold',
+            args: [newThreshold],
+        }),
+    };
+}
+/**
+ * Disable multi-factor authentication
+ * @param rhinestoneAccount Account to disable multi-factor authentication on
+ * @returns Calls to disable multi-factor authentication
+ */
+function disable() {
+    const module = (0, core_1.getMultiFactorValidator)(1, []);
+    return {
+        async resolve({ config }) {
+            return (0, accounts_1.getModuleUninstallationCalls)(config, module);
+        },
+    };
+}
+/**
+ * Set a sub-validator (multi-factor)
+ * @param id Validator ID
+ * @param validator Validator module
+ * @returns Call to set the sub-validator
+ */
+function setSubValidator(id, validator) {
+    const validatorId = (0, viem_1.padHex)((0, viem_1.toHex)(id), { size: 12 });
+    const validatorModule = (0, core_1.getValidator)(validator);
+    return {
+        to: core_1.MULTI_FACTOR_VALIDATOR_ADDRESS,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    type: 'function',
+                    name: 'setValidator',
+                    inputs: [
+                        {
+                            type: 'address',
+                            name: 'validatorAddress',
+                        },
+                        {
+                            type: 'bytes12',
+                            name: 'validatorId',
+                        },
+                        {
+                            type: 'bytes',
+                            name: 'newValidatorData',
+                        },
+                    ],
+                },
+            ],
+            functionName: 'setValidator',
+            args: [validatorModule.address, validatorId, validatorModule.initData],
+        }),
+    };
+}
+/**
+ * Remove a sub-validator (multi-factor)
+ * @param id Validator ID
+ * @param validator Validator module
+ * @returns Call to remove the sub-validator
+ */
+function removeSubValidator(id, validator) {
+    const validatorId = (0, viem_1.padHex)((0, viem_1.toHex)(id), { size: 12 });
+    const validatorModule = (0, core_1.getValidator)(validator);
+    return {
+        to: core_1.MULTI_FACTOR_VALIDATOR_ADDRESS,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    type: 'function',
+                    name: 'removeValidator',
+                    inputs: [
+                        {
+                            type: 'address',
+                            name: 'validatorAddress',
+                        },
+                        {
+                            type: 'bytes12',
+                            name: 'validatorId',
+                        },
+                    ],
+                },
+            ],
+            functionName: 'removeValidator',
+            args: [validatorModule.address, validatorId],
+        }),
+    };
+}

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

@@ -0,0 +1,37 @@
+import { type WebauthnCredential } from '../modules/validators/core';
+import type { CalldataInput, LazyCallInput } from '../types';
+/**
+ * Enable passkeys authentication
+ * @param pubKey Public key for the passkey
+ * @param authenticatorId Authenticator ID for the passkey
+ * @returns Calls to enable passkeys authentication
+ */
+declare function enable(credential: WebauthnCredential): LazyCallInput;
+/**
+ * Disable passkeys (WebAuthn) authentication
+ * @returns Calls to disable passkeys authentication
+ */
+declare function disable(): LazyCallInput;
+/**
+ * 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 addOwner(pubKeyX: bigint, pubKeyY: bigint, requireUserVerification: boolean): CalldataInput;
+/**
+ * Remove a passkey owner
+ * @param pubKeyX Public key X
+ * @param pubKeyY Public key Y
+ * @returns Call to remove the passkey owner
+ */
+declare function removeOwner(pubKeyX: bigint, pubKeyY: bigint): CalldataInput;
+/**
+ * Change an account's signer threshold (passkey)
+ * @param newThreshold New threshold
+ * @returns Call to change the threshold
+ */
+declare function changeThreshold(newThreshold: number): CalldataInput;
+export { addOwner, removeOwner, changeThreshold, disable, enable };
+//# sourceMappingURL=passkeys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"passkeys.d.ts","sourceRoot":"","sources":["../../../actions/passkeys.ts"],"names":[],"mappings":"AAKA,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,4BAA4B,CAAA;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE5D;;;;;GAKG;AACH,iBAAS,MAAM,CAAC,UAAU,EAAE,kBAAkB,GAAG,aAAa,CAO7D;AAED;;;GAGG;AACH,iBAAS,OAAO,IAAI,aAAa,CAchC;AAED;;;;;;GAMG;AACH,iBAAS,QAAQ,CACf,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,uBAAuB,EAAE,OAAO,GAC/B,aAAa,CAyBf;AAED;;;;;GAKG;AACH,iBAAS,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa,CAqBpE;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/passkeys.js

@@ -0,0 +1,129 @@
+"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 passkeys authentication
+ * @param pubKey Public key for the passkey
+ * @param authenticatorId Authenticator ID for the passkey
+ * @returns Calls to enable passkeys authentication
+ */
+function enable(credential) {
+    const module = (0, core_1.getWebAuthnValidator)(1, [credential]);
+    return {
+        async resolve({ config }) {
+            return (0, accounts_1.getModuleInstallationCalls)(config, module);
+        },
+    };
+}
+/**
+ * Disable passkeys (WebAuthn) authentication
+ * @returns Calls to disable passkeys authentication
+ */
+function disable() {
+    const module = (0, core_1.getWebAuthnValidator)(1, [
+        {
+            // Mocked values
+            pubKey: '0x580a9af0569ad3905b26a703201b358aa0904236642ebe79b22a19d00d3737637d46f725a5427ae45a9569259bf67e1e16b187d7b3ad1ed70138c4f0409677d1',
+            authenticatorId: '0x',
+        },
+    ]);
+    return {
+        async resolve({ config }) {
+            return (0, accounts_1.getModuleUninstallationCalls)(config, module);
+        },
+    };
+}
+/**
+ * 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
+ */
+function addOwner(pubKeyX, pubKeyY, requireUserVerification) {
+    return {
+        to: core_1.WEBAUTHN_VALIDATOR_ADDRESS,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    inputs: [
+                        { name: 'pubKeyX', type: 'uint256' },
+                        { name: 'pubKeyY', type: 'uint256' },
+                        {
+                            name: 'requireUserVerification',
+                            type: 'bool',
+                        },
+                    ],
+                    name: 'addCredential',
+                    outputs: [],
+                    stateMutability: 'nonpayable',
+                    type: 'function',
+                },
+            ],
+            functionName: 'addCredential',
+            args: [pubKeyX, pubKeyY, requireUserVerification],
+        }),
+    };
+}
+/**
+ * Remove a passkey owner
+ * @param pubKeyX Public key X
+ * @param pubKeyY Public key Y
+ * @returns Call to remove the passkey owner
+ */
+function removeOwner(pubKeyX, pubKeyY) {
+    return {
+        to: core_1.WEBAUTHN_VALIDATOR_ADDRESS,
+        value: 0n,
+        data: (0, viem_1.encodeFunctionData)({
+            abi: [
+                {
+                    inputs: [
+                        { name: 'pubKeyX', type: 'uint256' },
+                        { name: 'pubKeyY', type: 'uint256' },
+                    ],
+                    name: 'removeCredential',
+                    outputs: [],
+                    stateMutability: 'nonpayable',
+                    type: 'function',
+                },
+            ],
+            functionName: 'removeCredential',
+            args: [pubKeyX, pubKeyY],
+        }),
+    };
+}
+/**
+ * Change an account's signer threshold (passkey)
+ * @param newThreshold New threshold
+ * @returns Call to change the threshold
+ */
+function changeThreshold(newThreshold) {
+    return {
+        to: core_1.WEBAUTHN_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/passkeys.test.d.ts

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

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

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