@rhinestone/sdk 2.0.0-beta.8 → 2.0.0

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

@@ -1 +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"}
+{"version":3,"file":"passkeys.d.ts","sourceRoot":"","sources":["../../../actions/passkeys.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACrE,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,gCAAgC,CAAA;AAMvC;;;;;GAKG;AACH,iBAAS,MAAM,CAAC,UAAU,EAAE,kBAAkB,GAAG,aAAa,CAU7D;AAED;;;GAGG;AACH,iBAAS,OAAO,IAAI,aAAa,CAgBhC;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

@@ -1,6 +1,6 @@
 import { encodeFunctionData } from 'viem';
-import { getModuleInstallationCalls, getModuleUninstallationCalls, } from '../accounts/index.js';
-import { getWebAuthnValidator, WEBAUTHN_VALIDATOR_ADDRESS, } from '../modules/validators/core.js';
+import { resolveWebauthnCredentials, WEBAUTHN_VALIDATOR_ADDRESS, } from '../modules/validators/webauthn.js';
+import { resolveModuleInstallation, resolveModuleUninstallation, } from './runtime.js';
 /**
  * Enable passkeys authentication
  * @param pubKey Public key for the passkey
@@ -8,10 +8,13 @@ import { getWebAuthnValidator, WEBAUTHN_VALIDATOR_ADDRESS, } from '../modules/va
  * @returns Calls to enable passkeys authentication
  */
 function enable(credential) {
-    const module = getWebAuthnValidator(1, [credential]);
+    const module = resolveWebauthnCredentials({
+        credentials: [credential],
+        threshold: 1,
+    });
     return {
-        async resolve({ config }) {
-            return getModuleInstallationCalls(config, module);
+        async resolve(context) {
+            return resolveModuleInstallation(context, module);
         },
     };
 }
@@ -20,16 +23,18 @@ function enable(credential) {
  * @returns Calls to disable passkeys authentication
  */
 function disable() {
-    const module = getWebAuthnValidator(1, [
-        {
-            // Mocked values
-            pubKey: '0x580a9af0569ad3905b26a703201b358aa0904236642ebe79b22a19d00d3737637d46f725a5427ae45a9569259bf67e1e16b187d7b3ad1ed70138c4f0409677d1',
-            authenticatorId: '0x',
-        },
-    ]);
+    const module = resolveWebauthnCredentials({
+        threshold: 1,
+        credentials: [
+            {
+                pubKey: '0x580a9af0569ad3905b26a703201b358aa0904236642ebe79b22a19d00d3737637d46f725a5427ae45a9569259bf67e1e16b187d7b3ad1ed70138c4f0409677d1',
+                authenticatorId: '0x',
+            },
+        ],
+    });
     return {
-        async resolve({ config }) {
-            return getModuleUninstallationCalls(config, module);
+        async resolve(context) {
+            return resolveModuleUninstallation(context, module);
         },
     };
 }

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

@@ -0,0 +1,12 @@
+import type { CalldataInput, CallResolveContext, Session } from '../config/account.js';
+import type { ResolvedModule } from '../modules/types.js';
+export declare function resolveValidatorInstallation(context: CallResolveContext, module: ResolvedModule): Promise<CalldataInput[]>;
+export declare function resolveModuleInstallation(context: CallResolveContext, module: ResolvedModule): Promise<CalldataInput[]>;
+export declare function resolveModuleUninstallation(context: CallResolveContext, module: ResolvedModule): Promise<CalldataInput[]>;
+export declare function resolveSessionDisable(input: {
+    readonly context: CallResolveContext;
+    readonly account: `0x${string}`;
+    readonly session: Session;
+    readonly expires?: Date;
+}): Promise<CalldataInput>;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../actions/runtime.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,aAAa,EACb,kBAAkB,EAClB,OAAO,EACR,MAAM,mBAAmB,CAAA;AAQ1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAyEtD,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,aAAa,EAAE,CAAC,CA4C1B;AAED,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,aAAa,EAAE,CAAC,CAM1B;AAED,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,cAAc,GACrB,OAAO,CAAC,aAAa,EAAE,CAAC,CA2B1B;AAED,wBAAsB,qBAAqB,CAAC,KAAK,EAAE;IACjD,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAA;IACpC,QAAQ,CAAC,OAAO,EAAE,KAAK,MAAM,EAAE,CAAA;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,IAAI,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CAwBzB"}

package/dist/src/actions/runtime.js

@@ -0,0 +1,158 @@
+import { encodeFunctionData, maxUint256, size } from 'viem';
+import { createAccountConstruction } from '../accounts/construction.js';
+import { DefaultValidatorAlreadyInitializedError } from '../accounts/error.js';
+import { createAccountAdapter } from '../accounts/registry.js';
+import { materializeRpcReader } from '../clients/rpc/compatibility.js';
+import { resolveStandaloneAccountConfig } from '../config/resolve.js';
+import { assertAccountOwnersConfigured } from '../config/validate.js';
+import { encodeAccountModuleDeInitData, readInstalledModules, readValidatorInitialized, } from '../modules/read-core.js';
+import { OWNABLE_VALIDATOR_ADDRESS } from '../modules/validators/ownable.js';
+import { SESSION_LOCK_TAG } from '../modules/validators/smart-sessions/authorization.js';
+import { encodeDisableSessionCall } from '../modules/validators/smart-sessions/calls.js';
+import { readSessionNonce } from '../modules/validators/smart-sessions/state.js';
+function actionContext(context) {
+    const resolved = resolveStandaloneAccountConfig(context.config, 'current-v2');
+    assertAccountOwnersConfigured(resolved);
+    const module = resolved.sessions.module.source === 'explicit'
+        ? resolved.sessions.module.address
+        : undefined;
+    const compatibilityFallback = resolved.sessions.compatibilityFallback.source === 'explicit'
+        ? resolved.sessions.compatibilityFallback.address
+        : undefined;
+    const chain = {
+        kind: 'evm',
+        id: context.chain.id,
+        caip2: `eip155:${context.chain.id}`,
+    };
+    const construction = createAccountConstruction({
+        material: {
+            account: resolved.account,
+            ...(resolved.owners ? { owner: resolved.owners } : {}),
+            modules: resolved.modules,
+            ...(resolved.initData ? { initData: resolved.initData } : {}),
+            ...(resolved.eoa ? { eoa: resolved.eoa } : {}),
+            sessions: {
+                enabled: resolved.sessions.enabled,
+                environment: context.config.useDevContracts === true
+                    ? 'development'
+                    : 'production',
+                ...(module ? { module } : {}),
+                ...(compatibilityFallback ? { compatibilityFallback } : {}),
+            },
+        },
+        chain,
+        deployed: false,
+    });
+    const adapter = createAccountAdapter(construction);
+    return {
+        resolved,
+        construction,
+        adapter,
+        address: adapter.getIdentity(construction).address,
+    };
+}
+function calls(target, encoded) {
+    return encoded.map((data) => ({ to: target, value: 0n, data }));
+}
+function defaultValidatorConfigured(context, validator) {
+    return (!context.resolved.initData &&
+        context.construction.setup.validators.some((module) => module.address.toLowerCase() === validator.toLowerCase() &&
+            size(module.initData) > 0));
+}
+export async function resolveValidatorInstallation(context, module) {
+    const runtime = actionContext(context);
+    if (runtime.construction.account.kind === 'nexus') {
+        const defaultValidator = OWNABLE_VALIDATOR_ADDRESS;
+        if (module.address.toLowerCase() === defaultValidator.toLowerCase()) {
+            let initialized = defaultValidatorConfigured(runtime, defaultValidator);
+            if (!initialized) {
+                const reader = materializeRpcReader({
+                    chain: context.chain,
+                    provider: context.config.provider,
+                });
+                initialized = await readValidatorInitialized({
+                    rpc: reader.rpc,
+                    chain: reader.chain,
+                    account: runtime.address,
+                    validator: defaultValidator,
+                });
+            }
+            if (initialized)
+                throw new DefaultValidatorAlreadyInitializedError();
+            return [
+                {
+                    to: defaultValidator,
+                    value: 0n,
+                    data: encodeFunctionData({
+                        abi: [
+                            {
+                                type: 'function',
+                                name: 'onInstall',
+                                inputs: [{ type: 'bytes', name: 'data' }],
+                                outputs: [],
+                                stateMutability: 'nonpayable',
+                            },
+                        ],
+                        functionName: 'onInstall',
+                        args: [module.initData],
+                    }),
+                },
+            ];
+        }
+    }
+    return calls(runtime.address, runtime.adapter.encodeModuleInstallation(module));
+}
+export async function resolveModuleInstallation(context, module) {
+    const runtime = actionContext(context);
+    return calls(runtime.address, runtime.adapter.encodeModuleInstallation(module));
+}
+export async function resolveModuleUninstallation(context, module) {
+    const runtime = actionContext(context);
+    let deInitData = module.deInitData;
+    if (module.kind === 'validator' &&
+        ['nexus', 'safe', 'startale'].includes(runtime.construction.account.kind)) {
+        const reader = materializeRpcReader({
+            chain: context.chain,
+            provider: context.config.provider,
+        });
+        const installed = await readInstalledModules({
+            rpc: reader.rpc,
+            chain: reader.chain,
+            accountKind: runtime.construction.account.kind,
+            account: runtime.address,
+            kind: 'validator',
+        });
+        deInitData = encodeAccountModuleDeInitData({
+            accountKind: runtime.construction.account.kind,
+            module,
+            installed,
+        });
+    }
+    return calls(runtime.address, [
+        runtime.adapter.encodeModuleUninstallation({ ...module, deInitData }),
+    ]);
+}
+export async function resolveSessionDisable(input) {
+    const reader = materializeRpcReader({
+        chain: input.session.chain,
+        provider: input.context.config.provider,
+    });
+    const runtimeEnvironment = input.context.config.useDevContracts === true ? 'development' : 'production';
+    const nonce = await readSessionNonce({
+        rpc: reader.rpc,
+        chain: reader.chain,
+        account: input.account,
+        lockTag: SESSION_LOCK_TAG,
+        environment: runtimeEnvironment,
+    });
+    const call = encodeDisableSessionCall({
+        account: input.account,
+        session: input.session,
+        expires: input.expires
+            ? BigInt(Math.floor(input.expires.getTime() / 1000))
+            : maxUint256,
+        nonce,
+        environment: runtimeEnvironment,
+    });
+    return { to: call.target, value: call.value, data: call.data };
+}

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

@@ -1,23 +1,47 @@
 import type { Hex } from 'viem';
-import type { LazyCallInput, SessionInput } from '../types.js';
+import type { LazyCallInput, Session } from '../config/account.js';
 /**
  * Enable smart sessions
  * @returns Calls to enable smart sessions
  */
-declare function experimental_enable(): LazyCallInput;
+declare function enable(): LazyCallInput;
 /**
  * Disable smart sessions
  * @returns Calls to disable smart sessions
  */
-declare function experimental_disable(): LazyCallInput;
+declare function disable(): LazyCallInput;
 /**
  * Enable a smart session
- * @param session session to enable
+ *
+ * The `session` must be a resolved `Session` (the return value of
+ * `toSession(...)`). Re-resolving it here would drop the explicit
+ * `permissions` — a `Session` only carries the derived `actions`, not the
+ * original `SessionDefinition.permissions` — which makes the on-chain digest
+ * computed by `SmartSessionLens.getAndVerifyDigest` diverge from the one
+ * signed in `getSessionDetails`, causing the emissary to reject the enable.
+ *
+ * @param session resolved session to enable
  * @returns Calls to enable the smart session
  */
-declare function experimental_enableSession(session: SessionInput, enableSessionSignature: Hex, hashesAndChainIds: {
+declare function enableSession(session: Session, enableSessionSignature: Hex, hashesAndChainIds: {
     chainId: bigint;
     sessionDigest: Hex;
 }[], sessionToEnableIndex: number): LazyCallInput;
-export { experimental_disable, experimental_enable, experimental_enableSession };
+/**
+ * Disable a smart session
+ *
+ * Removes a single session from the smart-session emissary via `removeConfig`.
+ * The account executes the call itself, so the emissary skips the disable
+ * user-signature — the user authorizes it by signing the outer transaction as
+ * usual (no separate, blind session-digest signature). The `session` must be a
+ * resolved `Session` (the return value of `toSession(...)`) on the chain where
+ * the session is being disabled.
+ *
+ * @param session resolved session to disable
+ * @param expires optional deadline after which this disable call is no longer
+ *   valid; must be in the future. Omit for no expiry.
+ * @returns Calls to disable the smart session
+ */
+declare function disableSession(session: Session, expires?: Date): LazyCallInput;
+export { disable, disableSession, enable, enableSession };
 //# sourceMappingURL=smart-sessions.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../actions/smart-sessions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAU/B,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAE3D;;;GAGG;AACH,iBAAS,mBAAmB,IAAI,aAAa,CAU5C;AAED;;;GAGG;AACH,iBAAS,oBAAoB,IAAI,aAAa,CAU7C;AAED;;;;GAIG;AACH,iBAAS,0BAA0B,CACjC,OAAO,EAAE,YAAY,EACrB,sBAAsB,EAAE,GAAG,EAC3B,iBAAiB,EAAE;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,GAAG,CAAA;CACnB,EAAE,EACH,oBAAoB,EAAE,MAAM,GAC3B,aAAa,CAmBf;AAED,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,CAAA"}
+{"version":3,"file":"smart-sessions.d.ts","sourceRoot":"","sources":["../../../actions/smart-sessions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAC/B,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAA;AAwB/D;;;GAGG;AACH,iBAAS,MAAM,IAAI,aAAa,CAU/B;AAED;;;GAGG;AACH,iBAAS,OAAO,IAAI,aAAa,CAUhC;AAED;;;;;;;;;;;;GAYG;AACH,iBAAS,aAAa,CACpB,OAAO,EAAE,OAAO,EAChB,sBAAsB,EAAE,GAAG,EAC3B,iBAAiB,EAAE;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,EAAE,GAAG,CAAA;CACnB,EAAE,EACH,oBAAoB,EAAE,MAAM,GAC3B,aAAa,CAcf;AAED;;;;;;;;;;;;;;GAcG;AACH,iBAAS,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,IAAI,GAAG,aAAa,CAWvE;AAED,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,aAAa,EAAE,CAAA"}

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

@@ -1,17 +1,28 @@
-import { getModuleInstallationCalls, getModuleUninstallationCalls, } from '../accounts/index.js';
-import { getEnableSessionCall, getSmartSessionValidator, toSession, } from '../modules/validators/smart-sessions.js';
+import { encodeEnableSessionCall } from '../modules/validators/smart-sessions/calls.js';
+import { resolveSmartSessionModule } from '../modules/validators/smart-sessions/module.js';
+import { resolveModuleInstallation, resolveModuleUninstallation, resolveSessionDisable, } from './runtime.js';
+function environment(useDevContracts) {
+    return useDevContracts === true ? 'development' : 'production';
+}
+function sessionModule(config) {
+    return resolveSmartSessionModule({
+        enabled: config.sessions?.enabled ?? false,
+        address: config.sessions?.module,
+        environment: environment(config.useDevContracts),
+    });
+}
 /**
  * Enable smart sessions
  * @returns Calls to enable smart sessions
  */
-function experimental_enable() {
+function enable() {
     return {
-        async resolve({ config }) {
-            const module = getSmartSessionValidator(config);
+        async resolve(context) {
+            const module = sessionModule(context.config);
             if (!module) {
                 return [];
             }
-            return getModuleInstallationCalls(config, module);
+            return resolveModuleInstallation(context, module);
         },
     };
 }
@@ -19,30 +30,70 @@ function experimental_enable() {
  * Disable smart sessions
  * @returns Calls to disable smart sessions
  */
-function experimental_disable() {
+function disable() {
     return {
-        async resolve({ config }) {
-            const module = getSmartSessionValidator(config);
+        async resolve(context) {
+            const module = sessionModule(context.config);
             if (!module) {
                 return [];
             }
-            return getModuleUninstallationCalls(config, module);
+            return resolveModuleUninstallation(context, module);
         },
     };
 }
 /**
  * Enable a smart session
- * @param session session to enable
+ *
+ * The `session` must be a resolved `Session` (the return value of
+ * `toSession(...)`). Re-resolving it here would drop the explicit
+ * `permissions` — a `Session` only carries the derived `actions`, not the
+ * original `SessionDefinition.permissions` — which makes the on-chain digest
+ * computed by `SmartSessionLens.getAndVerifyDigest` diverge from the one
+ * signed in `getSessionDetails`, causing the emissary to reject the enable.
+ *
+ * @param session resolved session to enable
  * @returns Calls to enable the smart session
  */
-function experimental_enableSession(session, enableSessionSignature, hashesAndChainIds, sessionToEnableIndex) {
+function enableSession(session, enableSessionSignature, hashesAndChainIds, sessionToEnableIndex) {
+    return {
+        async resolve({ accountAddress, config }) {
+            const call = encodeEnableSessionCall({
+                account: accountAddress,
+                session: session,
+                userSignature: enableSessionSignature,
+                hashesAndChainIds,
+                sessionToEnableIndex,
+                environment: environment(config.useDevContracts),
+            });
+            return { to: call.target, value: call.value, data: call.data };
+        },
+    };
+}
+/**
+ * Disable a smart session
+ *
+ * Removes a single session from the smart-session emissary via `removeConfig`.
+ * The account executes the call itself, so the emissary skips the disable
+ * user-signature — the user authorizes it by signing the outer transaction as
+ * usual (no separate, blind session-digest signature). The `session` must be a
+ * resolved `Session` (the return value of `toSession(...)`) on the chain where
+ * the session is being disabled.
+ *
+ * @param session resolved session to disable
+ * @param expires optional deadline after which this disable call is no longer
+ *   valid; must be in the future. Omit for no expiry.
+ * @returns Calls to disable the smart session
+ */
+function disableSession(session, expires) {
     return {
-        async resolve({ accountAddress, chain, config }) {
-            return getEnableSessionCall(accountAddress, toSession({
-                ...session,
-                chain,
-            }, { useDevContracts: config.useDevContracts }), enableSessionSignature, hashesAndChainIds, sessionToEnableIndex, config.useDevContracts);
+        async resolve(context) {
+            return resolveSessionDisable({
+                context,
+                account: context.accountAddress,
+                session,
+                ...(expires ? { expires } : {}),
+            });
         },
     };
 }
-export { experimental_disable, experimental_enable, experimental_enableSession };
+export { disable, disableSession, enable, enableSession };