tempo.ts 0.6.1 → 0.7.0

package/src/viem/Actions/account.ts

@@ -0,0 +1,108 @@
+import { Secp256k1 } from 'ox'
+import * as Hex from 'ox/Hex'
+import * as P256 from 'ox/P256'
+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'
+import * as SignatureEnvelope from '../../ox/SignatureEnvelope.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)
+    // TODO: add once we have key auth
+    // 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,
+    })
+  // TODO: add once we have key auth
+  // 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
+}

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

@@ -3,14 +3,9 @@ import { Abis, Actions } from 'tempo.ts/viem'
 import { parseUnits } from 'viem'
 import { writeContractSync } from 'viem/actions'
 import { describe, expect, test } from 'vitest'
-import {
-  accounts,
-  clientWithAccount,
-  setupPoolWithLiquidity,
-} from '../../../test/viem/config.js'
+import { accounts, clientWithAccount } from '../../../test/viem/config.js'
 
 const account = accounts[0]
-const account2 = accounts[1]
 
 describe('getPool', () => {
   test('default', async () => {
@@ -41,78 +36,6 @@ describe('getLiquidityBalance', () => {
 
 describe('mint', () => {
   test('default', async () => {
-    // Create a new token for testing
-    const { token } = await Actions.token.createSync(clientWithAccount, {
-      name: 'Test Token',
-      symbol: 'TEST',
-      currency: 'USD',
-    })
-
-    // Grant issuer role to mint tokens
-    await Actions.token.grantRolesSync(clientWithAccount, {
-      token,
-      roles: ['issuer'],
-      to: clientWithAccount.account.address,
-    })
-
-    // Mint some tokens to account
-    await Actions.token.mintSync(clientWithAccount, {
-      to: clientWithAccount.account.address,
-      amount: parseUnits('1000', 6),
-      token,
-    })
-
-    // Add liquidity to pool
-    const { receipt: mintReceipt, ...mintResult } = await Actions.amm.mintSync(
-      clientWithAccount,
-      {
-        userToken: {
-          address: token,
-          amount: parseUnits('100', 6),
-        },
-        validatorToken: {
-          address: 1n,
-          amount: parseUnits('100', 6),
-        },
-        to: account.address,
-      },
-    )
-    const { sender, userToken, ...rest } = mintResult
-    expect(mintReceipt).toBeDefined()
-    expect(sender).toBe(clientWithAccount.account.address)
-    expect(userToken).toBe(token)
-    expect(rest).toMatchInlineSnapshot(`
-      {
-        "amountUserToken": 100000000n,
-        "amountValidatorToken": 100000000n,
-        "liquidity": 4999999999999000n,
-        "validatorToken": "0x20C0000000000000000000000000000000000001",
-      }
-    `)
-
-    // Verify pool reserves
-    const pool = await Actions.amm.getPool(clientWithAccount, {
-      userToken: token,
-      validatorToken: 1n,
-    })
-    expect(pool).toMatchInlineSnapshot(`
-      {
-        "reserveUserToken": 100000000n,
-        "reserveValidatorToken": 100000000n,
-        "totalSupply": 5000000000000000n,
-      }
-    `)
-
-    // Verify LP token balance
-    const lpBalance = await Actions.amm.getLiquidityBalance(clientWithAccount, {
-      address: account.address,
-      userToken: token,
-      validatorToken: 1n,
-    })
-    expect(lpBalance).toBeGreaterThan(0n)
-  })
-
-  test('behavior: single-sided mint (mintWithValidatorToken)', async () => {
     // Create a new token for testing
     const { token } = await Actions.token.createSync(clientWithAccount, {
       name: 'Test Token 2',
@@ -136,15 +59,10 @@ describe('mint', () => {
 
     // First, establish initial liquidity with two-sided mint
     await Actions.amm.mintSync(clientWithAccount, {
-      userToken: {
-        address: token,
-        amount: parseUnits('100', 6),
-      },
-      validatorToken: {
-        address: 1n,
-        amount: parseUnits('100', 6),
-      },
       to: account.address,
+      userTokenAddress: token,
+      validatorTokenAddress: 1n,
+      validatorTokenAmount: parseUnits('100', 6),
     })
 
     // Get initial pool state
@@ -157,13 +75,9 @@ describe('mint', () => {
     const { receipt: mintReceipt, ...mintResult } = await Actions.amm.mintSync(
       clientWithAccount,
       {
-        userToken: {
-          address: token,
-        },
-        validatorToken: {
-          address: 1n,
-          amount: parseUnits('50', 6),
-        },
+        userTokenAddress: token,
+        validatorTokenAddress: 1n,
+        validatorTokenAmount: parseUnits('50', 6),
         to: account.address,
       },
     )
@@ -188,149 +102,6 @@ describe('mint', () => {
   })
 })
 
-describe('burn', () => {
-  test('default', async () => {
-    const { tokenAddress } = await setupPoolWithLiquidity(clientWithAccount)
-
-    // Get LP balance before burn
-    const lpBalanceBefore = await Actions.amm.getLiquidityBalance(
-      clientWithAccount,
-      {
-        address: account.address,
-        userToken: tokenAddress,
-        validatorToken: 1n,
-      },
-    )
-
-    // Burn half of LP tokens
-    const {
-      receipt: burnReceipt,
-      userToken,
-      ...burnResult
-    } = await Actions.amm.burnSync(clientWithAccount, {
-      userToken: tokenAddress,
-      validatorToken: 1n,
-      liquidity: lpBalanceBefore / 2n,
-      to: account2.address,
-    })
-    const { sender, to, ...rest } = burnResult
-
-    expect(burnReceipt).toBeDefined()
-    expect(userToken).toBe(tokenAddress)
-    expect(sender).toBe(account.address)
-    expect(to).toBe(account2.address)
-    expect(rest).toMatchInlineSnapshot(`
-      {
-        "amountUserToken": 49999999n,
-        "amountValidatorToken": 49999999n,
-        "liquidity": 2499999999999500n,
-        "validatorToken": "0x20C0000000000000000000000000000000000001",
-      }
-    `)
-
-    // Verify LP balance decreased
-    const lpBalanceAfter = await Actions.amm.getLiquidityBalance(
-      clientWithAccount,
-      {
-        address: account.address,
-        userToken: tokenAddress,
-        validatorToken: 1n,
-      },
-    )
-    expect(lpBalanceAfter).toBeLessThan(lpBalanceBefore)
-    expect(lpBalanceAfter).toBe(lpBalanceBefore / 2n)
-
-    // Verify pool reserves decreased
-    const pool = await Actions.amm.getPool(clientWithAccount, {
-      userToken: tokenAddress,
-      validatorToken: 1n,
-    })
-    expect(pool).toMatchInlineSnapshot(`
-      {
-        "reserveUserToken": 50000001n,
-        "reserveValidatorToken": 50000001n,
-        "totalSupply": 2500000000000500n,
-      }
-    `)
-  })
-})
-
-describe('rebalanceSwap', () => {
-  test('default', async () => {
-    const { tokenAddress } = await setupPoolWithLiquidity(clientWithAccount)
-
-    // Get balance before swap
-    const balanceBefore = await Actions.token.getBalance(clientWithAccount, {
-      token: tokenAddress,
-      account: account2.address,
-    })
-
-    // Perform rebalance swap
-    const {
-      receipt: swapReceipt,
-      swapper,
-      userToken,
-      ...swapResult
-    } = await Actions.amm.rebalanceSwapSync(clientWithAccount, {
-      userToken: tokenAddress,
-      validatorToken: 1n,
-      amountOut: parseUnits('10', 6),
-      to: account2.address,
-      account: account,
-    })
-    expect(swapReceipt).toBeDefined()
-    expect(userToken).toBe(tokenAddress)
-    expect(swapper).toBe(account.address)
-    expect(swapResult).toMatchInlineSnapshot(`
-      {
-        "amountIn": 9985001n,
-        "amountOut": 10000000n,
-        "validatorToken": "0x20C0000000000000000000000000000000000001",
-      }
-    `)
-
-    // Verify balance increased
-    const balanceAfter = await Actions.token.getBalance(clientWithAccount, {
-      token: tokenAddress,
-      account: account2.address,
-    })
-    expect(balanceAfter).toBe(balanceBefore + parseUnits('10', 6))
-  })
-})
-
-describe('watchRebalanceSwap', () => {
-  test('default', async () => {
-    const { tokenAddress } = await setupPoolWithLiquidity(clientWithAccount)
-
-    let eventArgs: any = null
-    const unwatch = Actions.amm.watchRebalanceSwap(clientWithAccount, {
-      onRebalanceSwap: (args) => {
-        eventArgs = args
-      },
-    })
-
-    // Perform rebalance swap
-    await Actions.amm.rebalanceSwapSync(clientWithAccount, {
-      userToken: tokenAddress,
-      validatorToken: 1n,
-      amountOut: parseUnits('10', 6),
-      to: account2.address,
-      account: account,
-    })
-
-    await setTimeout(1000)
-
-    expect(eventArgs).toBeDefined()
-    expect(eventArgs.userToken.toLowerCase()).toBe(tokenAddress.toLowerCase())
-    expect(eventArgs.validatorToken.toLowerCase()).toBe(
-      '0x20c0000000000000000000000000000000000001',
-    )
-    expect(eventArgs.amountOut).toBe(parseUnits('10', 6))
-
-    unwatch()
-  })
-})
-
 describe('watchMint', () => {
   test('default', async () => {
     // Create a new token for testing
@@ -371,14 +142,9 @@ describe('watchMint', () => {
 
     // Add liquidity to pool
     await Actions.amm.mintSync(clientWithAccount, {
-      userToken: {
-        address: token,
-        amount: parseUnits('100', 6),
-      },
-      validatorToken: {
-        address: 1n,
-        amount: parseUnits('100', 6),
-      },
+      userTokenAddress: token,
+      validatorTokenAddress: 1n,
+      validatorTokenAmount: parseUnits('100', 6),
       to: account.address,
     })
 
@@ -389,48 +155,8 @@ describe('watchMint', () => {
     expect(eventArgs.validatorToken.address.toLowerCase()).toBe(
       '0x20c0000000000000000000000000000000000001',
     )
-    expect(eventArgs.userToken.amount).toBe(parseUnits('100', 6))
     expect(eventArgs.validatorToken.amount).toBe(parseUnits('100', 6))
 
     unwatch()
   })
 })
-
-describe('watchBurn', () => {
-  test('default', async () => {
-    const { tokenAddress } = await setupPoolWithLiquidity(clientWithAccount)
-
-    // Get LP balance
-    const lpBalance = await Actions.amm.getLiquidityBalance(clientWithAccount, {
-      userToken: tokenAddress,
-      validatorToken: 1n,
-      address: account.address,
-    })
-
-    let eventArgs: any = null
-    const unwatch = Actions.amm.watchBurn(clientWithAccount, {
-      onBurn: (args) => {
-        eventArgs = args
-      },
-    })
-
-    // Burn LP tokens
-    await Actions.amm.burnSync(clientWithAccount, {
-      userToken: tokenAddress,
-      validatorToken: 1n,
-      liquidity: lpBalance / 2n,
-      to: account.address,
-    })
-
-    await setTimeout(1000)
-
-    expect(eventArgs).toBeDefined()
-    expect(eventArgs.userToken.toLowerCase()).toBe(tokenAddress.toLowerCase())
-    expect(eventArgs.validatorToken.toLowerCase()).toBe(
-      '0x20c0000000000000000000000000000000000001',
-    )
-    expect(eventArgs.liquidity).toBe(lpBalance / 2n)
-
-    unwatch()
-  })
-})