ox 1.0.0-beta.8 → 1.0.0

package/src/tempo/TokenId.bench.ts

@@ -1,36 +0,0 @@
-import { bench, describe } from 'vp/test'
-import * as TokenId from './TokenId.js'
-
-const sender = '0x1234567890123456789012345678901234567890' as const
-const salt =
-  '0x0000000000000000000000000000000000000000000000000000000000000001' as const
-
-const tokenIdAddress = '0x20c0000000000000000000000000000000000001' as const
-const tokenIdBigInt = 1n
-const tokenIdLargeBigInt = 0xdeadbeefcafebabe1234n
-
-describe('TokenId.compute', () => {
-  bench('hex sender', () => {
-    TokenId.compute({ sender, salt })
-  })
-})
-
-describe('TokenId.fromAddress', () => {
-  bench('hex address', () => {
-    TokenId.fromAddress(tokenIdAddress)
-  })
-})
-
-describe('TokenId.toAddress', () => {
-  bench('small bigint', () => {
-    TokenId.toAddress(tokenIdBigInt)
-  })
-
-  bench('large bigint', () => {
-    TokenId.toAddress(tokenIdLargeBigInt)
-  })
-
-  bench('hex address passthrough', () => {
-    TokenId.toAddress(tokenIdAddress)
-  })
-})

package/src/tempo/TokenId.test.ts

@@ -1,79 +0,0 @@
-import { Hex } from 'ox'
-import { TokenId } from 'ox/tempo'
-import { expect, test } from 'vp/test'
-
-test('from', () => {
-  expect(TokenId.from(0n)).toBe(0n)
-  expect(TokenId.from(0x1)).toBe(1n)
-  expect(TokenId.from(0xdef)).toBe(0xdefn)
-  expect(TokenId.from('0x20c0000000000000000000000000000000000000')).toBe(0n)
-  expect(TokenId.from('0x20c0000000000000000000000000000000000001')).toBe(1n)
-  expect(TokenId.from('0x20c0000000000000000000000000000000000def')).toBe(
-    0xdefn,
-  )
-})
-
-test('fromAddress', () => {
-  expect(
-    TokenId.fromAddress('0x20c0000000000000000000000000000000000000'),
-  ).toBe(0n)
-  expect(
-    TokenId.fromAddress('0x20c0000000000000000000000000000000000001'),
-  ).toBe(1n)
-  expect(
-    TokenId.fromAddress('0x20c0000000000000000000000000000000000def'),
-  ).toBe(0xdefn)
-})
-
-test('toAddress', () => {
-  expect(TokenId.toAddress(0n)).toBe(
-    '0x20c0000000000000000000000000000000000000',
-  )
-  expect(TokenId.toAddress('0x20c0000000000000000000000000000000000000')).toBe(
-    '0x20c0000000000000000000000000000000000000',
-  )
-  expect(TokenId.toAddress(1n)).toBe(
-    '0x20c0000000000000000000000000000000000001',
-  )
-  expect(TokenId.toAddress(0xdefn)).toBe(
-    '0x20c0000000000000000000000000000000000def',
-  )
-})
-
-test('compute', () => {
-  const sender = '0x1234567890123456789012345678901234567890'
-  const salt1 =
-    '0x0000000000000000000000000000000000000000000000000000000000000001'
-  const salt2 =
-    '0x0000000000000000000000000000000000000000000000000000000000000002'
-
-  const id1 = TokenId.compute({ sender, salt: salt1 })
-  const id2 = TokenId.compute({ sender, salt: salt2 })
-  const address1 = TokenId.toAddress(id1)
-  const address2 = TokenId.toAddress(id2)
-
-  // deterministic: same inputs produce same output
-  expect(TokenId.compute({ sender, salt: salt1 })).toBe(id1)
-
-  // different salts produce different addresses
-  expect(address1).not.toBe(address2)
-
-  // address suffix matches id
-  expect(Hex.slice(address1, 12)).toBe(Hex.fromNumber(id1, { size: 8 }))
-
-  // addresses have TIP-20 prefix (0x20c0 followed by zeroes for 12 bytes total)
-  expect(address1.toLowerCase().startsWith('0x20c000000000000000000000')).toBe(
-    true,
-  )
-  expect(address2.toLowerCase().startsWith('0x20c000000000000000000000')).toBe(
-    true,
-  )
-
-  // addresses are 20 bytes (40 hex chars + 0x prefix)
-  expect(address1.length).toBe(42)
-
-  // different senders produce different addresses
-  const otherSender = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd'
-  const address3 = TokenId.compute({ sender: otherSender, salt: salt1 })
-  expect(address3).not.toBe(address1)
-})

package/src/tempo/TokenId.ts

@@ -1,141 +0,0 @@
-import { keccak_256 } from '@noble/hashes/sha3.js'
-import * as Address from '../core/Address.js'
-import * as Bytes from '../core/Bytes.js'
-import * as Hex from '../core/Hex.js'
-
-const tip20Prefix = '0x20c0'
-
-export type TokenId = bigint
-export type TokenIdOrAddress = TokenId | Address.Address
-
-/**
- * Converts a token ID or address to a token ID.
- *
- * TIP-20 is Tempo's native token standard for stablecoins with deterministic addresses
- * derived from sequential token IDs (prefix `0x20c0`).
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const tokenId = TokenId.from(1n)
- * ```
- *
- * @param tokenIdOrAddress - The token ID or address.
- * @returns The token ID.
- */
-export function from(tokenIdOrAddress: TokenIdOrAddress | number): TokenId {
-  if (
-    typeof tokenIdOrAddress === 'bigint' ||
-    typeof tokenIdOrAddress === 'number'
-  )
-    return BigInt(tokenIdOrAddress)
-  return fromAddress(tokenIdOrAddress)
-}
-
-/**
- * Converts a TIP-20 token address to a token ID.
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const tokenId = TokenId.fromAddress(
- *   '0x20c0000000000000000000000000000000000001'
- * )
- * ```
- *
- * @param address - The token address.
- * @returns The token ID.
- */
-export function fromAddress(address: Address.Address): TokenId {
-  const resolved = address
-  // The TIP-20 prefix check is case-insensitive, but most inputs are already
-  // lowercase, so peek the prefix bytes before falling back to a full
-  // `.toLowerCase()`.
-  const c2 = resolved.charCodeAt(2)
-  const c3 = resolved.charCodeAt(3)
-  const c4 = resolved.charCodeAt(4)
-  const c5 = resolved.charCodeAt(5)
-  const isPrefix =
-    c2 === 50 /* '2' */ &&
-    c3 === 48 /* '0' */ &&
-    (c4 === 99 || c4 === 67) /* 'c' or 'C' */ &&
-    c5 === 48 /* '0' */
-  if (!isPrefix) throw new Error('invalid tip20 address.')
-  // The trailing 36 hex characters encode the token id big-endian.
-  return BigInt(`0x${resolved.slice(tip20Prefix.length)}`)
-}
-
-/**
- * Converts a TIP-20 token ID to an address.
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const address = TokenId.toAddress(1n)
- * ```
- *
- * @param tokenId - The token ID.
- * @returns The address.
- */
-export function toAddress(tokenId: TokenIdOrAddress): Address.Address {
-  if (typeof tokenId === 'string') {
-    Address.assert(tokenId)
-    return tokenId
-  }
-
-  const tokenIdHex = Hex.fromNumber(tokenId, { size: 18 })
-  return Hex.concat(tip20Prefix, tokenIdHex)
-}
-
-/**
- * Computes a deterministic TIP-20 token address from a sender address and salt.
- *
- * The address is computed as: `TIP20_PREFIX (12 bytes) || keccak256(abi.encode(sender, salt))[:8]`
- *
- * [TIP-20 Token Standard](https://docs.tempo.xyz/protocol/tip20/overview)
- *
- * @example
- * ```ts twoslash
- * import { TokenId } from 'ox/tempo'
- *
- * const id = TokenId.compute({
- *   sender: '0x1234567890123456789012345678901234567890',
- *   salt: '0x0000000000000000000000000000000000000000000000000000000000000001'
- * })
- * ```
- *
- * @param value - The sender address and salt.
- * @returns The computed TIP-20 token id.
- */
-export function compute(value: compute.Value): bigint {
-  // ABI encoding of (address, bytes32) is the 32-byte left-padded address
-  // followed by the 32-byte salt. Build that 64-byte buffer directly and hash
-  // it, instead of round-tripping through `AbiParameters.encode`.
-  const buffer = new Uint8Array(64)
-  const addressBytes = Bytes.fromHex(value.sender)
-  buffer.set(addressBytes, 12)
-  buffer.set(Bytes.fromHex(value.salt, { size: 32 }), 32)
-  const hash = keccak_256(buffer)
-  // First 8 bytes of the digest, big-endian.
-  let id = 0n
-  for (let i = 0; i < 8; i++) id = (id << 8n) | BigInt(hash[i]!)
-  return id
-}
-
-export declare namespace compute {
-  export type Value = {
-    /** The salt (32 bytes). */
-    salt: Hex.Hex
-    /** The sender address. */
-    sender: Address.Address
-  }
-}

package/src/zod/tempo/TokenId.ts

@@ -1,15 +0,0 @@
-/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
-import * as core_TokenId from '../../tempo/TokenId.js'
-import * as z_Address from '../Address.js'
-import * as z from 'zod/mini'
-
-/** TIP-20 token id schema (non-negative bigint). */
-export const TokenId = z
-  .bigint()
-  .check(z.refine((value) => value >= 0n, 'expected token id'))
-
-/** Codec decoding a TIP-20 token address into a token id. */
-export const address = z.codec(z_Address.Address, TokenId, {
-  decode: (value) => core_TokenId.fromAddress(value),
-  encode: (value) => core_TokenId.toAddress(value),
-})

package/src/zod/tempo/_test/TokenId.test-d.ts

@@ -1,17 +0,0 @@
-import type * as core_Address from '../../../core/Address.js'
-import type * as core_TokenId from '../../../tempo/TokenId.js'
-import type * as z from 'zod/mini'
-import { expectTypeOf, test } from 'vp/test'
-import * as z_TokenId from '../TokenId.js'
-
-test('TokenId schemas preserve decoded and encoded types', () => {
-  expectTypeOf<
-    z.output<typeof z_TokenId.TokenId>
-  >().toEqualTypeOf<core_TokenId.TokenId>()
-  expectTypeOf<
-    z.output<typeof z_TokenId.address>
-  >().toEqualTypeOf<core_TokenId.TokenId>()
-  expectTypeOf<
-    z.input<typeof z_TokenId.address>
-  >().toEqualTypeOf<core_Address.Address>()
-})

package/src/zod/tempo/_test/TokenId.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-import * as z_TokenId from '../TokenId.js'
-import * as z from 'zod/mini'
-
-describe('TokenId', () => {
-  test('accepts non-negative bigints', () => {
-    expect(z.safeDecode(z_TokenId.TokenId, 1n).success).toBe(true)
-    expect(z.safeDecode(z_TokenId.TokenId, -1n).success).toMatchInlineSnapshot(
-      `false`,
-    )
-  })
-
-  test('decodes and encodes token addresses', () => {
-    expect(
-      z.decode(z_TokenId.address, '0x20c0000000000000000000000000000000000001'),
-    ).toMatchInlineSnapshot(`1n`)
-    expect(z.encode(z_TokenId.address, 1n)).toMatchInlineSnapshot(
-      `"0x20c0000000000000000000000000000000000001"`,
-    )
-  })
-})