Add sessions to manager

Author: ScreamingHawk

packages/core/src/signers/session-manager.ts

@@ -13,7 +13,7 @@ import { State } from '..'
 
 type SessionManagerConfiguration = {
   topology: SessionConfig.SessionsTopology
-  provider: Provider.Provider
+  provider?: Provider.Provider
   implicitSigners?: Implicit[]
   explicitSigners?: Explicit[]
   address?: Address.Address
@@ -22,7 +22,7 @@ type SessionManagerConfiguration = {
 export class SessionManager implements SapientSigner {
   private readonly _address: Address.Address
   private readonly _topology: SessionConfig.SessionsTopology
-  private readonly _provider: Provider.Provider
+  private readonly _provider: Provider.Provider | undefined
   private readonly _implicitSigners: Implicit[]
   private readonly _explicitSigners: Explicit[]
 
@@ -159,13 +159,17 @@ export class SessionManager implements SapientSigner {
       throw new Error('Only calls are supported')
     }
 
+    if (!this._provider) {
+      throw new Error('Provider not set')
+    }
+
     // Try to sign with each signer, prioritizing implicit signers
     const signers = [...this._implicitSigners, ...this._explicitSigners]
     const signatures = await Promise.all(
       //FIXME Run sync to support cumulative rules within a payload
       payload.calls.map(async (call) => {
         for (const signer of signers) {
-          if (await signer.supportedCall(wallet, chainId, call, this._provider)) {
+          if (this._provider && (await signer.supportedCall(wallet, chainId, call, this._provider))) {
             const signature = await signer.signCall(wallet, chainId, call, payload, this._provider)
             return {
               ...signature,
@@ -202,6 +206,11 @@ export class SessionManager implements SapientSigner {
       // Only calls are supported
       return false
     }
+
+    if (!this._provider) {
+      throw new Error('Provider not set')
+    }
+
     const encodedPayload = Payload.encodeSapient(chainId, payload)
     const encodedCallData = AbiFunction.encodeData(Constants.RECOVER_SAPIENT_SIGNATURE, [
       encodedPayload,

packages/wdk/src/sequence/index.ts

@@ -1,6 +1,7 @@
 import { Network } from '@0xsequence/sequence-primitives'
 
 export * from './manager'
+export * from './sessions'
 export * from './signatures'
 export * from './wallets'
 export * from './types'

packages/wdk/src/sequence/manager.ts

@@ -1,21 +1,21 @@
+import { Signers as CoreSigners, Relayer, State } from '@0xsequence/sequence-core'
+import { Config, Constants, Context, Extensions, Network, Payload } from '@0xsequence/sequence-primitives'
 import { Address } from 'ox'
-
-import { Extensions, Context, Config, Constants, Network, Payload } from '@0xsequence/sequence-primitives'
-import { Signers as CoreSigners, State, Relayer } from '@0xsequence/sequence-core'
 import * as Db from '../dbs'
-import { Logger } from './logger'
+import * as Identity from '../identity'
 import { Devices } from './devices'
-import { CompleteRedirectArgs, LoginArgs, SignupArgs, StartSignUpWithRedirectArgs, Wallets } from './wallets'
-import { Transactions } from './transactions'
-import { Signatures } from './signatures'
-import { Kinds, Signers } from './signers'
 import { DevicesHandler, Handler, PasskeysHandler } from './handlers'
+import { AuthCodePkceHandler } from './handlers/authcode-pkce'
 import { MnemonicHandler } from './handlers/mnemonic'
-import { RelayerOption, TransactionRequest, Transaction } from './types/transactionRequest'
-import { BaseSignatureRequest, SignatureRequest, Wallet } from './types'
 import { OtpHandler } from './handlers/otp'
-import { AuthCodePkceHandler } from './handlers/authcode-pkce'
-import * as Identity from '../identity'
+import { Logger } from './logger'
+import { Sessions } from './sessions'
+import { Signatures } from './signatures'
+import { Kinds, Signers } from './signers'
+import { Transactions } from './transactions'
+import { BaseSignatureRequest, SignatureRequest, Wallet } from './types'
+import { Transaction, TransactionRequest } from './types/transactionRequest'
+import { CompleteRedirectArgs, LoginArgs, SignupArgs, StartSignUpWithRedirectArgs, Wallets } from './wallets'
 
 export type ManagerOptions = {
   verbose?: boolean
@@ -60,6 +60,13 @@ export const ManagerOptionsDefaults = {
     address: '0xf71eC72C8C03a0857DD7601ACeF1e42b85983e99',
     weight: 1n,
   } as Config.SignerLeaf,
+
+  defaultSessionTopology: {
+    // TODO: Move this somewhere else
+    type: 'sapient-signer',
+    address: Constants.DefaultSessionManager,
+    weight: 1n,
+  } as Omit<Config.SapientSignerLeaf, 'imageHash'>,
 }
 
 export const CreateWalletOptionsDefaults = {
@@ -89,12 +96,14 @@ export type Sequence = {
   readonly relayers: Relayer.Relayer[]
 
   readonly defaultGuardTopology: Config.Topology
+  readonly defaultSessionTopology: Omit<Config.SapientSignerLeaf, 'imageHash'>
 }
 
 export type Modules = {
   readonly logger: Logger
   readonly devices: Devices
   readonly wallets: Wallets
+  readonly sessions: Sessions
   readonly signers: Signers
   readonly signatures: Signatures
   readonly transactions: Transactions
@@ -135,6 +144,7 @@ export class Manager {
         relayers: ops.relayers,
 
         defaultGuardTopology: ops.defaultGuardTopology,
+        defaultSessionTopology: ops.defaultSessionTopology,
       },
 
       databases: {
@@ -153,6 +163,7 @@ export class Manager {
       logger: new Logger(shared),
       devices: new Devices(shared),
       wallets: new Wallets(shared),
+      sessions: new Sessions(shared),
       signers: new Signers(shared),
       signatures: new Signatures(shared),
       transactions: new Transactions(shared),

packages/wdk/src/sequence/sessions.ts

@@ -0,0 +1,40 @@
+import { Wallet } from '@0xsequence/sequence-core'
+import { Config, Constants } from '@0xsequence/sequence-primitives'
+import { Address, Provider, RpcTransport } from 'ox'
+import { SessionController } from '../session'
+import { Shared } from './manager'
+
+export class Sessions {
+  constructor(private readonly shared: Shared) {}
+
+  async controllerForWallet(address: Address.Address, chainId?: bigint) {
+    // Find the session configuration for the wallet
+    const wallet = new Wallet(address, {
+      context: this.shared.sequence.context,
+      stateProvider: this.shared.sequence.stateProvider,
+      guest: this.shared.sequence.guest,
+    })
+    const status = await wallet.getStatus()
+    const walletConfig = status.configuration
+    const sessionConfigLeaf = Config.findSignerLeaf(walletConfig, Constants.DefaultSessionManager)
+    if (!sessionConfigLeaf || !Config.isSapientSignerLeaf(sessionConfigLeaf)) {
+      throw new Error(`Session module not found for wallet ${address}`)
+    }
+
+    // Get the provider if available
+    let provider: Provider.Provider | undefined
+    if (chainId) {
+      const network = this.shared.sequence.networks.find((network) => network.chainId === chainId)
+      if (network) {
+        provider = Provider.from(RpcTransport.fromHttp(network.rpc))
+      }
+    }
+
+    // Create the controller
+    const controller = SessionController.createFromStorage(sessionConfigLeaf.imageHash, {
+      wallet,
+      provider,
+    })
+    return controller
+  }
+}

packages/wdk/src/sequence/wallets.ts

@@ -1,13 +1,13 @@
+import { Wallet as CoreWallet, Envelope, Signers, State } from '@0xsequence/sequence-core'
+import { Config, GenericTree, Payload, SessionConfig } from '@0xsequence/sequence-primitives'
 import { Address, Hex } from 'ox'
-import { Envelope, Signers, Wallet as CoreWallet, State } from '@0xsequence/sequence-core'
-import { Config, Payload } from '@0xsequence/sequence-primitives'
-import { Kinds, WitnessExtraSignerKind } from './signers'
-import { Shared } from './manager'
+import { AuthCommitment } from '../dbs/auth-commitments'
+import { AuthCodePkceHandler } from './handlers/authcode-pkce'
 import { MnemonicHandler } from './handlers/mnemonic'
 import { OtpHandler } from './handlers/otp'
+import { Shared } from './manager'
+import { Kinds, WitnessExtraSignerKind } from './signers'
 import { Wallet } from './types'
-import { AuthCodePkceHandler } from './handlers/authcode-pkce'
-import { AuthCommitment } from '../dbs/auth-commitments'
 
 export type StartSignUpWithRedirectArgs = {
   kind: 'google-pkce' | 'apple-pkce'
@@ -17,6 +17,7 @@ export type StartSignUpWithRedirectArgs = {
 
 export type CommonSignupArgs = {
   noGuard?: boolean
+  noSessionManager?: boolean
   onExistingWallets?: (wallets: Address.Address[]) => Promise<boolean>
 }
 
@@ -350,13 +351,13 @@ export class Wallets {
     }
 
     // Build the login tree
+    const loginSignerAddress = await loginSigner.signer.address
     const loginTopology = buildCappedTree([
       {
-        address: await loginSigner.signer.address,
+        address: loginSignerAddress,
         imageHash: Signers.isSapientSigner(loginSigner.signer) ? await loginSigner.signer.imageHash : undefined,
       },
     ])
-
     const devicesTopology = buildCappedTree([{ address: device.address }])
     const guardTopology = args.noGuard
       ? undefined
@@ -365,11 +366,24 @@ export class Wallets {
     // TODO: Add recovery module
     // TODO: Add smart sessions module
     // Placeholder
-    const modules = {
+    let modules: Config.Topology = {
       type: 'signer',
       address: '0x0000000000000000000000000000000000000000',
       weight: 0n,
-    } as Config.SignerLeaf
+    }
+    if (!args.noSessionManager) {
+      // FIXME: Calculate image hash with the identity signer
+      const sessionManagerTopology = SessionConfig.emptySessionsTopology(loginSignerAddress)
+      const sessionConfigTree = SessionConfig.sessionsTopologyToConfigurationTree(sessionManagerTopology)
+      const sessionImageHash = GenericTree.hash(sessionConfigTree)
+      modules = [
+        {
+          ...this.shared.sequence.defaultSessionTopology,
+          imageHash: sessionImageHash,
+        },
+        modules,
+      ]
+    }
 
     // Create initial configuration
     const initialConfiguration = toConfig(0n, loginTopology, devicesTopology, modules, guardTopology)