@0xsequence/wallet-primitives 0.0.0-20250520201059

package/src/config.ts

@@ -0,0 +1,521 @@
+import { Address, Bytes, Hash, Hex } from 'ox'
+import {
+  isRawConfig,
+  isRawNestedLeaf,
+  isRawSignerLeaf,
+  isSignedSapientSignerLeaf,
+  isSignedSignerLeaf,
+  RawConfig,
+  RawTopology,
+  SignatureOfSapientSignerLeaf,
+  SignatureOfSignerLeaf,
+} from './signature.js'
+
+export type SignerLeaf = {
+  type: 'signer'
+  address: Address.Address
+  weight: bigint
+  signed?: boolean
+  signature?: SignatureOfSignerLeaf
+}
+
+export type SapientSignerLeaf = {
+  type: 'sapient-signer'
+  address: Address.Address
+  weight: bigint
+  imageHash: Hex.Hex
+  signed?: boolean
+  signature?: SignatureOfSapientSignerLeaf
+}
+
+export type SubdigestLeaf = {
+  type: 'subdigest'
+  digest: Hex.Hex
+}
+
+export type AnyAddressSubdigestLeaf = {
+  type: 'any-address-subdigest'
+  digest: Hex.Hex
+}
+
+export type NestedLeaf = {
+  type: 'nested'
+  tree: Topology
+  weight: bigint
+  threshold: bigint
+}
+
+export type NodeLeaf = Hex.Hex
+
+export type Node = [Topology, Topology]
+
+export type Leaf = SignerLeaf | SapientSignerLeaf | SubdigestLeaf | AnyAddressSubdigestLeaf | NestedLeaf | NodeLeaf
+
+export type Topology = Node | Leaf
+
+export type Config = {
+  threshold: bigint
+  checkpoint: bigint
+  topology: Topology
+  checkpointer?: Address.Address
+}
+
+export function isSignerLeaf(cand: any): cand is SignerLeaf {
+  return typeof cand === 'object' && cand !== null && cand.type === 'signer'
+}
+
+export function isSapientSignerLeaf(cand: any): cand is SapientSignerLeaf {
+  return typeof cand === 'object' && cand !== null && cand.type === 'sapient-signer'
+}
+
+export function isSubdigestLeaf(cand: any): cand is SubdigestLeaf {
+  return typeof cand === 'object' && cand !== null && cand.type === 'subdigest'
+}
+
+export function isAnyAddressSubdigestLeaf(cand: any): cand is AnyAddressSubdigestLeaf {
+  return typeof cand === 'object' && cand !== null && cand.type === 'any-address-subdigest'
+}
+
+export function isNodeLeaf(cand: any): cand is NodeLeaf {
+  return Hex.validate(cand) && cand.length === 66
+}
+
+export function isNestedLeaf(cand: any): cand is NestedLeaf {
+  return typeof cand === 'object' && cand !== null && cand.type === 'nested'
+}
+
+export function isNode(cand: any): cand is Node {
+  return Array.isArray(cand) && cand.length === 2 && isTopology(cand[0]) && isTopology(cand[1])
+}
+
+export function isConfig(cand: any): cand is Config {
+  return typeof cand === 'object' && 'threshold' in cand && 'checkpoint' in cand && 'topology' in cand
+}
+
+export function isLeaf(cand: Topology): cand is Leaf {
+  return (
+    isSignerLeaf(cand) ||
+    isSapientSignerLeaf(cand) ||
+    isSubdigestLeaf(cand) ||
+    isAnyAddressSubdigestLeaf(cand) ||
+    isNodeLeaf(cand) ||
+    isNestedLeaf(cand)
+  )
+}
+
+export function isTopology(cand: any): cand is Topology {
+  return isNode(cand) || isLeaf(cand)
+}
+
+export function getSigners(configuration: Config | Topology): {
+  signers: Address.Address[]
+  sapientSigners: { address: Address.Address; imageHash: Hex.Hex }[]
+  isComplete: boolean
+} {
+  const signers = new Set<Address.Address>()
+  const sapientSigners = new Set<{ address: Address.Address; imageHash: Hex.Hex }>()
+
+  let isComplete = true
+
+  const scan = (topology: Topology) => {
+    if (isNode(topology)) {
+      scan(topology[0])
+      scan(topology[1])
+    } else if (isSignerLeaf(topology)) {
+      if (topology.weight) {
+        signers.add(topology.address)
+      }
+    } else if (isSapientSignerLeaf(topology)) {
+      sapientSigners.add({ address: topology.address, imageHash: topology.imageHash })
+    } else if (isNodeLeaf(topology)) {
+      isComplete = false
+    } else if (isNestedLeaf(topology)) {
+      if (topology.weight) {
+        scan(topology.tree)
+      }
+    }
+  }
+
+  scan(isConfig(configuration) ? configuration.topology : configuration)
+  return { signers: Array.from(signers), sapientSigners: Array.from(sapientSigners), isComplete }
+}
+
+export function findSignerLeaf(
+  configuration: Config | Topology,
+  address: Address.Address,
+): SignerLeaf | SapientSignerLeaf | undefined {
+  if (isConfig(configuration)) {
+    return findSignerLeaf(configuration.topology, address)
+  } else if (isNode(configuration)) {
+    return findSignerLeaf(configuration[0], address) || findSignerLeaf(configuration[1], address)
+  } else if (isSignerLeaf(configuration)) {
+    if (Address.isEqual(configuration.address, address)) {
+      return configuration
+    }
+  } else if (isSapientSignerLeaf(configuration)) {
+    if (Address.isEqual(configuration.address, address)) {
+      return configuration
+    }
+  }
+  return undefined
+}
+
+export function getWeight(
+  topology: RawTopology | RawConfig | Config,
+  canSign: (signer: SignerLeaf | SapientSignerLeaf) => boolean,
+): { weight: bigint; maxWeight: bigint } {
+  topology = isRawConfig(topology) || isConfig(topology) ? topology.topology : topology
+
+  if (isSignedSignerLeaf(topology)) {
+    return { weight: topology.weight, maxWeight: topology.weight }
+  } else if (isSignerLeaf(topology)) {
+    return { weight: 0n, maxWeight: canSign(topology) ? topology.weight : 0n }
+  } else if (isRawSignerLeaf(topology)) {
+    return { weight: topology.weight, maxWeight: topology.weight }
+  } else if (isSignedSapientSignerLeaf(topology)) {
+    return { weight: topology.weight, maxWeight: topology.weight }
+  } else if (isSapientSignerLeaf(topology)) {
+    return { weight: 0n, maxWeight: canSign(topology) ? topology.weight : 0n }
+  } else if (isSubdigestLeaf(topology)) {
+    return { weight: 0n, maxWeight: 0n }
+  } else if (isAnyAddressSubdigestLeaf(topology)) {
+    return { weight: 0n, maxWeight: 0n }
+  } else if (isRawNestedLeaf(topology)) {
+    const { weight, maxWeight } = getWeight(topology.tree, canSign)
+    return {
+      weight: weight >= topology.threshold ? topology.weight : 0n,
+      maxWeight: maxWeight >= topology.threshold ? topology.weight : 0n,
+    }
+  } else if (isNodeLeaf(topology)) {
+    return { weight: 0n, maxWeight: 0n }
+  } else {
+    const [left, right] = [getWeight(topology[0], canSign), getWeight(topology[1], canSign)]
+    return { weight: left.weight + right.weight, maxWeight: left.maxWeight + right.maxWeight }
+  }
+}
+
+export function hashConfiguration(topology: Topology | Config): Bytes.Bytes {
+  if (isConfig(topology)) {
+    let root = hashConfiguration(topology.topology)
+    root = Hash.keccak256(Bytes.concat(root, Bytes.padLeft(Bytes.fromNumber(topology.threshold), 32)))
+    root = Hash.keccak256(Bytes.concat(root, Bytes.padLeft(Bytes.fromNumber(topology.checkpoint), 32)))
+    root = Hash.keccak256(
+      Bytes.concat(
+        root,
+        Bytes.padLeft(Bytes.fromHex(topology.checkpointer ?? '0x0000000000000000000000000000000000000000'), 32),
+      ),
+    )
+    return root
+  }
+
+  if (isSignerLeaf(topology)) {
+    return Hash.keccak256(
+      Bytes.concat(
+        Bytes.fromString('Sequence signer:\n'),
+        Bytes.fromHex(topology.address),
+        Bytes.padLeft(Bytes.fromNumber(topology.weight), 32),
+      ),
+    )
+  }
+
+  if (isSapientSignerLeaf(topology)) {
+    return Hash.keccak256(
+      Bytes.concat(
+        Bytes.fromString('Sequence sapient config:\n'),
+        Bytes.fromHex(topology.address),
+        Bytes.padLeft(Bytes.fromNumber(topology.weight), 32),
+        Bytes.padLeft(Bytes.fromHex(topology.imageHash), 32),
+      ),
+    )
+  }
+
+  if (isSubdigestLeaf(topology)) {
+    return Hash.keccak256(Bytes.concat(Bytes.fromString('Sequence static digest:\n'), Bytes.fromHex(topology.digest)))
+  }
+
+  if (isAnyAddressSubdigestLeaf(topology)) {
+    return Hash.keccak256(
+      Bytes.concat(Bytes.fromString('Sequence any address subdigest:\n'), Bytes.fromHex(topology.digest)),
+    )
+  }
+
+  if (isNodeLeaf(topology)) {
+    return Bytes.fromHex(topology)
+  }
+
+  if (isNestedLeaf(topology)) {
+    return Hash.keccak256(
+      Bytes.concat(
+        Bytes.fromString('Sequence nested config:\n'),
+        hashConfiguration(topology.tree),
+        Bytes.padLeft(Bytes.fromNumber(topology.threshold), 32),
+        Bytes.padLeft(Bytes.fromNumber(topology.weight), 32),
+      ),
+    )
+  }
+
+  if (isNode(topology)) {
+    return Hash.keccak256(Bytes.concat(hashConfiguration(topology[0]), hashConfiguration(topology[1])))
+  }
+
+  throw new Error('Invalid topology')
+}
+
+export function flatLeavesToTopology(leaves: Leaf[]): Topology {
+  if (leaves.length === 0) {
+    throw new Error('Cannot create topology from empty leaves')
+  }
+
+  if (leaves.length === 1) {
+    return leaves[0]!
+  }
+
+  if (leaves.length === 2) {
+    return [leaves[0]!, leaves[1]!]
+  }
+
+  return [
+    flatLeavesToTopology(leaves.slice(0, leaves.length / 2)),
+    flatLeavesToTopology(leaves.slice(leaves.length / 2)),
+  ]
+}
+
+export function configToJson(config: Config): string {
+  return JSON.stringify({
+    threshold: config.threshold.toString(),
+    checkpoint: config.checkpoint.toString(),
+    topology: encodeTopology(config.topology),
+    checkpointer: config.checkpointer,
+  })
+}
+
+export function configFromJson(json: string): Config {
+  const parsed = JSON.parse(json)
+  return {
+    threshold: BigInt(parsed.threshold),
+    checkpoint: BigInt(parsed.checkpoint),
+    checkpointer: parsed.checkpointer,
+    topology: decodeTopology(parsed.topology),
+  }
+}
+
+function encodeTopology(top: Topology): any {
+  if (isNode(top)) {
+    return [encodeTopology(top[0]), encodeTopology(top[1])]
+  } else if (isSignerLeaf(top)) {
+    return {
+      type: 'signer',
+      address: top.address,
+      weight: top.weight.toString(),
+    }
+  } else if (isSapientSignerLeaf(top)) {
+    return {
+      type: 'sapient-signer',
+      address: top.address,
+      weight: top.weight.toString(),
+      imageHash: top.imageHash,
+    }
+  } else if (isSubdigestLeaf(top)) {
+    return {
+      type: 'subdigest',
+      digest: top.digest,
+    }
+  } else if (isAnyAddressSubdigestLeaf(top)) {
+    return {
+      type: 'any-address-subdigest',
+      digest: top.digest,
+    }
+  } else if (isNodeLeaf(top)) {
+    return top
+  } else if (isNestedLeaf(top)) {
+    return {
+      type: 'nested',
+      tree: encodeTopology(top.tree),
+      weight: top.weight.toString(),
+      threshold: top.threshold.toString(),
+    }
+  }
+
+  throw new Error('Invalid topology')
+}
+
+function decodeTopology(obj: any): Topology {
+  if (Array.isArray(obj)) {
+    if (obj.length !== 2) {
+      throw new Error('Invalid node structure in JSON')
+    }
+    return [decodeTopology(obj[0]), decodeTopology(obj[1])]
+  }
+
+  if (typeof obj === 'string') {
+    return obj as Hex.Hex
+  }
+
+  switch (obj.type) {
+    case 'signer':
+      return {
+        type: 'signer',
+        address: obj.address,
+        weight: BigInt(obj.weight),
+      }
+    case 'sapient-signer':
+      return {
+        type: 'sapient-signer',
+        address: obj.address,
+        weight: BigInt(obj.weight),
+        imageHash: obj.imageHash,
+      }
+    case 'subdigest':
+      return {
+        type: 'subdigest',
+        digest: obj.digest,
+      }
+    case 'any-address-subdigest':
+      return {
+        type: 'any-address-subdigest',
+        digest: obj.digest,
+      }
+    case 'nested':
+      return {
+        type: 'nested',
+        tree: decodeTopology(obj.tree),
+        weight: BigInt(obj.weight),
+        threshold: BigInt(obj.threshold),
+      }
+    default:
+      throw new Error('Invalid type in topology JSON')
+  }
+}
+
+export type SignerSignature<T> = [T] extends [Promise<unknown>]
+  ? never
+  : MaybePromise<T> | { signature: Promise<T>; onSignerSignature?: SignerSignatureCallback; onCancel?: CancelCallback }
+
+export function normalizeSignerSignature<T>(signature: SignerSignature<T>): {
+  signature: Promise<T>
+  onSignerSignature?: SignerSignatureCallback
+  onCancel?: CancelCallback
+} {
+  if (signature instanceof Promise) {
+    return { signature }
+  } else if (
+    typeof signature === 'object' &&
+    signature &&
+    'signature' in signature &&
+    signature.signature instanceof Promise
+  ) {
+    return signature as ReturnType<typeof normalizeSignerSignature>
+  } else {
+    return { signature: Promise.resolve(signature) as Promise<T> }
+  }
+}
+
+export type SignerErrorCallback = (signer: SignerLeaf | SapientSignerLeaf, error: unknown) => void
+
+type SignerSignatureCallback = (topology: RawTopology) => void
+type CancelCallback = (success: boolean) => void
+type MaybePromise<T> = T | Promise<T>
+
+export function mergeTopology(a: Topology, b: Topology): Topology {
+  if (isNode(a) && isNode(b)) {
+    return [mergeTopology(a[0], b[0]), mergeTopology(a[1], b[1])]
+  }
+
+  if (isNode(a) && !isNode(b)) {
+    if (!isNodeLeaf(b)) {
+      throw new Error('Topology mismatch: cannot merge node with non-node that is not a node leaf')
+    }
+    const hb = hashConfiguration(b)
+    if (!Bytes.isEqual(hb, hashConfiguration(a))) {
+      throw new Error('Topology mismatch: node hash does not match')
+    }
+    return a
+  }
+
+  if (!isNode(a) && isNode(b)) {
+    if (!isNodeLeaf(a)) {
+      throw new Error('Topology mismatch: cannot merge node with non-node that is not a node leaf')
+    }
+    const ha = hashConfiguration(a)
+    if (!Bytes.isEqual(ha, hashConfiguration(b))) {
+      throw new Error('Topology mismatch: node hash does not match')
+    }
+    return b
+  }
+
+  return mergeLeaf(a as Leaf, b as Leaf)
+}
+
+function mergeLeaf(a: Leaf, b: Leaf): Leaf {
+  if (isNodeLeaf(a) && isNodeLeaf(b)) {
+    if (!Hex.isEqual(a, b)) {
+      throw new Error('Topology mismatch: different node leaves')
+    }
+    return a
+  }
+
+  if (isNodeLeaf(a) && !isNodeLeaf(b)) {
+    const hb = hashConfiguration(b)
+    if (!Bytes.isEqual(hb, Bytes.fromHex(a))) {
+      throw new Error('Topology mismatch: node leaf hash does not match')
+    }
+    return b
+  }
+
+  if (!isNodeLeaf(a) && isNodeLeaf(b)) {
+    const ha = hashConfiguration(a)
+    if (!Bytes.isEqual(ha, Bytes.fromHex(b))) {
+      throw new Error('Topology mismatch: node leaf hash does not match')
+    }
+    return a
+  }
+
+  if (isSignerLeaf(a) && isSignerLeaf(b)) {
+    if (a.address !== b.address || a.weight !== b.weight) {
+      throw new Error('Topology mismatch: signer fields differ')
+    }
+    if (!!a.signed !== !!b.signed || !!a.signature !== !!b.signature) {
+      throw new Error('Topology mismatch: signer signature fields differ')
+    }
+    return a
+  }
+
+  if (isSapientSignerLeaf(a) && isSapientSignerLeaf(b)) {
+    if (a.address !== b.address || a.weight !== b.weight || a.imageHash !== b.imageHash) {
+      throw new Error('Topology mismatch: sapient signer fields differ')
+    }
+    if (!!a.signed !== !!b.signed || !!a.signature !== !!b.signature) {
+      throw new Error('Topology mismatch: sapient signature fields differ')
+    }
+    return a
+  }
+
+  if (isSubdigestLeaf(a) && isSubdigestLeaf(b)) {
+    if (!Bytes.isEqual(Bytes.fromHex(a.digest), Bytes.fromHex(b.digest))) {
+      throw new Error('Topology mismatch: subdigest fields differ')
+    }
+    return a
+  }
+
+  if (isAnyAddressSubdigestLeaf(a) && isAnyAddressSubdigestLeaf(b)) {
+    if (!Bytes.isEqual(Bytes.fromHex(a.digest), Bytes.fromHex(b.digest))) {
+      throw new Error('Topology mismatch: any-address-subdigest fields differ')
+    }
+    return a
+  }
+
+  if (isNestedLeaf(a) && isNestedLeaf(b)) {
+    if (a.weight !== b.weight || a.threshold !== b.threshold) {
+      throw new Error('Topology mismatch: nested leaf fields differ')
+    }
+    const mergedTree = mergeTopology(a.tree, b.tree)
+    return {
+      type: 'nested',
+      weight: a.weight,
+      threshold: a.threshold,
+      tree: mergedTree,
+    }
+  }
+
+  throw new Error('Topology mismatch: incompatible leaf types')
+}

package/src/constants.ts

@@ -0,0 +1,39 @@
+import { Abi, Address, Hex } from 'ox'
+
+export const DEFAULT_CREATION_CODE: Hex.Hex =
+  '0x603e600e3d39601e805130553df33d3d34601c57363d3d373d363d30545af43d82803e903d91601c57fd5bf3'
+
+export const DefaultFactory: Address.Address = '0xe068ec288d8b4Aaf7F7FC028Ce0797a7a353EF2d'
+export const DefaultStage1: Address.Address = '0x302608CcdCc540761A0ec89C9d8Fa195dc8049C6'
+export const DefaultStage2: Address.Address = '0x80cF586AFaCb3Cae77d84aFEBcC92382eDCF3A02'
+export const DefaultGuest: Address.Address = '0x75e19AA6241D84C290658131857824B4eeF10dfF'
+export const DefaultSessionManager: Address.Address = '0x81Fa4b986f958CB02A3A6c10aa38056dCd701941'
+
+// ERC1271
+export const IS_VALID_SIGNATURE = Abi.from([
+  'function isValidSignature(bytes32 _hash, bytes memory _signature) public view returns (bytes4 magicValue)',
+])[0]
+
+// Factory
+export const DEPLOY = Abi.from([
+  'function deploy(address _mainModule, bytes32 _salt) public payable returns (address _contract)',
+])[0]
+
+// Stage1Module
+export const GET_IMPLEMENTATION = Abi.from(['function getImplementation() external view returns (address)'])[0]
+
+// Stage2Module
+export const IMAGE_HASH = Abi.from(['function imageHash() external view returns (bytes32)'])[0]
+export const READ_NONCE = Abi.from(['function readNonce(uint256 _space) public view returns (uint256)'])[0]
+export const EXECUTE = Abi.from(['function execute(bytes calldata _payload, bytes calldata _signature) external'])[0]
+export const UPDATE_IMAGE_HASH = Abi.from(['function updateImageHash(bytes32 _imageHash) external'])[0]
+
+// Sapient
+export const RECOVER_SAPIENT_SIGNATURE = Abi.from([
+  'function recoverSapientSignature((uint8 kind,bool noChainId,(address to,uint256 value,bytes data,uint256 gasLimit,bool delegateCall,bool onlyFallback,uint256 behaviorOnError)[] calls,uint256 space,uint256 nonce,bytes message,bytes32 imageHash,bytes32 digest,address[] parentWallets) calldata _payload, bytes calldata _signature) external view returns (bytes32)',
+])[0]
+
+// SapientCompact
+export const RECOVER_SAPIENT_SIGNATURE_COMPACT = Abi.from([
+  'function recoverSapientSignatureCompact(bytes32 _digest, bytes calldata _signature) external view returns (bytes32)',
+])[0]

package/src/context.ts

@@ -0,0 +1,16 @@
+import { Address, Hex } from 'ox'
+import { DEFAULT_CREATION_CODE, DefaultFactory, DefaultStage1, DefaultStage2 } from './constants.js'
+
+export type Context = {
+  factory: Address.Address
+  stage1: Address.Address
+  stage2: Address.Address
+  creationCode: Hex.Hex
+}
+
+export const Dev1: Context = {
+  factory: DefaultFactory,
+  stage1: DefaultStage1,
+  stage2: DefaultStage2,
+  creationCode: DEFAULT_CREATION_CODE,
+}

package/src/erc-6492.ts

@@ -0,0 +1,97 @@
+import { AbiFunction, AbiParameters, Address, Bytes, Hex, Provider } from 'ox'
+import { WrappedSignature } from 'ox/erc6492'
+import { DEPLOY } from './constants.js'
+import { Context } from './context.js'
+
+const EIP_6492_OFFCHAIN_DEPLOY_CODE =
+  '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'
+
+export function deploy<T extends Bytes.Bytes | Hex.Hex>(
+  deployHash: T,
+  context: Context,
+): { to: Address.Address; data: T } {
+  const encoded = AbiFunction.encodeData(DEPLOY, [context.stage1, Hex.from(deployHash)])
+
+  switch (typeof deployHash) {
+    case 'object':
+      return { to: context.factory, data: Hex.toBytes(encoded) as T }
+    case 'string':
+      return { to: context.factory, data: encoded as T }
+  }
+}
+
+export function wrap<T extends Bytes.Bytes | Hex.Hex>(
+  signature: T,
+  { to, data }: { to: Address.Address; data: Bytes.Bytes | Hex.Hex },
+): T {
+  const encoded = Hex.concat(
+    AbiParameters.encode(
+      [{ type: 'address' }, { type: 'bytes' }, { type: 'bytes' }],
+      [to, Hex.from(data), Hex.from(signature)],
+    ),
+    WrappedSignature.magicBytes,
+  )
+
+  switch (typeof signature) {
+    case 'object':
+      return Hex.toBytes(encoded) as T
+    case 'string':
+      return encoded as T
+  }
+}
+
+export function decode<T extends Bytes.Bytes | Hex.Hex>(
+  signature: T,
+): { signature: T; erc6492?: { to: Address.Address; data: T } } {
+  switch (typeof signature) {
+    case 'object':
+      if (
+        Bytes.toHex(signature.subarray(-WrappedSignature.magicBytes.slice(2).length / 2)) ===
+        WrappedSignature.magicBytes
+      ) {
+        const [to, data, decoded] = AbiParameters.decode(
+          [{ type: 'address' }, { type: 'bytes' }, { type: 'bytes' }],
+          signature.subarray(0, -WrappedSignature.magicBytes.slice(2).length / 2),
+        )
+        return { signature: Hex.toBytes(decoded) as T, erc6492: { to, data: Hex.toBytes(data) as T } }
+      } else {
+        return { signature }
+      }
+
+    case 'string':
+      if (signature.endsWith(WrappedSignature.magicBytes.slice(2))) {
+        try {
+          const [to, data, decoded] = AbiParameters.decode(
+            [{ type: 'address' }, { type: 'bytes' }, { type: 'bytes' }],
+            signature.slice(0, -WrappedSignature.magicBytes.slice(2).length) as Hex.Hex,
+          )
+          return { signature: decoded as T, erc6492: { to, data: data as T } }
+        } catch {
+          return { signature }
+        }
+      } else {
+        return { signature }
+      }
+  }
+}
+
+export function isValid(
+  address: Address.Address,
+  messageHash: Bytes.Bytes | Hex.Hex,
+  encodedSignature: Bytes.Bytes | Hex.Hex,
+  provider: Provider.Provider,
+): Promise<boolean> {
+  // Validate off chain with ERC-6492
+  const validationCallData: Hex.Hex = AbiParameters.encode(AbiParameters.from('address, bytes32, bytes'), [
+    address,
+    Hex.from(messageHash),
+    Hex.from(encodedSignature),
+  ])
+  const callData = Hex.concat(EIP_6492_OFFCHAIN_DEPLOY_CODE, validationCallData)
+  return provider
+    .request({
+      method: 'eth_call',
+      params: [{ data: callData }, 'latest'],
+    })
+    .then((result) => parseInt(result, 16) === 1)
+}