@rhinestone/sdk 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -2,12 +2,55 @@ import type { Account, Address, Hex } from 'viem';
 import { getSetup as experimental_getModuleSetup } from '../modules/index.js';
 import type { RhinestoneAccountConfig } from '../types.js';
 import { walletClientToAccount, wrapParaAccount } from './walletClient.js';
+/**
+ * Compute the v0 (legacy) initialization data for an account configuration.
+ *
+ * Use this to reconstruct the `initData` for an account originally created with
+ * the Rhinestone SDK v0, then pass it back into `createAccount`.
+ * @param config Account configuration
+ * @returns The account address, factory, factory data, and whether the intent executor is installed
+ * @example
+ * ```ts
+ * import { experimental_getV0InitData } from '@rhinestone/sdk/utils'
+ *
+ * const initData = experimental_getV0InitData({
+ *   owners: { type: 'ecdsa', accounts: [owner] },
+ * })
+ *
+ * const account = await sdk.createAccount({
+ *   owners: { type: 'ecdsa', accounts: [owner] },
+ *   initData,
+ * })
+ * ```
+ */
 declare function experimental_getV0InitData(config: RhinestoneAccountConfig): {
     address: Address;
     factory: Address;
     factoryData: Hex;
     intentExecutorInstalled: boolean;
 };
+/**
+ * Compute the Rhinestone initialization data for an account configuration.
+ *
+ * Use this to reconstruct the `initData` for an account originally created with
+ * the Rhinestone SDK, then pass it back into `createAccount` instead of
+ * providing the factory and factory data manually.
+ * @param config Account configuration
+ * @returns The account address, plus factory data when the account is not yet deployed
+ * @example
+ * ```ts
+ * import { experimental_getRhinestoneInitData } from '@rhinestone/sdk/utils'
+ *
+ * const initData = experimental_getRhinestoneInitData({
+ *   owners: { type: 'ecdsa', accounts: [owner] },
+ * })
+ *
+ * const account = await sdk.createAccount({
+ *   owners: { type: 'ecdsa', accounts: [owner] },
+ *   initData,
+ * })
+ * ```
+ */
 declare function experimental_getRhinestoneInitData(config: RhinestoneAccountConfig): {
     address: Address;
     factory: Address;
@@ -16,6 +59,22 @@ declare function experimental_getRhinestoneInitData(config: RhinestoneAccountCon
 } | {
     address: Address;
 };
+/**
+ * Create a view-only viem `Account` for an address. Any signing operation throws.
+ *
+ * Useful as an account owner when signing happens elsewhere (e.g. a server-held
+ * session signer), so the SDK can read from the account without holding a key.
+ * @param address Address to wrap
+ * @returns A viem account that can be read from but not signed with
+ * @example
+ * ```ts
+ * import { toViewOnlyAccount } from '@rhinestone/sdk/utils'
+ *
+ * const account = await sdk.createAccount({
+ *   owners: { type: 'ecdsa', accounts: [toViewOnlyAccount(userAddress)] },
+ * })
+ * ```
+ */
 declare function toViewOnlyAccount(address: Address): Account;
 export { experimental_getV0InitData, experimental_getModuleSetup, experimental_getRhinestoneInitData, toViewOnlyAccount, walletClientToAccount, wrapParaAccount, };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAGjD,OAAO,EAAE,QAAQ,IAAI,2BAA2B,EAAE,MAAM,YAAY,CAAA;AACpE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AACvD,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEvE,iBAAS,0BAA0B,CAAC,MAAM,EAAE,uBAAuB,GAAG;IACpE,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,WAAW,EAAE,GAAG,CAAA;IAChB,uBAAuB,EAAE,OAAO,CAAA;CACjC,CAgBA;AAED,iBAAS,kCAAkC,CAAC,MAAM,EAAE,uBAAuB,GACvE;IACE,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,WAAW,EAAE,GAAG,CAAA;IAChB,uBAAuB,EAAE,OAAO,CAAA;CACjC,GACD;IACE,OAAO,EAAE,OAAO,CAAA;CACjB,CAmBJ;AAED,iBAAS,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAcpD;AAED,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAC3B,kCAAkC,EAClC,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,GAChB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAGjD,OAAO,EAAE,QAAQ,IAAI,2BAA2B,EAAE,MAAM,YAAY,CAAA;AACpE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AACvD,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEvE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,iBAAS,0BAA0B,CAAC,MAAM,EAAE,uBAAuB,GAAG;IACpE,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,WAAW,EAAE,GAAG,CAAA;IAChB,uBAAuB,EAAE,OAAO,CAAA;CACjC,CAgBA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iBAAS,kCAAkC,CAAC,MAAM,EAAE,uBAAuB,GACvE;IACE,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,WAAW,EAAE,GAAG,CAAA;IAChB,uBAAuB,EAAE,OAAO,CAAA;CACjC,GACD;IACE,OAAO,EAAE,OAAO,CAAA;CACjB,CAmBJ;AAED;;;;;;;;;;;;;;;GAeG;AACH,iBAAS,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAcpD;AAED,OAAO,EACL,0BAA0B,EAC1B,2BAA2B,EAC3B,kCAAkC,EAClC,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,GAChB,CAAA"}

package/dist/src/utils/index.js

@@ -2,6 +2,27 @@ import { toAccount } from 'viem/accounts';
 import { getAddress, getInitCode, getV0InitCode } from '../accounts/index.js';
 import { getSetup as experimental_getModuleSetup } from '../modules/index.js';
 import { walletClientToAccount, wrapParaAccount } from './walletClient.js';
+/**
+ * Compute the v0 (legacy) initialization data for an account configuration.
+ *
+ * Use this to reconstruct the `initData` for an account originally created with
+ * the Rhinestone SDK v0, then pass it back into `createAccount`.
+ * @param config Account configuration
+ * @returns The account address, factory, factory data, and whether the intent executor is installed
+ * @example
+ * ```ts
+ * import { experimental_getV0InitData } from '@rhinestone/sdk/utils'
+ *
+ * const initData = experimental_getV0InitData({
+ *   owners: { type: 'ecdsa', accounts: [owner] },
+ * })
+ *
+ * const account = await sdk.createAccount({
+ *   owners: { type: 'ecdsa', accounts: [owner] },
+ *   initData,
+ * })
+ * ```
+ */
 function experimental_getV0InitData(config) {
     const initCode = getV0InitCode(config);
     if (!initCode) {
@@ -19,6 +40,28 @@ function experimental_getV0InitData(config) {
         intentExecutorInstalled: true,
     };
 }
+/**
+ * Compute the Rhinestone initialization data for an account configuration.
+ *
+ * Use this to reconstruct the `initData` for an account originally created with
+ * the Rhinestone SDK, then pass it back into `createAccount` instead of
+ * providing the factory and factory data manually.
+ * @param config Account configuration
+ * @returns The account address, plus factory data when the account is not yet deployed
+ * @example
+ * ```ts
+ * import { experimental_getRhinestoneInitData } from '@rhinestone/sdk/utils'
+ *
+ * const initData = experimental_getRhinestoneInitData({
+ *   owners: { type: 'ecdsa', accounts: [owner] },
+ * })
+ *
+ * const account = await sdk.createAccount({
+ *   owners: { type: 'ecdsa', accounts: [owner] },
+ *   initData,
+ * })
+ * ```
+ */
 function experimental_getRhinestoneInitData(config) {
     const initCode = getInitCode(config);
     if (!initCode) {
@@ -40,6 +83,22 @@ function experimental_getRhinestoneInitData(config) {
         };
     }
 }
+/**
+ * Create a view-only viem `Account` for an address. Any signing operation throws.
+ *
+ * Useful as an account owner when signing happens elsewhere (e.g. a server-held
+ * session signer), so the SDK can read from the account without holding a key.
+ * @param address Address to wrap
+ * @returns A viem account that can be read from but not signed with
+ * @example
+ * ```ts
+ * import { toViewOnlyAccount } from '@rhinestone/sdk/utils'
+ *
+ * const account = await sdk.createAccount({
+ *   owners: { type: 'ecdsa', accounts: [toViewOnlyAccount(userAddress)] },
+ * })
+ * ```
+ */
 function toViewOnlyAccount(address) {
     const errorMessage = 'Signing is not supported for view-only accounts';
     return toAccount({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinestone/sdk",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.30",
   "description": "End-to-end chain abstraction and modularity toolkit",
   "author": {
     "name": "Rhinestone",
@@ -43,10 +43,6 @@
       "types": "./dist/src/actions/smart-sessions.d.ts",
       "import": "./dist/src/actions/smart-sessions.js"
     },
-    "./actions/recovery": {
-      "types": "./dist/src/actions/recovery.d.ts",
-      "import": "./dist/src/actions/recovery.js"
-    },
     "./errors": {
       "types": "./dist/src/errors/index.d.ts",
       "import": "./dist/src/errors/index.js"
@@ -56,8 +52,8 @@
       "import": "./dist/src/utils/index.js"
     },
     "./smart-sessions": {
-      "types": "./dist/src/modules/validators/smart-sessions.d.ts",
-      "import": "./dist/src/modules/validators/smart-sessions.js"
+      "types": "./dist/src/smart-sessions/index.d.ts",
+      "import": "./dist/src/smart-sessions/index.js"
     },
     "./jwt-server": {
       "types": "./dist/src/jwt-server/index.d.ts",
@@ -79,7 +75,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@rhinestone/shared-configs": "1.4.139",
+    "@rhinestone/shared-configs": "1.6.7",
     "solady": "^0.1.26"
   },
   "peerDependencies": {

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

@@ -1,33 +0,0 @@
-import { type Account, type Address, type Chain } from 'viem';
-import type { CalldataInput, LazyCallInput, OwnableValidatorConfig, RhinestoneConfig, WebauthnValidatorConfig } from '../types.js';
-/**
- * Set up social recovery
- * @param guardians Guardians to use for recovery
- * @param threshold Threshold for the guardians
- * @returns Calls to set up social recovery
- */
-declare function enable(guardians: Account[], threshold?: number): LazyCallInput;
-/**
- * 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, config: RhinestoneConfig): Promise<CalldataInput[]>;
-/**
- * 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, config: RhinestoneConfig): Promise<CalldataInput[]>;
-export { enable, recoverEcdsaOwnership, recoverPasskeyOwnership };
-//# sourceMappingURL=recovery.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../../../actions/recovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,KAAK,KAAK,EAEX,MAAM,MAAM,CAAA;AASb,OAAO,KAAK,EACV,aAAa,EAEb,aAAa,EACb,sBAAsB,EACtB,gBAAgB,EAChB,uBAAuB,EACxB,MAAM,UAAU,CAAA;AAQjB;;;;;GAKG;AACH,iBAAS,MAAM,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,SAAS,SAAI,GAAG,aAAa,CAOlE;AAED;;;;;;;GAOG;AACH,iBAAe,qBAAqB,CAClC,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,aAAa,EAAE,CAAC,CAwG1B;AAED;;;;;;;;GAQG;AACH,iBAAe,uBAAuB,CACpC,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAAE,EACtD,SAAS,EAAE,uBAAuB,EAClC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,aAAa,EAAE,CAAC,CA0F1B;AAED,OAAO,EAAE,MAAM,EAAE,qBAAqB,EAAE,uBAAuB,EAAE,CAAA"}

package/dist/src/actions/recovery.js

@@ -1,189 +0,0 @@
-import { createPublicClient, } from 'viem';
-import { getModuleInstallationCalls } from '../accounts/index.js';
-import { createTransport } from '../accounts/json-rpc/index.js';
-import { resolveCallInputs } from '../execution/utils.js';
-import { getSocialRecoveryValidator, OWNABLE_VALIDATOR_ADDRESS, WEBAUTHN_VALIDATOR_ADDRESS, } from '../modules/validators/core.js';
-import { addOwner, changeThreshold, removeOwner } from './ecdsa.js';
-import { addOwner as addPasskeyOwner, changeThreshold as changePasskeyThreshold, removeOwner as removePasskeyOwner, } from './passkeys.js';
-/**
- * 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 = getSocialRecoveryValidator(guardians, threshold);
-    return {
-        async resolve({ config }) {
-            return 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 = createPublicClient({
-        chain,
-        transport: createTransport(chain, config.provider),
-    });
-    // Read the existing config
-    const results = await publicClient.multicall({
-        contracts: [
-            {
-                address: 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: 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(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(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(removeOwner(prevOwner, ownerToRemove));
-        currentOwners = currentOwners.filter((owner) => owner !== ownerToRemove);
-    }
-    const calls = await 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 = createPublicClient({
-        chain,
-        transport: createTransport(chain, config.provider),
-    });
-    const existingThreshold = await publicClient.readContract({
-        address: 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(changePasskeyThreshold(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(removePasskeyOwner(credential.pubKeyX, credential.pubKeyY));
-    }
-    // Then add new credentials
-    for (const credential of credentialsToAdd) {
-        callInputs.push(addPasskeyOwner(credential.pubKeyX, credential.pubKeyY, credential.requireUV));
-    }
-    const calls = await resolveCallInputs(callInputs, config, chain, address);
-    return calls;
-}
-export { enable, recoverEcdsaOwnership, recoverPasskeyOwnership };