tapimo 0.15.1 → 0.18.1

package/src/internal/routes/SolanaTransferSubsidy.test.ts

@@ -0,0 +1,471 @@
+import * as crypto from 'node:crypto'
+
+import { ed25519 } from '@noble/curves/ed25519'
+import {
+  findAssociatedTokenPda,
+  getTransferCheckedInstruction,
+  TOKEN_PROGRAM_ADDRESS,
+} from '@solana-program/token'
+import {
+  address,
+  appendTransactionMessageInstruction,
+  blockhash,
+  compileTransaction,
+  createTransactionMessage,
+  getTransactionEncoder,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash,
+  signatureBytes,
+} from '@solana/kit'
+import { Base58 } from 'ox'
+import { describe, expect, test } from 'vitest'
+
+import * as TestRelay from '../../../test/Relay.js'
+import * as Chain from './Chain.js'
+import * as Subsidy from './SolanaTransferSubsidy.js'
+
+async function prepared() {
+  const secret = crypto.randomBytes(32)
+  const account = address(Base58.fromBytes(ed25519.getPublicKey(secret)))
+  const recipient = address(Base58.fromBytes(ed25519.getPublicKey(crypto.randomBytes(32))))
+  const mint = address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')
+  const [source] = await findAssociatedTokenPda({
+    mint,
+    owner: account,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+  })
+  const [destination] = await findAssociatedTokenPda({
+    mint,
+    owner: recipient,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+  })
+  const recentBlockhash = blockhash(Base58.fromBytes(crypto.randomBytes(32)))
+  const message = appendTransactionMessageInstruction(
+    getTransferCheckedInstruction({
+      amount: 123n,
+      authority: account,
+      decimals: 6,
+      destination,
+      mint,
+      source,
+    }),
+    setTransactionMessageLifetimeUsingBlockhash(
+      { blockhash: recentBlockhash, lastValidBlockHeight: 123456n },
+      setTransactionMessageFeePayer(account, createTransactionMessage({ version: 'legacy' })),
+    ),
+  )
+  const transaction = compileTransaction(message)
+  const value: Subsidy.Prepared = {
+    account,
+    amount: '123',
+    chainId: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+    destination,
+    lastValidBlockHeight: 123456,
+    nativeAmount: '5000',
+    originSlot: 123306,
+    recipient,
+    request: {
+      network: 'solana:mainnet-beta',
+      transaction: Buffer.from(getTransactionEncoder().encode(transaction)).toString('base64'),
+    },
+    source,
+    token: mint,
+  }
+  return { account, secret, transaction, value }
+}
+
+describe('create', () => {
+  test('tries another RPC node when send preflight cannot find the blockhash', async () => {
+    const { account, secret, transaction, value } = await prepared()
+    const signature = signatureBytes(ed25519.sign(Buffer.from(transaction.messageBytes), secret))
+    const signed: Subsidy.Signed = {
+      ...value,
+      hash: Base58.fromBytes(signature),
+      transaction: Buffer.from(
+        getTransactionEncoder().encode({ ...transaction, signatures: { [account]: signature } }),
+      ).toString('base64'),
+    }
+    const requests: string[] = []
+    const server = await TestRelay.createServer((request, response) => {
+      requests.push(request.url ?? '')
+      request.resume()
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(
+        JSON.stringify(
+          request.url === '/lagging'
+            ? {
+                error: {
+                  code: -32002,
+                  data: { err: 'BlockhashNotFound' },
+                  message: 'Transaction simulation failed',
+                },
+                id: 1,
+                jsonrpc: '2.0',
+              }
+            : { id: 1, jsonrpc: '2.0', result: signed.hash },
+        ),
+      )
+    })
+    try {
+      const chain = Chain.from({
+        id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        name: 'Solana',
+        rpcUrls: [`${server.url}/lagging`, server.url],
+        slug: 'solana',
+      })
+      const subsidy = Subsidy.create({
+        account,
+        fetch: globalThis.fetch,
+        horcrux: { auth: { type: 'none' }, url: 'http://127.0.0.1:3040' },
+        policy: { maxAmount: '1000000' },
+        walletId: crypto.randomUUID(),
+      })
+      await expect(subsidy.broadcast({ chain, signed })).resolves.toBeUndefined()
+      expect(requests).toEqual(['/lagging', '/'])
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('does not fail over on an unrelated send preflight error', async () => {
+    const { account, secret, transaction, value } = await prepared()
+    const signature = signatureBytes(ed25519.sign(Buffer.from(transaction.messageBytes), secret))
+    const signed: Subsidy.Signed = {
+      ...value,
+      hash: Base58.fromBytes(signature),
+      transaction: Buffer.from(
+        getTransactionEncoder().encode({ ...transaction, signatures: { [account]: signature } }),
+      ).toString('base64'),
+    }
+    const requests: string[] = []
+    const server = await TestRelay.createServer((request, response) => {
+      requests.push(request.url ?? '')
+      request.resume()
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(
+        JSON.stringify({
+          error: { code: -32002, message: 'Transaction simulation failed: insufficient funds' },
+          id: 1,
+          jsonrpc: '2.0',
+        }),
+      )
+    })
+    try {
+      const chain = Chain.from({
+        id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        name: 'Solana',
+        rpcUrls: [`${server.url}/invalid`, server.url],
+        slug: 'solana',
+      })
+      const subsidy = Subsidy.create({
+        account,
+        fetch: globalThis.fetch,
+        horcrux: { auth: { type: 'none' }, url: 'http://127.0.0.1:3040' },
+        policy: { maxAmount: '1000000' },
+        walletId: crypto.randomUUID(),
+      })
+      await expect(subsidy.broadcast({ chain, signed })).rejects.toThrow('insufficient funds')
+      expect(requests).toEqual(['/invalid'])
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('waits for finality before treating a failed signature as reverted', async () => {
+    const { account, secret, transaction, value } = await prepared()
+    const signature = signatureBytes(ed25519.sign(Buffer.from(transaction.messageBytes), secret))
+    const signedTransaction = { ...transaction, signatures: { [account]: signature } }
+    const signed: Subsidy.Signed = {
+      ...value,
+      hash: Base58.fromBytes(signature),
+      transaction: Buffer.from(getTransactionEncoder().encode(signedTransaction)).toString(
+        'base64',
+      ),
+    }
+    const statuses = ['processed', 'confirmed', 'finalized']
+    const server = await TestRelay.createServer((request, response) => {
+      request.resume()
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(
+        JSON.stringify({
+          id: 1,
+          jsonrpc: '2.0',
+          result: {
+            value: [
+              { confirmationStatus: statuses.shift(), err: { InstructionError: [0, 'Custom'] } },
+            ],
+          },
+        }),
+      )
+    })
+    try {
+      const chain = Chain.from({
+        id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        name: 'Solana',
+        rpcUrls: [server.url],
+        slug: 'solana',
+      })
+      const subsidy = Subsidy.create({
+        account,
+        fetch: globalThis.fetch,
+        horcrux: { auth: { type: 'none' }, url: 'http://127.0.0.1:3040' },
+        policy: { maxAmount: '1000000' },
+        walletId: crypto.randomUUID(),
+      })
+      const options = { chain, recipient: value.recipient, signed, token: value.token }
+      await expect(subsidy.status(options)).resolves.toBe('pending')
+      await expect(subsidy.status(options)).resolves.toBe('pending')
+      await expect(subsidy.status(options)).resolves.toBe('reverted')
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('tries the next RPC URL after an unavailable response', async () => {
+    const { account, value } = await prepared()
+    const requests: string[] = []
+    const server = await TestRelay.createServer((request, response) => {
+      requests.push(request.url ?? '')
+      request.resume()
+      if (request.url === '/unavailable') {
+        response.writeHead(503)
+        response.end()
+        return
+      }
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(JSON.stringify({ id: 1, jsonrpc: '2.0', result: 123000 }))
+    })
+    try {
+      const chain = Chain.from({
+        id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        name: 'Solana',
+        rpcUrls: [`${server.url}/unavailable`, server.url],
+        slug: 'solana',
+      })
+      const subsidy = Subsidy.create({
+        account,
+        fetch: globalThis.fetch,
+        horcrux: { auth: { type: 'none' }, url: 'http://127.0.0.1:3040' },
+        policy: { maxAmount: '1000000' },
+        walletId: crypto.randomUUID(),
+      })
+      await expect(subsidy.expiring({ chain, prepared: value })).resolves.toBe(false)
+      expect(requests).toEqual(['/unavailable', '/'])
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('tries the next RPC URL when a node reports rate limiting', async () => {
+    const { account, value } = await prepared()
+    const requests: string[] = []
+    const server = await TestRelay.createServer((request, response) => {
+      requests.push(request.url ?? '')
+      request.resume()
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(
+        JSON.stringify(
+          request.url === '/limited'
+            ? { error: { code: -32005, message: 'Too many requests' }, id: 1, jsonrpc: '2.0' }
+            : { id: 1, jsonrpc: '2.0', result: 123000 },
+        ),
+      )
+    })
+    try {
+      const chain = Chain.from({
+        id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        name: 'Solana',
+        rpcUrls: [`${server.url}/limited`, server.url],
+        slug: 'solana',
+      })
+      const subsidy = Subsidy.create({
+        account,
+        fetch: globalThis.fetch,
+        horcrux: { auth: { type: 'none' }, url: 'http://127.0.0.1:3040' },
+        policy: { maxAmount: '1000000' },
+        walletId: crypto.randomUUID(),
+      })
+      await expect(subsidy.expiring({ chain, prepared: value })).resolves.toBe(false)
+      expect(requests).toEqual(['/limited', '/'])
+    } finally {
+      await server.closeAsync()
+    }
+  })
+
+  test('times out an unresponsive RPC URL before trying the next one', async () => {
+    const { account, value } = await prepared()
+    const requests: string[] = []
+    const server = await TestRelay.createServer((request, response) => {
+      requests.push(request.url ?? '')
+      request.resume()
+      if (request.url === '/unresponsive') return
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(JSON.stringify({ id: 1, jsonrpc: '2.0', result: 123000 }))
+    })
+    try {
+      const chain = Chain.from({
+        id: 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        name: 'Solana',
+        rpcUrls: [`${server.url}/unresponsive`, server.url],
+        slug: 'solana',
+      })
+      const subsidy = Subsidy.create({
+        account,
+        fetch: globalThis.fetch,
+        horcrux: { auth: { type: 'none' }, url: 'http://127.0.0.1:3040' },
+        policy: { maxAmount: '1000000' },
+        walletId: crypto.randomUUID(),
+      })
+      await expect(subsidy.expiring({ chain, prepared: value })).resolves.toBe(false)
+      expect(requests).toEqual(['/unresponsive', '/'])
+    } finally {
+      server.closeAllConnections()
+      await server.closeAsync()
+    }
+  }, 20_000)
+})
+
+describe('isPermanentBroadcastError', () => {
+  test('retries a blockhash unavailable on a lagging RPC node', () => {
+    expect(Subsidy.isPermanentBroadcastError(new Error('Blockhash not found'))).toBe(false)
+    expect(Subsidy.isPermanentBroadcastError(new Error('Block height exceeded'))).toBe(true)
+  })
+})
+
+describe('readPrepared', () => {
+  test('accepts an exact TransferChecked and rejects changed terms', async () => {
+    const { value } = await prepared()
+    expect(Subsidy.readPrepared(value)).toEqual(value)
+    expect(Subsidy.readPrepared({ ...value, amount: '124' })).toBeUndefined()
+    expect(
+      Subsidy.readPrepared({
+        ...value,
+        destination: Base58.fromBytes(crypto.randomBytes(32)),
+      }),
+    ).toBeUndefined()
+  })
+})
+
+describe('readSigned', () => {
+  test('requires the wallet signature over the exact prepared message', async () => {
+    const { account, secret, transaction, value } = await prepared()
+    const signature = signatureBytes(ed25519.sign(Buffer.from(transaction.messageBytes), secret))
+    const signedTransaction = { ...transaction, signatures: { [account]: signature } }
+    const signed: Subsidy.Signed = {
+      ...value,
+      hash: Base58.fromBytes(signature),
+      transaction: Buffer.from(getTransactionEncoder().encode(signedTransaction)).toString(
+        'base64',
+      ),
+    }
+    expect(Subsidy.readSigned(signed)).toEqual(signed)
+    expect(
+      Subsidy.readSigned({ ...signed, hash: Base58.fromBytes(crypto.randomBytes(32)) }),
+    ).toBeUndefined()
+  })
+})
+
+describe('matchesTerms', () => {
+  test('binds the prepared transaction to its chain, recipient, token, and amount', async () => {
+    const { value } = await prepared()
+    expect(
+      Subsidy.matchesTerms(value, {
+        account: value.account,
+        amount: 123n,
+        chainId: value.chainId,
+        recipient: value.recipient,
+        token: value.token,
+      }),
+    ).toBe(true)
+    expect(
+      Subsidy.matchesTerms(value, {
+        account: value.account,
+        amount: 124n,
+        chainId: value.chainId,
+        recipient: value.recipient,
+        token: value.token,
+      }),
+    ).toBe(false)
+  })
+})
+
+describe('inspectFinalizedBlock', () => {
+  const first = {
+    blockHeight: 100,
+    blockhash: 'first',
+    parentSlot: 9,
+    previousBlockhash: 'parent',
+    signatures: ['another-signature'],
+  }
+  const options = {
+    lastValidBlockHeight: 101,
+    originSlot: 10,
+    previousBlockhash: undefined,
+    previousHeight: undefined,
+    previousSlot: undefined,
+    signature: 'signed-transaction',
+    slot: 10,
+  }
+
+  test('proves absence through the first block beyond validity', () => {
+    expect(Subsidy.inspectFinalizedBlock({ ...options, block: first })).toEqual({
+      blockhash: 'first',
+      blockHeight: 100,
+      type: 'absent',
+    })
+    expect(
+      Subsidy.inspectFinalizedBlock({
+        ...options,
+        block: {
+          ...first,
+          blockHeight: 102,
+          blockhash: 'last',
+          parentSlot: 10,
+          previousBlockhash: 'first',
+        },
+        previousBlockhash: 'first',
+        previousHeight: 101,
+        previousSlot: 10,
+        slot: 12,
+      }),
+    ).toEqual({ blockhash: 'last', blockHeight: 102, type: 'expired' })
+  })
+
+  test('finds the signature, including at the validity boundary', () => {
+    expect(
+      Subsidy.inspectFinalizedBlock({
+        ...options,
+        block: { ...first, blockHeight: 101, signatures: ['signed-transaction'] },
+      }),
+    ).toEqual({ blockhash: 'first', blockHeight: 101, type: 'found' })
+  })
+
+  test('rejects gaps, missing blocks, and conflicting block evidence', () => {
+    expect(Subsidy.inspectFinalizedBlock({ ...options, block: null })).toEqual({
+      type: 'ambiguous',
+    })
+    expect(Subsidy.inspectFinalizedBlock({ ...options, block: first, slot: 11 })).toEqual({
+      type: 'ambiguous',
+    })
+    expect(
+      Subsidy.inspectFinalizedBlock({
+        ...options,
+        block: { ...first, blockHeight: 101, parentSlot: 9 },
+        previousBlockhash: 'first',
+        previousHeight: 100,
+        previousSlot: 10,
+        slot: 11,
+      }),
+    ).toEqual({ type: 'ambiguous' })
+    expect(
+      Subsidy.inspectFinalizedBlock({
+        ...options,
+        block: { ...first, blockHeight: 102, parentSlot: 10, previousBlockhash: 'wrong' },
+        previousBlockhash: 'first',
+        previousHeight: 100,
+        previousSlot: 10,
+        slot: 12,
+      }),
+    ).toEqual({ type: 'ambiguous' })
+  })
+})