tempo.ts 0.11.1 → 0.12.1

package/src/viem/Actions/account.test.ts

@@ -1,414 +0,0 @@
-import { Hex, P256, Secp256k1, WebCryptoP256 } from 'ox'
-import { verifyMessage, verifyTypedData } from 'viem/actions'
-import { describe, expect, test } from 'vitest'
-import { client as baseClient } from '../../../test/viem/config.js'
-import * as Account from '../Account.js'
-import { decorator as tempoActions } from '../Decorator.js'
-import * as actions from './account.js'
-
-const client = baseClient.extend(tempoActions())
-
-describe('verifyHash', () => {
-  test('secp256k1: default signature', async () => {
-    const privateKey = Secp256k1.randomPrivateKey()
-    const account = Account.fromSecp256k1(privateKey)
-
-    const hash = Hex.random(32)
-    const signature = await account.sign({ hash })
-
-    const valid = await actions.verifyHash(client, {
-      address: account.address,
-      hash,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('secp256k1: without address (recovers from signature)', async () => {
-    const privateKey = Secp256k1.randomPrivateKey()
-    const account = Account.fromSecp256k1(privateKey)
-
-    const hash = Hex.random(32)
-    const signature = await account.sign({ hash })
-
-    const valid = await actions.verifyHash(client, {
-      hash,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('secp256k1: invalid signature returns false', async () => {
-    const privateKey = Secp256k1.randomPrivateKey()
-    const account = Account.fromSecp256k1(privateKey)
-
-    const hash = Hex.random(32)
-    const wrongHash = Hex.random(32)
-    const signature = await account.sign({ hash })
-
-    const valid = await actions.verifyHash(client, {
-      address: account.address,
-      hash: wrongHash,
-      signature,
-    })
-
-    expect(valid).toBe(false)
-  })
-
-  test('p256: default signature', async () => {
-    const privateKey = P256.randomPrivateKey()
-    const account = Account.fromP256(privateKey)
-
-    const hash = Hex.random(32)
-    const signature = await account.sign({ hash })
-
-    const valid = await actions.verifyHash(client, {
-      address: account.address,
-      hash,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('p256: invalid signature returns false', async () => {
-    const privateKey = P256.randomPrivateKey()
-    const account = Account.fromP256(privateKey)
-
-    const hash = Hex.random(32)
-    const wrongHash = Hex.random(32)
-    const signature = await account.sign({ hash })
-
-    const valid = await actions.verifyHash(client, {
-      address: account.address,
-      hash: wrongHash,
-      signature,
-    })
-
-    expect(valid).toBe(false)
-  })
-
-  test('webCrypto p256: default signature', async () => {
-    const keyPair = await WebCryptoP256.createKeyPair()
-    const account = Account.fromWebCryptoP256(keyPair)
-
-    const hash = Hex.random(32)
-    const signature = await account.sign({ hash })
-
-    const valid = await actions.verifyHash(client, {
-      address: account.address,
-      hash,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('webCrypto p256: invalid signature returns false', async () => {
-    const keyPair = await WebCryptoP256.createKeyPair()
-    const account = Account.fromWebCryptoP256(keyPair)
-
-    const hash = Hex.random(32)
-    const wrongHash = Hex.random(32)
-    const signature = await account.sign({ hash })
-
-    const valid = await actions.verifyHash(client, {
-      address: account.address,
-      hash: wrongHash,
-      signature,
-    })
-
-    expect(valid).toBe(false)
-  })
-
-  test('headless webAuthn: default signature', async () => {
-    const privateKey = P256.randomPrivateKey()
-    const account = Account.fromHeadlessWebAuthn(privateKey, {
-      rpId: 'example.com',
-      origin: 'https://example.com',
-    })
-
-    const hash = Hex.random(32)
-    const signature = await account.sign({ hash })
-
-    const valid = await actions.verifyHash(client, {
-      address: account.address,
-      hash,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('headless webAuthn: invalid signature returns false', async () => {
-    const privateKey = P256.randomPrivateKey()
-    const account = Account.fromHeadlessWebAuthn(privateKey, {
-      rpId: 'example.com',
-      origin: 'https://example.com',
-    })
-
-    const hash = Hex.random(32)
-    const wrongHash = Hex.random(32)
-    const signature = await account.sign({ hash })
-
-    const valid = await actions.verifyHash(client, {
-      address: account.address,
-      hash: wrongHash,
-      signature,
-    })
-
-    expect(valid).toBe(false)
-  })
-
-  test('behavior: signature from wrong account returns false', async () => {
-    const privateKey1 = Secp256k1.randomPrivateKey()
-    const account1 = Account.fromSecp256k1(privateKey1)
-
-    const privateKey2 = Secp256k1.randomPrivateKey()
-    const account2 = Account.fromSecp256k1(privateKey2)
-
-    const hash = Hex.random(32)
-    const signature = await account1.sign({ hash })
-
-    // Try to verify with wrong address
-    const valid = await actions.verifyHash(client, {
-      address: account2.address,
-      hash,
-      signature,
-    })
-
-    expect(valid).toBe(false)
-  })
-
-  test('as inherited: verifyMessage with secp256k1', async () => {
-    const privateKey = Secp256k1.randomPrivateKey()
-    const account = Account.fromSecp256k1(privateKey)
-
-    const message = 'Hello, World!'
-    const signature = await account.signMessage({ message })
-
-    const valid = await verifyMessage(client, {
-      address: account.address,
-      message,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('as inherited: verifyMessage with p256', async () => {
-    const privateKey = P256.randomPrivateKey()
-    const account = Account.fromP256(privateKey)
-
-    const message = 'Hello, P256!'
-    const signature = await account.signMessage({ message })
-
-    const valid = await verifyMessage(client, {
-      address: account.address,
-      message,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('as inherited: verifyMessage with webCrypto p256', async () => {
-    const keyPair = await WebCryptoP256.createKeyPair()
-    const account = Account.fromWebCryptoP256(keyPair)
-
-    const message = 'Hello, WebCrypto!'
-    const signature = await account.signMessage({ message })
-
-    const valid = await verifyMessage(client, {
-      address: account.address,
-      message,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('as inherited: verifyMessage with headless webAuthn', async () => {
-    const privateKey = P256.randomPrivateKey()
-    const account = Account.fromHeadlessWebAuthn(privateKey, {
-      rpId: 'example.com',
-      origin: 'https://example.com',
-    })
-
-    const message = 'Hello, WebAuthn!'
-    const signature = await account.signMessage({ message })
-
-    const valid = await verifyMessage(client, {
-      address: account.address,
-      message,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('as inherited: verifyTypedData with secp256k1', async () => {
-    const privateKey = Secp256k1.randomPrivateKey()
-    const account = Account.fromSecp256k1(privateKey)
-
-    const domain = {
-      name: 'Test App',
-      version: '1',
-      chainId: 1,
-    }
-
-    const types = {
-      Person: [
-        { name: 'name', type: 'string' },
-        { name: 'wallet', type: 'address' },
-      ],
-    }
-
-    const message = {
-      name: 'Alice',
-      wallet: '0x0000000000000000000000000000000000000000',
-    }
-
-    const signature = await account.signTypedData({
-      domain,
-      types,
-      primaryType: 'Person',
-      message,
-    })
-
-    const valid = await verifyTypedData(client, {
-      address: account.address,
-      domain,
-      types,
-      primaryType: 'Person',
-      message,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('as inherited: verifyTypedData with p256', async () => {
-    const privateKey = P256.randomPrivateKey()
-    const account = Account.fromP256(privateKey)
-
-    const domain = {
-      name: 'P256 App',
-      version: '1',
-      chainId: 1,
-    }
-
-    const types = {
-      Message: [{ name: 'content', type: 'string' }],
-    }
-
-    const message = {
-      content: 'Hello from P256!',
-    }
-
-    const signature = await account.signTypedData({
-      domain,
-      types,
-      primaryType: 'Message',
-      message,
-    })
-
-    const valid = await verifyTypedData(client, {
-      address: account.address,
-      domain,
-      types,
-      primaryType: 'Message',
-      message,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('as inherited: verifyTypedData with webCrypto p256', async () => {
-    const keyPair = await WebCryptoP256.createKeyPair()
-    const account = Account.fromWebCryptoP256(keyPair)
-
-    const domain = {
-      name: 'WebCrypto App',
-      version: '1',
-      chainId: 1,
-    }
-
-    const types = {
-      Data: [
-        { name: 'value', type: 'uint256' },
-        { name: 'label', type: 'string' },
-      ],
-    }
-
-    const message = {
-      value: 42n,
-      label: 'test',
-    }
-
-    const signature = await account.signTypedData({
-      domain,
-      types,
-      primaryType: 'Data',
-      message,
-    })
-
-    const valid = await verifyTypedData(client, {
-      address: account.address,
-      domain,
-      types,
-      primaryType: 'Data',
-      message,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-
-  test('as inherited: verifyTypedData with headless webAuthn', async () => {
-    const privateKey = P256.randomPrivateKey()
-    const account = Account.fromHeadlessWebAuthn(privateKey, {
-      rpId: 'example.com',
-      origin: 'https://example.com',
-    })
-
-    const domain = {
-      name: 'WebAuthn App',
-      version: '1',
-      chainId: 1,
-    }
-
-    const types = {
-      Auth: [
-        { name: 'user', type: 'address' },
-        { name: 'action', type: 'string' },
-      ],
-    }
-
-    const message = {
-      user: account.address,
-      action: 'login',
-    }
-
-    const signature = await account.signTypedData({
-      domain,
-      types,
-      primaryType: 'Auth',
-      message,
-    })
-
-    const valid = await verifyTypedData(client, {
-      address: account.address,
-      domain,
-      types,
-      primaryType: 'Auth',
-      message,
-      signature,
-    })
-
-    expect(valid).toBe(true)
-  })
-})

package/src/viem/Actions/account.ts

@@ -1,106 +0,0 @@
-import { Secp256k1 } from 'ox'
-import * as Hex from 'ox/Hex'
-import * as P256 from 'ox/P256'
-import { SignatureEnvelope } from 'ox/tempo'
-import * as WebAuthnP256 from 'ox/WebAuthnP256'
-import type { Chain, Client, Transport } from 'viem'
-import type { VerifyHashParameters, VerifyHashReturnType } from 'viem/actions'
-import { verifyHash as viem_verifyHash } from 'viem/actions'
-import { getAction } from 'viem/utils'
-import type { PartialBy } from '../../internal/types.js'
-
-/**
- * Verifies that a signature is valid for a given hash and address.
- * Supports multiple signature types: Secp256k1, P256, WebCrypto P256, and WebAuthn P256.
- *
- * @example
- * ```ts
- * import { createClient, http } from 'viem'
- * import { tempo } from 'tempo.ts/chains'
- * import { Actions, Account, P256 } from 'tempo.ts/viem'
- *
- * const client = createClient({
- *   chain: tempo({ feeToken: '0x20c0000000000000000000000000000000000001' })
- *   transport: http(),
- * })
- *
- * const privateKey = P256.randomPrivateKey()
- * const account = Account.fromP256(privateKey)
- *
- * const hash = '0x...'
- * const signature = await account.sign({ hash })
- *
- * const valid = await Actions.verifyHash(client, {
- *   hash,
- *   signature,
- * })
- * ```
- *
- * @param client - Client.
- * @param parameters - Parameters.
- * @returns Whether the signature is valid.
- */
-export async function verifyHash<chain extends Chain | undefined>(
-  client: Client<Transport, chain>,
-  parameters: verifyHash.Parameters,
-): Promise<verifyHash.ReturnValue> {
-  const { hash } = parameters
-
-  const signature = (() => {
-    const signature = parameters.signature
-    if (Hex.validate(signature)) return signature
-    if (typeof signature === 'object' && 'r' in signature && 's' in signature)
-      return SignatureEnvelope.serialize({
-        type: 'secp256k1',
-        signature: {
-          r: BigInt(signature.r),
-          s: BigInt(signature.s),
-          yParity: signature.yParity!,
-        },
-      })
-    return Hex.fromBytes(signature)
-  })()
-
-  const [envelope, userAddress] = (() => {
-    const envelope = SignatureEnvelope.from(signature)
-    if (envelope.type === 'keychain')
-      return [envelope.inner, envelope.userAddress]
-    return [envelope, undefined]
-  })()
-
-  if (envelope.type === 'p256')
-    return P256.verify({
-      payload: hash,
-      publicKey: envelope.publicKey,
-      signature: envelope.signature,
-      hash: envelope.prehash,
-    })
-  if (envelope.type === 'webAuthn')
-    return WebAuthnP256.verify({
-      challenge: hash,
-      metadata: envelope.metadata,
-      publicKey: envelope.publicKey,
-      signature: envelope.signature,
-    })
-  if (envelope.type === 'keychain') throw new Error('not supported')
-
-  const address =
-    parameters.address ??
-    userAddress ??
-    Secp256k1.recoverAddress({
-      payload: hash,
-      signature: envelope.signature,
-    })
-
-  return await getAction(
-    client,
-    viem_verifyHash,
-    'verifyHash',
-  )({ ...parameters, address } as never)
-}
-
-export declare namespace verifyHash {
-  export type Parameters = PartialBy<VerifyHashParameters, 'address'>
-
-  export type ReturnValue = VerifyHashReturnType
-}