Merge pull request #750 from 0xsequence/sessions-identity

ScreamingHawk · web-flow · commit 6b719f8fa8ad · 2025-05-08T14:11:07.000+12:00
Address comparison and attestation fix
diff --git a/packages/wallet/core/src/envelope.ts b/packages/wallet/core/src/envelope.ts
@@ -33,12 +33,15 @@ export type Signed<T extends Payload.Payload> = Envelope<T> & {
 
 export function signatureForLeaf(envelope: Signed<Payload.Payload>, leaf: Config.Leaf) {
   if (Config.isSignerLeaf(leaf)) {
-    return envelope.signatures.find((sig) => isSignature(sig) && sig.address === leaf.address)
+    return envelope.signatures.find((sig) => isSignature(sig) && Address.isEqual(sig.address, leaf.address))
   }
 
   if (Config.isSapientSignerLeaf(leaf)) {
     return envelope.signatures.find(
-      (sig) => isSapientSignature(sig) && sig.imageHash === leaf.imageHash && sig.signature.address === leaf.address,
+      (sig) =>
+        isSapientSignature(sig) &&
+        sig.imageHash === leaf.imageHash &&
+        Address.isEqual(sig.signature.address, leaf.address),
     )
   }
 
@@ -89,7 +92,7 @@ export function addSignature(
     const prev = envelope.signatures.find(
       (sig) =>
         isSapientSignature(sig) &&
-        sig.signature.address === signature.signature.address &&
+        Address.isEqual(sig.signature.address, signature.signature.address) &&
         sig.imageHash === signature.imageHash,
     ) as SapientSignature | undefined
 
@@ -110,9 +113,9 @@ export function addSignature(
     envelope.signatures.push(signature)
   } else if (isSignature(signature)) {
     // Find if the signature already exists in envelope
-    const prev = envelope.signatures.find((sig) => isSignature(sig) && sig.address === signature.address) as
-      | Signature
-      | undefined
+    const prev = envelope.signatures.find(
+      (sig) => isSignature(sig) && Address.isEqual(sig.address, signature.address),
+    ) as Signature | undefined
 
     if (prev) {
       // If the signatures are identical, then we can do nothing
diff --git a/packages/wallet/core/src/signers/passkey.ts b/packages/wallet/core/src/signers/passkey.ts
@@ -203,7 +203,9 @@ export class Passkey implements SapientSigner, Witnessable {
     // Flatten and remove duplicates
     const flattened = signers
       .flat()
-      .filter((v, i, self) => self.findIndex((t) => t.wallet === v.wallet && t.imageHash === v.imageHash) === i)
+      .filter(
+        (v, i, self) => self.findIndex((t) => Address.isEqual(t.wallet, v.wallet) && t.imageHash === v.imageHash) === i,
+      )
 
     // If there are no signers, return undefined
     if (flattened.length === 0) {
diff --git a/packages/wallet/core/src/signers/session/explicit.ts b/packages/wallet/core/src/signers/session/explicit.ts
@@ -1,11 +1,11 @@
 import { Payload, Permission, SessionSignature, Utils } from '@0xsequence/wallet-primitives'
 import { AbiParameters, Address, Bytes, Hash, Hex, Provider, Secp256k1 } from 'ox'
-import { SignerInterface } from './session.js'
+import { SessionSigner } from './session.js'
 import { MemoryPkStore, PkStore } from '../pk/index.js'
 
 export type ExplicitParams = Omit<Permission.SessionPermissions, 'signer'>
 
-export class Explicit implements SignerInterface {
+export class Explicit implements SessionSigner {
   private readonly _privateKey: PkStore
 
   public readonly address: Address.Address
diff --git a/packages/wallet/core/src/signers/session/implicit.ts b/packages/wallet/core/src/signers/session/implicit.ts
@@ -1,11 +1,11 @@
 import { Attestation, Payload, Signature as SequenceSignature, SessionSignature } from '@0xsequence/wallet-primitives'
 import { AbiFunction, Address, Bytes, Hex, Provider, Secp256k1, Signature } from 'ox'
 import { MemoryPkStore, PkStore } from '../pk/index.js'
-import { SignerInterface } from './session.js'
+import { SessionSigner } from './session.js'
 
 export type AttestationParams = Omit<Attestation.Attestation, 'approvedSigner'>
 
-export class Implicit implements SignerInterface {
+export class Implicit implements SessionSigner {
   private readonly _privateKey: PkStore
   private readonly _identitySignature: SequenceSignature.RSY
   public readonly address: Address.Address
diff --git a/packages/wallet/core/src/signers/session/session.ts b/packages/wallet/core/src/signers/session/session.ts
@@ -1,8 +1,8 @@
 import { Address, Provider } from 'ox'
 import { Payload, SessionSignature } from '@0xsequence/wallet-primitives'
 
-export interface SignerInterface {
-  address: Address.Address
+export interface SessionSigner {
+  address: Address.Address | Promise<Address.Address>
 
   /// Check if the signer supports the call
   supportedCall: (
diff --git a/packages/wallet/core/src/state/local/index.ts b/packages/wallet/core/src/state/local/index.ts
@@ -271,7 +271,7 @@ export class Provider implements ProviderInterface {
         if (Config.isSapientSignerLeaf(leaf)) {
           const sapientSignature = signaturesOfSigners.find(
             ({ signer, imageHash }: { signer: Address.Address; imageHash?: Hex.Hex }) => {
-              return imageHash && signer === leaf.address && imageHash === leaf.imageHash
+              return imageHash && Address.isEqual(signer, leaf.address) && imageHash === leaf.imageHash
             },
           )?.signature
 
@@ -281,7 +281,7 @@ export class Provider implements ProviderInterface {
           }
         }
 
-        const signature = signaturesOfSigners.find(({ signer }) => signer === leaf.address)?.signature
+        const signature = signaturesOfSigners.find(({ signer }) => Address.isEqual(signer, leaf.address))?.signature
         if (!signature) {
           return undefined
         }
diff --git a/packages/wallet/primitives-cli/src/subcommands/signature.ts b/packages/wallet/primitives-cli/src/subcommands/signature.ts
@@ -1,5 +1,5 @@
 import { Config, Signature } from '@0xsequence/wallet-primitives'
-import { Bytes, Hex, Signature as OxSignature } from 'ox'
+import { Address, Bytes, Hex, Signature as OxSignature } from 'ox'
 import { type CommandModule } from 'yargs'
 import { fromPosOrStdin } from '../utils.js'
 import { PossibleElements } from './config.js'
@@ -43,7 +43,7 @@ export async function doEncode(
   const allSignatures = signatures.map((s) => {
     const values = s.split(':')
     return {
-      address: values[0],
+      address: Address.from(values[0] as `0x${string}`),
       type: values[1],
       values: values.slice(2),
     }
@@ -52,7 +52,7 @@ export async function doEncode(
   const fullTopology = Signature.fillLeaves(config.topology, (leaf) => {
     if (Config.isSignerLeaf(leaf)) {
       // Type must be 1271, eth_sign, or hash
-      const candidate = allSignatures.find((s) => s.address === leaf.address)
+      const candidate = allSignatures.find((s) => Address.isEqual(s.address, leaf.address))
 
       if (!candidate) {
         return undefined
@@ -92,7 +92,7 @@ export async function doEncode(
     }
 
     if (Config.isSapientSignerLeaf(leaf)) {
-      const candidate = allSignatures.find((s) => s.address === leaf.address)
+      const candidate = allSignatures.find((s) => Address.isEqual(s.address, leaf.address))
       if (!candidate) {
         return undefined
       }
diff --git a/packages/wallet/primitives/src/config.ts b/packages/wallet/primitives/src/config.ts
@@ -149,11 +149,11 @@ export function findSignerLeaf(
   } else if (isNode(configuration)) {
     return findSignerLeaf(configuration[0], address) || findSignerLeaf(configuration[1], address)
   } else if (isSignerLeaf(configuration)) {
-    if (configuration.address === address) {
+    if (Address.isEqual(configuration.address, address)) {
       return configuration
     }
   } else if (isSapientSignerLeaf(configuration)) {
-    if (configuration.address === address) {
+    if (Address.isEqual(configuration.address, address)) {
       return configuration
     }
   }
diff --git a/packages/wallet/primitives/src/session-config.ts b/packages/wallet/primitives/src/session-config.ts
@@ -166,7 +166,7 @@ export function getImplicitBlacklistLeaf(topology: SessionsTopology): ImplicitBl
 
 export function getSessionPermissions(topology: SessionsTopology, address: Address.Address): SessionPermissions | null {
   if (isSessionPermissions(topology)) {
-    if (topology.signer === address) {
+    if (Address.isEqual(topology.signer, address)) {
       return topology
     }
   }
@@ -426,7 +426,7 @@ export function removeExplicitSession(
   signerAddress: `0x${string}`,
 ): SessionsTopology | null {
   if (isSessionPermissions(topology)) {
-    if (topology.signer === signerAddress) {
+    if (Address.isEqual(topology.signer, signerAddress)) {
       return null
     }
     // Return the leaf unchanged
@@ -642,7 +642,7 @@ export function addToImplicitBlacklist(topology: SessionsTopology, address: Addr
     throw new Error('No blacklist found')
   }
   const { blacklist } = blacklistNode
-  if (blacklist.some((addr) => addr === address)) {
+  if (blacklist.some((addr) => Address.isEqual(addr, address))) {
     return topology
   }
   blacklist.push(address)
diff --git a/packages/wallet/wdk/src/identity/signer.ts b/packages/wallet/wdk/src/identity/signer.ts
@@ -14,7 +14,7 @@ export class IdentitySigner implements Signers.Signer {
     if (!Address.validate(this.authKey.identitySigner)) {
       throw new Error('No signer address found')
     }
-    return this.authKey.identitySigner
+    return Address.checksum(this.authKey.identitySigner)
   }
 
   async sign(
diff --git a/packages/wallet/wdk/src/sequence/handlers/authcode-pkce.ts b/packages/wallet/wdk/src/sequence/handlers/authcode-pkce.ts
@@ -82,10 +82,12 @@ export class AuthCodePkceHandler extends IdentityHandler implements Handler {
     _imageHash: Hex.Hex | undefined,
     request: BaseSignatureRequest,
   ): Promise<SignerUnavailable | SignerReady | SignerActionable> {
-    const signer = await this.getAuthKeySigner(address)
+    // Normalize address
+    const normalizedAddress = Address.checksum(address)
+    const signer = await this.getAuthKeySigner(normalizedAddress)
     if (signer) {
       return {
-        address,
+        address: normalizedAddress,
         handler: this,
         status: 'ready',
         handle: async () => {
@@ -96,12 +98,12 @@ export class AuthCodePkceHandler extends IdentityHandler implements Handler {
     }
 
     return {
-      address,
+      address: normalizedAddress,
       handler: this,
       status: 'actionable',
       message: 'request-redirect',
       handle: async () => {
-        const url = await this.commitAuth(window.location.pathname, false, request.id, address.toString())
+        const url = await this.commitAuth(window.location.pathname, false, request.id, normalizedAddress)
         window.location.href = url
         return true
       },
diff --git a/packages/wallet/wdk/src/sequence/manager.ts b/packages/wallet/wdk/src/sequence/manager.ts
@@ -55,7 +55,7 @@ export type ManagerOptions = {
 
   stateProvider?: State.Provider
   networks?: Network.Network[]
-  relayers?: Relayer.Relayer[]
+  relayers?: Relayer.Relayer[] | (() => Relayer.Relayer[])
 
   defaultGuardTopology?: Config.Topology
   defaultRecoverySettings?: RecoverySettings
diff --git a/packages/wallet/wdk/src/sequence/recovery.ts b/packages/wallet/wdk/src/sequence/recovery.ts
@@ -86,7 +86,7 @@ export class Recovery {
   }
 
   hasRecoveryModule(modules: Config.SapientSignerLeaf[]): boolean {
-    return modules.some((m) => m.address === this.shared.sequence.extensions.recovery)
+    return modules.some((m) => Address.isEqual(m.address, this.shared.sequence.extensions.recovery))
   }
 
   async addRecoverySignerToModules(modules: Config.SapientSignerLeaf[], address: Address.Address) {
@@ -95,11 +95,11 @@ export class Recovery {
     }
 
     await this.updateRecoveryModule(modules, (leaves) => {
-      if (leaves.some((l) => l.signer === address)) {
+      if (leaves.some((l) => Address.isEqual(l.signer, address))) {
         return leaves
       }
 
-      const filtered = leaves.filter((l) => l.signer !== '0x0000000000000000000000000000000000000000')
+      const filtered = leaves.filter((l) => !Address.isEqual(l.signer, '0x0000000000000000000000000000000000000000'))
 
       return [
         ...filtered,
@@ -184,7 +184,7 @@ export class Recovery {
 
   async getRecoverySigners(address: Address.Address): Promise<RecoverySigner[] | undefined> {
     const { raw } = await this.shared.modules.wallets.getConfiguration({ wallet: address })
-    const recoveryLeaf = raw.modules.find((m) => m.address === this.shared.sequence.extensions.recovery)
+    const recoveryLeaf = raw.modules.find((m) => Address.isEqual(m.address, this.shared.sequence.extensions.recovery))
     if (!recoveryLeaf) {
       return undefined
     }
@@ -206,10 +206,10 @@ export class Recovery {
     )
 
     return leaves
-      .filter((l) => l.signer !== '0x0000000000000000000000000000000000000000')
+      .filter((l) => !Address.isEqual(l.signer, '0x0000000000000000000000000000000000000000'))
       .map((l) => ({
         address: l.signer,
-        kind: kos.find((s) => s.address === l.signer)?.kind || 'unknown',
+        kind: kos.find((s) => Address.isEqual(s.address, l.signer))?.kind || 'unknown',
         isRecovery: true,
         minTimestamp: l.minTimestamp,
         requiredDeltaTime: l.requiredDeltaTime,
@@ -296,7 +296,7 @@ export class Recovery {
   async getQueuedRecoveryPayloads(wallet?: Address.Address): Promise<QueuedRecoveryPayload[]> {
     const all = await this.shared.databases.recovery.list()
     if (wallet) {
-      return all.filter((p) => p.wallet === wallet)
+      return all.filter((p) => Address.isEqual(p.wallet, wallet))
     }
 
     return all
diff --git a/packages/wallet/wdk/src/sequence/sessions.ts b/packages/wallet/wdk/src/sequence/sessions.ts
@@ -8,7 +8,7 @@ import {
   Signature as SequenceSignature,
   SessionConfig,
 } from '@0xsequence/wallet-primitives'
-import { Address, Bytes, Hex } from 'ox'
+import { Address, Bytes, Hash, Hex } from 'ox'
 import { IdentityType } from '../identity/index.js'
 import { AuthCodePkceHandler } from './handlers/authcode-pkce.js'
 import { IdentityHandler, identityTypeToHex } from './handlers/identity.js'
@@ -70,10 +70,8 @@ export class Sessions {
     if (handler instanceof IdentityHandler) {
       identityType = handler.identityType
       if (handler instanceof AuthCodePkceHandler) {
-        Hex.assert(handler.issuer)
-        Hex.assert(handler.audience)
-        issuerHash = handler.issuer
-        audienceHash = handler.audience
+        issuerHash = Hash.keccak256(Hex.fromString(handler.issuer))
+        audienceHash = Hash.keccak256(Hex.fromString(handler.audience))
       }
     }
     const attestation: Attestation.Attestation = {
diff --git a/packages/wallet/wdk/src/sequence/signatures.ts b/packages/wallet/wdk/src/sequence/signatures.ts
@@ -1,6 +1,6 @@
 import { Envelope } from '@0xsequence/wallet-core'
 import { Config, Payload } from '@0xsequence/wallet-primitives'
-import { Hex } from 'ox'
+import { Address, Hex } from 'ox'
 import { v7 as uuidv7 } from 'uuid'
 import { Shared } from './manager.js'
 import {
@@ -81,9 +81,9 @@ export class Signatures {
         // We may have a signature for this signer already
         const signed = request.envelope.signatures.some((sig) => {
           if (Envelope.isSapientSignature(sig)) {
-            return sig.signature.address === sak.address && sig.imageHash === sak.imageHash
+            return Address.isEqual(sig.signature.address, sak.address) && sig.imageHash === sak.imageHash
           }
-          return sig.address === sak.address
+          return Address.isEqual(sig.address, sak.address)
         })
 
         if (!sak.kind) {
@@ -180,7 +180,7 @@ export class Signatures {
       const pendingRequests = await this.shared.databases.signatures.list()
       const pendingConfigUpdatesToClear = pendingRequests.filter(
         (sig) =>
-          sig.wallet === request.wallet &&
+          Address.isEqual(sig.wallet, request.wallet) &&
           sig.envelope.payload.type === 'config-update' &&
           sig.envelope.configuration.checkpoint <= request.envelope.configuration.checkpoint,
       )
diff --git a/packages/wallet/wdk/src/sequence/signers.ts b/packages/wallet/wdk/src/sequence/signers.ts
@@ -33,7 +33,7 @@ export class Signers {
 
     // Some signers are known by the configuration of the wallet development kit, specifically
     // some of the sapient signers, who always share the same address
-    if (this.shared.sequence.extensions.recovery === address) {
+    if (Address.isEqual(this.shared.sequence.extensions.recovery, address)) {
       return Kinds.Recovery
     }
 
diff --git a/packages/wallet/wdk/src/sequence/wallets.ts b/packages/wallet/wdk/src/sequence/wallets.ts
@@ -629,7 +629,7 @@ export class Wallets {
       }
 
       const wallet = await args.selectWallet(wallets.map((w) => w.wallet))
-      if (!wallets.some((w) => w.wallet === wallet)) {
+      if (!wallets.some((w) => Address.isEqual(w.wallet, wallet))) {
         throw new Error('wallet-not-found')
       }
 
@@ -651,7 +651,7 @@ export class Wallets {
       }
 
       const wallet = await args.selectWallet(wallets.map((w) => w.wallet))
-      if (!wallets.some((w) => w.wallet === wallet)) {
+      if (!wallets.some((w) => Address.isEqual(w.wallet, wallet))) {
         throw new Error('wallet-not-found')
       }
 
diff --git a/packages/wallet/wdk/test/sessions.test.ts b/packages/wallet/wdk/test/sessions.test.ts
@@ -4,7 +4,6 @@ import { Signers as CoreSigners, Wallet as CoreWallet, Envelope, Relayer, State
 import { Attestation, Constants, Payload, Permission } from '../../primitives/src/index.js'
 import { Sequence } from '../src/index.js'
 import { CAN_RUN_LIVE, EMITTER_ABI, EMITTER_ADDRESS, PRIVATE_KEY, RPC_URL } from './constants'
-import { SignerActionable } from '../src/sequence/index.js'
 
 describe('Sessions (via Manager)', () => {
   // Shared components
@@ -195,10 +194,10 @@ describe('Sessions (via Manager)', () => {
       // Sign and complete the request
       const sigRequest = await wdk.manager.getSignatureRequest(requestId)
       const identitySigner = sigRequest.signers.find((s) => s.address === wdk.identitySignerAddress)
-      if (!identitySigner || identitySigner.status !== 'actionable') {
-        throw new Error(`Identity signer not found or not ready: ${identitySigner?.status}`)
+      if (!identitySigner || (identitySigner.status !== 'actionable' && identitySigner.status !== 'ready')) {
+        throw new Error(`Identity signer not found or not ready/actionable: ${identitySigner?.status}`)
       }
-      const handled = await (identitySigner as SignerActionable).handle()
+      const handled = await identitySigner.handle()
       if (!handled) {
         throw new Error('Failed to handle identity signer')
       }
@@ -256,10 +255,10 @@ describe('Sessions (via Manager)', () => {
       // Sign the request (Wallet UI action)
       const sigRequest = await wdk.manager.getSignatureRequest(requestId)
       const identitySigner = sigRequest.signers[0]
-      if (!identitySigner || identitySigner.status !== 'actionable') {
-        throw new Error(`Identity signer not found or not actionable: ${identitySigner?.status}`)
+      if (!identitySigner || (identitySigner.status !== 'actionable' && identitySigner.status !== 'ready')) {
+        throw new Error(`Identity signer not found or not ready/actionable: ${identitySigner?.status}`)
       }
-      const handled = await (identitySigner as SignerActionable).handle()
+      const handled = await identitySigner.handle()
       if (!handled) {
         throw new Error('Failed to handle identity signer')
       }

Original file line number	Diff line number	Diff line change
`@@ -271,7 +271,7 @@ export class Provider implements ProviderInterface {`
`271`	`271`	`if (Config.isSapientSignerLeaf(leaf)) {`
`272`	`272`	`const sapientSignature = signaturesOfSigners.find(`
`273`	`273`	`({ signer, imageHash }: { signer: Address.Address; imageHash?: Hex.Hex }) => {`
`274`		`- return imageHash && signer === leaf.address && imageHash === leaf.imageHash`
	`274`	`+ return imageHash && Address.isEqual(signer, leaf.address) && imageHash === leaf.imageHash`
`275`	`275`	`},`
`276`	`276`	`)?.signature`
`277`	`277`
`@@ -281,7 +281,7 @@ export class Provider implements ProviderInterface {`
`281`	`281`	`}`
`282`	`282`	`}`
`283`	`283`
`284`		`- const signature = signaturesOfSigners.find(({ signer }) => signer === leaf.address)?.signature`
	`284`	`+ const signature = signaturesOfSigners.find(({ signer }) => Address.isEqual(signer, leaf.address))?.signature`
`285`	`285`	`if (!signature) {`
`286`	`286`	`return undefined`
`287`	`287`	`}`
Original file line number	Diff line number	Diff line change
`@@ -149,11 +149,11 @@ export function findSignerLeaf(`
`149`	`149`	`} else if (isNode(configuration)) {`
`150`	`150`	`return findSignerLeaf(configuration[0], address) \|\| findSignerLeaf(configuration[1], address)`
`151`	`151`	`} else if (isSignerLeaf(configuration)) {`
`152`		`- if (configuration.address === address) {`
	`152`	`+ if (Address.isEqual(configuration.address, address)) {`
`153`	`153`	`return configuration`
`154`	`154`	`}`
`155`	`155`	`} else if (isSapientSignerLeaf(configuration)) {`
`156`		`- if (configuration.address === address) {`
	`156`	`+ if (Address.isEqual(configuration.address, address)) {`
`157`	`157`	`return configuration`
`158`	`158`	`}`
`159`	`159`	`}`
Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,7 @@ export function getImplicitBlacklistLeaf(topology: SessionsTopology): ImplicitBl`
`166`	`166`
`167`	`167`	`export function getSessionPermissions(topology: SessionsTopology, address: Address.Address): SessionPermissions \| null {`
`168`	`168`	`if (isSessionPermissions(topology)) {`
`169`		`- if (topology.signer === address) {`
	`169`	`+ if (Address.isEqual(topology.signer, address)) {`
`170`	`170`	`return topology`
`171`	`171`	`}`
`172`	`172`	`}`
`@@ -426,7 +426,7 @@ export function removeExplicitSession(`
`426`	`426`	signerAddress: `0x${string}`,
`427`	`427`	`): SessionsTopology \| null {`
`428`	`428`	`if (isSessionPermissions(topology)) {`
`429`		`- if (topology.signer === signerAddress) {`
	`429`	`+ if (Address.isEqual(topology.signer, signerAddress)) {`
`430`	`430`	`return null`
`431`	`431`	`}`
`432`	`432`	`// Return the leaf unchanged`
`@@ -642,7 +642,7 @@ export function addToImplicitBlacklist(topology: SessionsTopology, address: Addr`
`642`	`642`	`throw new Error('No blacklist found')`
`643`	`643`	`}`
`644`	`644`	`const { blacklist } = blacklistNode`
`645`		`- if (blacklist.some((addr) => addr === address)) {`
	`645`	`+ if (blacklist.some((addr) => Address.isEqual(addr, address))) {`
`646`	`646`	`return topology`
`647`	`647`	`}`
`648`	`648`	`blacklist.push(address)`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ export class IdentitySigner implements Signers.Signer {`
`14`	`14`	`if (!Address.validate(this.authKey.identitySigner)) {`
`15`	`15`	`throw new Error('No signer address found')`
`16`	`16`	`}`
`17`		`- return this.authKey.identitySigner`
	`17`	`+ return Address.checksum(this.authKey.identitySigner)`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`async sign(`