ox 0.9.16 → 0.10.0

package/tempo/Tick/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/Tick.d.ts",
+  "main": "../../_cjs/tempo/Tick.js",
+  "module": "../../_esm/tempo/Tick.js"
+}

package/tempo/Tick.test.ts

@@ -0,0 +1,281 @@
+import { Tick } from 'ox/tempo'
+import { describe, expect, test } from 'vitest'
+
+describe('toPrice', () => {
+  test('converts tick 0 to price 1', () => {
+    expect(Tick.toPrice(0)).toBe('1')
+  })
+
+  test('converts positive ticks correctly', () => {
+    expect(Tick.toPrice(100)).toBe('1.001')
+    expect(Tick.toPrice(1000)).toBe('1.01')
+    expect(Tick.toPrice(2000)).toBe('1.02')
+  })
+
+  test('converts negative ticks correctly', () => {
+    expect(Tick.toPrice(-100)).toBe('0.999')
+    expect(Tick.toPrice(-1000)).toBe('0.99')
+    expect(Tick.toPrice(-2000)).toBe('0.98')
+  })
+
+  test('handles boundary values', () => {
+    expect(Tick.toPrice(Tick.minTick)).toBe('0.98')
+    expect(Tick.toPrice(Tick.maxTick)).toBe('1.02')
+  })
+
+  test('preserves exact 5 decimal precision', () => {
+    expect(Tick.toPrice(1)).toBe('1.00001')
+    expect(Tick.toPrice(-1)).toBe('0.99999')
+    expect(Tick.toPrice(1234)).toBe('1.01234')
+  })
+
+  test('throws error when tick is below minimum', () => {
+    expect(() => Tick.toPrice(-2001)).toThrow(Tick.TickOutOfBoundsError)
+    expect(() => Tick.toPrice(-2001)).toThrow('Tick -2001 is out of bounds.')
+    expect(() => Tick.toPrice(-3000)).toThrow(Tick.TickOutOfBoundsError)
+  })
+
+  test('throws error when tick is above maximum', () => {
+    expect(() => Tick.toPrice(2001)).toThrow(Tick.TickOutOfBoundsError)
+    expect(() => Tick.toPrice(2001)).toThrow('Tick 2001 is out of bounds.')
+    expect(() => Tick.toPrice(3000)).toThrow(Tick.TickOutOfBoundsError)
+  })
+
+  test('handles edge cases near bounds', () => {
+    expect(() => Tick.toPrice(-2000)).not.toThrow()
+    expect(() => Tick.toPrice(2000)).not.toThrow()
+  })
+})
+
+describe('fromPrice', () => {
+  test('converts price 1.0 to tick 0', () => {
+    expect(Tick.fromPrice('1.0')).toBe(0)
+    expect(Tick.fromPrice('1.00000')).toBe(0)
+  })
+
+  test('converts prices above 1.0 correctly', () => {
+    expect(Tick.fromPrice('1.001')).toBe(100)
+    expect(Tick.fromPrice('1.01')).toBe(1000)
+    expect(Tick.fromPrice('1.02')).toBe(2000)
+  })
+
+  test('converts prices below 1.0 correctly', () => {
+    expect(Tick.fromPrice('0.999')).toBe(-100)
+    expect(Tick.fromPrice('0.99')).toBe(-1000)
+    expect(Tick.fromPrice('0.98')).toBe(-2000)
+  })
+
+  test('handles boundary values', () => {
+    expect(Tick.fromPrice('0.98')).toBe(Tick.minTick)
+    expect(Tick.fromPrice('1.02')).toBe(Tick.maxTick)
+  })
+
+  test('handles different decimal precisions', () => {
+    expect(Tick.fromPrice('1.00001')).toBe(1)
+    expect(Tick.fromPrice('1.0001')).toBe(10)
+    expect(Tick.fromPrice('1.001')).toBe(100)
+    expect(Tick.fromPrice('0.99999')).toBe(-1)
+  })
+
+  test('truncates beyond 5 decimal places', () => {
+    // Should truncate, not round, extra decimals
+    expect(Tick.fromPrice('1.000019')).toBe(1) // Takes first 5: 1.00001
+    expect(Tick.fromPrice('1.000015')).toBe(1) // Takes first 5: 1.00001
+  })
+
+  test('validates string format', () => {
+    expect(() => Tick.fromPrice('abc')).toThrow(Tick.InvalidPriceFormatError)
+    expect(() => Tick.fromPrice('abc')).toThrow('Invalid price format')
+    expect(() => Tick.fromPrice('1.2.3')).toThrow(Tick.InvalidPriceFormatError)
+    expect(() => Tick.fromPrice('')).toThrow(Tick.InvalidPriceFormatError)
+  })
+
+  test('throws error when price results in tick below minimum', () => {
+    expect(() => Tick.fromPrice('0.979')).toThrow(Tick.PriceOutOfBoundsError)
+    expect(() => Tick.fromPrice('0.979')).toThrow(
+      'Price "0.979" results in tick -2100 which is out of bounds.',
+    )
+    expect(() => Tick.fromPrice('0.5')).toThrow(Tick.PriceOutOfBoundsError)
+  })
+
+  test('throws error when price results in tick above maximum', () => {
+    expect(() => Tick.fromPrice('1.021')).toThrow(Tick.PriceOutOfBoundsError)
+    expect(() => Tick.fromPrice('1.021')).toThrow(
+      'Price "1.021" results in tick 2100 which is out of bounds.',
+    )
+    expect(() => Tick.fromPrice('1.5')).toThrow(Tick.PriceOutOfBoundsError)
+  })
+
+  test('handles edge cases near bounds', () => {
+    expect(() => Tick.fromPrice('0.98')).not.toThrow()
+    expect(() => Tick.fromPrice('1.02')).not.toThrow()
+  })
+
+  test('handles whitespace', () => {
+    expect(Tick.fromPrice('  1.0  ')).toBe(0)
+    expect(Tick.fromPrice(' 1.001 ')).toBe(100)
+  })
+})
+
+describe('round-trip conversions', () => {
+  test('tick -> price -> tick preserves tick values exactly', () => {
+    const ticks = [-2000, -1000, -100, -1, 0, 1, 100, 1000, 2000]
+    for (const tick of ticks) {
+      const price = Tick.toPrice(tick)
+      const roundTripTick = Tick.fromPrice(price)
+      expect(roundTripTick).toBe(tick)
+    }
+  })
+
+  test('price -> tick -> price preserves price strings exactly', () => {
+    const prices = ['0.98', '0.99', '1', '1.01', '1.02']
+    for (const price of prices) {
+      const tick = Tick.fromPrice(price)
+      const roundTripPrice = Tick.toPrice(tick)
+      expect(roundTripPrice).toBe(price)
+    }
+  })
+
+  test('handles arbitrary precision in input strings', () => {
+    // Shorter decimal strings should round-trip correctly
+    expect(Tick.toPrice(Tick.fromPrice('1.0'))).toBe('1')
+    expect(Tick.toPrice(Tick.fromPrice('0.999'))).toBe('0.999')
+
+    // Longer decimal strings get truncated to 5 decimals
+    expect(Tick.toPrice(Tick.fromPrice('1.000019999'))).toBe('1.00001')
+  })
+})
+
+describe('error handling', () => {
+  test('InvalidPriceFormatError is catchable and has correct properties', () => {
+    try {
+      Tick.fromPrice('invalid')
+      expect.fail('Should have thrown')
+    } catch (error) {
+      expect(error).toBeInstanceOf(Tick.InvalidPriceFormatError)
+      expect(error).toHaveProperty('name', 'Tick.InvalidPriceFormatError')
+      expect((error as Error).message).toContain('Invalid price format')
+      expect((error as Error).message).toContain('invalid')
+      expect((error as Error).message).toContain(
+        'Price must be a decimal number string',
+      )
+    }
+  })
+
+  test('TickOutOfBoundsError is catchable and has correct properties', () => {
+    try {
+      Tick.toPrice(-2001)
+      expect.fail('Should have thrown')
+    } catch (error) {
+      expect(error).toBeInstanceOf(Tick.TickOutOfBoundsError)
+      expect(error).toHaveProperty('name', 'Tick.TickOutOfBoundsError')
+      // BaseError appends metaMessages to the message
+      expect((error as Error).message).toContain('Tick -2001 is out of bounds.')
+      expect((error as Error).message).toContain(
+        'Tick must be between -2000 and 2000.',
+      )
+    }
+  })
+
+  test('PriceOutOfBoundsError is catchable and has correct properties', () => {
+    try {
+      Tick.fromPrice('0.979')
+      expect.fail('Should have thrown')
+    } catch (error) {
+      expect(error).toBeInstanceOf(Tick.PriceOutOfBoundsError)
+      expect(error).toHaveProperty('name', 'Tick.PriceOutOfBoundsError')
+      expect((error as Error).message).toContain(
+        'Price "0.979" results in tick -2100 which is out of bounds.',
+      )
+      expect((error as Error).message).toContain(
+        'Tick must be between -2000 and 2000.',
+      )
+    }
+  })
+
+  test('can distinguish between error types', () => {
+    try {
+      Tick.fromPrice('invalid')
+    } catch (error) {
+      if (error instanceof Tick.InvalidPriceFormatError) {
+        expect(true).toBe(true) // Successfully caught as InvalidPriceFormatError
+      } else {
+        expect.fail('Should be InvalidPriceFormatError')
+      }
+    }
+
+    try {
+      Tick.toPrice(-2001)
+    } catch (error) {
+      if (error instanceof Tick.TickOutOfBoundsError) {
+        expect(true).toBe(true) // Successfully caught as TickOutOfBoundsError
+      } else {
+        expect.fail('Should be TickOutOfBoundsError')
+      }
+    }
+
+    try {
+      Tick.fromPrice('0.979')
+    } catch (error) {
+      if (error instanceof Tick.PriceOutOfBoundsError) {
+        expect(true).toBe(true) // Successfully caught as PriceOutOfBoundsError
+      } else {
+        expect.fail('Should be PriceOutOfBoundsError')
+      }
+    }
+  })
+})
+
+describe('precision and edge cases', () => {
+  test('handles very small price increments', () => {
+    // 0.1 bps = 0.001% = 0.00001 in decimal
+    expect(Tick.fromPrice('1.00001')).toBe(1)
+    expect(Tick.fromPrice('1.00002')).toBe(2)
+  })
+
+  test('price scale maintains exact 5 decimal precision', () => {
+    // The price scale is 100,000 which gives us exactly 5 decimal places
+    const price0 = Tick.toPrice(0)
+    const price1 = Tick.toPrice(1)
+    expect(price0).toBe('1')
+    expect(price1).toBe('1.00001')
+
+    // Verify exact difference
+    const diff = Number(price1) - Number(price0)
+    expect(diff).toBeCloseTo(0.00001, 10)
+  })
+
+  test('symmetric around 1.0', () => {
+    // +100 ticks should have same magnitude as -100 ticks from 1.0
+    const priceUp = Tick.toPrice(100)
+    const priceDown = Tick.toPrice(-100)
+    expect(priceUp).toBe('1.001')
+    expect(priceDown).toBe('0.999')
+
+    const upDiff = Number(priceUp) - 1.0
+    const downDiff = 1.0 - Number(priceDown)
+    expect(upDiff).toBeCloseTo(downDiff, 10)
+  })
+
+  test('validates 2% range', () => {
+    // At minimum tick, price should be exactly 2% below 1.0
+    const minPrice = Tick.toPrice(Tick.minTick)
+    expect(minPrice).toBe('0.98')
+    expect((1.0 - Number(minPrice)) / 1.0).toBeCloseTo(0.02, 10)
+
+    // At maximum tick, price should be exactly 2% above 1.0
+    const maxPrice = Tick.toPrice(Tick.maxTick)
+    expect(maxPrice).toBe('1.02')
+    expect((Number(maxPrice) - 1.0) / 1.0).toBeCloseTo(0.02, 10)
+  })
+
+  test('no floating point precision errors', () => {
+    // String-based parsing should eliminate float precision issues
+    expect(Tick.fromPrice('0.99999')).toBe(-1)
+    expect(Tick.fromPrice('1.00001')).toBe(1)
+
+    // These would potentially fail with float arithmetic
+    expect(Tick.fromPrice('0.98001')).toBe(-1999)
+    expect(Tick.fromPrice('1.01999')).toBe(1999)
+  })
+})

package/tempo/Tick.ts

@@ -0,0 +1,186 @@
+import * as Errors from '../core/Errors.js'
+
+/**
+ * Minimum allowed tick value (-2% from peg).
+ *
+ * [Stablecoin DEX Pricing](https://docs.tempo.xyz/protocol/exchange/spec#key-concepts)
+ */
+export const minTick = -2000
+
+/**
+ * Maximum allowed tick value (+2% from peg).
+ *
+ * [Stablecoin DEX Pricing](https://docs.tempo.xyz/protocol/exchange/spec#key-concepts)
+ */
+export const maxTick = 2000
+
+/**
+ * Price scaling factor (5 decimal places for 0.1 bps precision).
+ *
+ * The DEX uses a tick-based pricing system where `price = PRICE_SCALE + tick`.
+ * Orders must be placed at ticks divisible by `TICK_SPACING = 10` (1 bp grid).
+ *
+ * [Stablecoin DEX Pricing](https://docs.tempo.xyz/protocol/exchange/spec#key-concepts)
+ */
+export const priceScale = 100_000
+
+/**
+ * Tick type.
+ */
+export type Tick = number
+
+/**
+ * Converts a tick to a price string.
+ *
+ * [Stablecoin DEX Pricing](https://docs.tempo.xyz/protocol/exchange/spec#key-concepts)
+ *
+ * @example
+ * ```ts
+ * import { Tick } from 'ox/tempo'
+ *
+ * // Tick 0 = price of 1.0
+ * const price1 = Tick.toPrice(0) // "1"
+ *
+ * // Tick 100 = price of 1.001 (0.1% higher)
+ * const price2 = Tick.toPrice(100) // "1.001"
+ *
+ * // Tick -100 = price of 0.999 (0.1% lower)
+ * const price3 = Tick.toPrice(-100) // "0.999"
+ * ```
+ *
+ * @param tick - The tick value (range: -2000 to +2000).
+ * @returns The price as a string with exact decimal representation.
+ * @throws `TickOutOfBoundsError` If tick is out of bounds.
+ */
+export function toPrice(tick: toPrice.Tick): toPrice.ReturnType {
+  if (tick < minTick || tick > maxTick) {
+    throw new TickOutOfBoundsError({ tick })
+  }
+  // Use integer arithmetic to avoid floating point errors
+  const price = priceScale + tick
+  const whole = Math.floor(price / priceScale)
+
+  let decimal = (price % priceScale).toString().padStart(5, '0')
+  decimal = decimal.replace(/0+$/, '')
+
+  if (decimal.length === 0) return whole.toString()
+  return `${whole}.${decimal}`
+}
+
+export declare namespace toPrice {
+  export type Tick = number
+  export type ReturnType = string
+}
+
+/**
+ * Converts a price string to a tick.
+ *
+ * [Stablecoin DEX Pricing](https://docs.tempo.xyz/protocol/exchange/spec#key-concepts)
+ *
+ * @example
+ * ```ts
+ * import { Tick } from 'ox/tempo'
+ *
+ * // Price of 1.0 = tick 0
+ * const tick1 = Tick.fromPrice('1.0') // 0
+ * const tick2 = Tick.fromPrice('1.00000') // 0
+ *
+ * // Price of 1.001 = tick 100
+ * const tick3 = Tick.fromPrice('1.001') // 100
+ *
+ * // Price of 0.999 = tick -100
+ * const tick4 = Tick.fromPrice('0.999') // -100
+ * ```
+ *
+ * @param price - The price as a string (e.g., "1.001", "0.999").
+ * @returns The tick value.
+ */
+export function fromPrice(price: fromPrice.Price): fromPrice.ReturnType {
+  const priceStr = price.trim()
+  if (!/^-?\d+(\.\d+)?$/.test(priceStr))
+    throw new InvalidPriceFormatError({ price })
+
+  // Parse price using string manipulation to avoid float precision issues
+  const [w, d = '0'] = priceStr.split('.')
+  const whole = BigInt(w!)
+
+  // Pad or truncate decimal to exactly 5 digits
+  const decimal = BigInt(d.padEnd(5, '0').slice(0, 5))
+
+  // Calculate price
+  const priceInt = whole * BigInt(priceScale) + decimal
+
+  // Calculate tick
+  const tick = Number(priceInt - BigInt(priceScale))
+
+  if (tick < minTick || tick > maxTick)
+    throw new PriceOutOfBoundsError({ price, tick })
+
+  return tick
+}
+
+export declare namespace fromPrice {
+  export type Price = string
+  export type ReturnType = number
+}
+
+/**
+ * Error thrown when a tick value is out of the allowed bounds.
+ */
+export class TickOutOfBoundsError extends Errors.BaseError {
+  override readonly name = 'Tick.TickOutOfBoundsError'
+
+  constructor(options: TickOutOfBoundsError.Options) {
+    super(`Tick ${options.tick} is out of bounds.`, {
+      metaMessages: [`Tick must be between ${minTick} and ${maxTick}.`],
+    })
+  }
+}
+
+export declare namespace TickOutOfBoundsError {
+  export type Options = {
+    tick: number
+  }
+}
+
+/**
+ * Error thrown when a price string has an invalid format.
+ */
+export class InvalidPriceFormatError extends Errors.BaseError {
+  override readonly name = 'Tick.InvalidPriceFormatError'
+
+  constructor(options: InvalidPriceFormatError.Options) {
+    super(`Invalid price format: "${options.price}".`, {
+      metaMessages: ['Price must be a decimal number string (e.g., "1.001").'],
+    })
+  }
+}
+
+export declare namespace InvalidPriceFormatError {
+  export type Options = {
+    price: string
+  }
+}
+
+/**
+ * Error thrown when a price string results in an out-of-bounds tick.
+ */
+export class PriceOutOfBoundsError extends Errors.BaseError {
+  override readonly name = 'Tick.PriceOutOfBoundsError'
+
+  constructor(options: PriceOutOfBoundsError.Options) {
+    super(
+      `Price "${options.price}" results in tick ${options.tick} which is out of bounds.`,
+      {
+        metaMessages: [`Tick must be between ${minTick} and ${maxTick}.`],
+      },
+    )
+  }
+}
+
+export declare namespace PriceOutOfBoundsError {
+  export type Options = {
+    price: string
+    tick: number
+  }
+}

package/tempo/TokenId/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/TokenId.d.ts",
+  "main": "../../_cjs/tempo/TokenId.js",
+  "module": "../../_esm/tempo/TokenId.js"
+}

package/tempo/TokenId.test.ts

@@ -0,0 +1,40 @@
+import { TokenId } from 'ox/tempo'
+import { expect, test } from 'vitest'
+
+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',
+  )
+})

package/tempo/TokenId.ts

@@ -0,0 +1,80 @@
+import * as Address from '../core/Address.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('0x20c00000000000000000000000000000000000000001')
+ * ```
+ *
+ * @param address - The token address.
+ * @returns The token ID.
+ */
+export function fromAddress(address: Address.Address): TokenId {
+  if (!address.toLowerCase().startsWith(tip20Prefix))
+    throw new Error('invalid tip20 address.')
+  return Hex.toBigInt(Hex.slice(address, 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)
+}

package/tempo/TokenRole/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/TokenRole.d.ts",
+  "main": "../../_cjs/tempo/TokenRole.js",
+  "module": "../../_esm/tempo/TokenRole.js"
+}

package/tempo/TokenRole.test.ts

@@ -0,0 +1,16 @@
+import { Hash, Hex } from 'ox'
+import { TokenRole } from 'ox/tempo'
+import { expect, test } from 'vitest'
+
+test('serialize', () => {
+  TokenRole.roles.forEach((role) => {
+    if (role === 'defaultAdmin')
+      expect(TokenRole.serialize(role)).toBe(
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
+      )
+    else
+      expect(TokenRole.serialize(role)).toBe(
+        Hash.keccak256(Hex.fromString(TokenRole.toPreHashed[role])),
+      )
+  })
+})

package/tempo/TokenRole.ts

@@ -0,0 +1,45 @@
+import * as Hash from '../core/Hash.js'
+import * as Hex from '../core/Hex.js'
+
+export const roles = [
+  'defaultAdmin',
+  'pause',
+  'unpause',
+  'issuer',
+  'burnBlocked',
+] as const
+export type TokenRole = (typeof roles)[number]
+
+export const toPreHashed = {
+  defaultAdmin: 'DEFAULT_ADMIN_ROLE',
+  pause: 'PAUSE_ROLE',
+  unpause: 'UNPAUSE_ROLE',
+  issuer: 'ISSUER_ROLE',
+  burnBlocked: 'BURN_BLOCKED_ROLE',
+} as const satisfies Record<TokenRole, string>
+
+/**
+ * Serializes a token role to its keccak256 hash representation.
+ *
+ * TIP-20 includes a built-in RBAC system with roles like `ISSUER_ROLE` (mint/burn),
+ * `PAUSE_ROLE`/`UNPAUSE_ROLE` (emergency controls), and `BURN_BLOCKED_ROLE` (compliance).
+ *
+ * [TIP-20 RBAC](https://docs.tempo.xyz/protocol/tip20/overview#role-based-access-control-rbac)
+ *
+ * @example
+ * ```ts twoslash
+ * import { TokenRole } from 'ox/tempo'
+ *
+ * const hash = TokenRole.serialize('issuer')
+ * ```
+ *
+ * @param role - The token role to serialize.
+ * @returns The keccak256 hash of the role.
+ */
+export function serialize(role: TokenRole) {
+  if (role === 'defaultAdmin')
+    return '0x0000000000000000000000000000000000000000000000000000000000000000'
+  return Hash.keccak256(
+    Hex.fromString(toPreHashed[role as keyof typeof toPreHashed] ?? role),
+  )
+}

package/tempo/Transaction/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/Transaction.d.ts",
+  "main": "../../_cjs/tempo/Transaction.js",
+  "module": "../../_esm/tempo/Transaction.js"
+}