tempo.ts 0.0.0 → 0.0.1

package/package.json

@@ -1,4 +1,102 @@
 {
-  "name": "tempo.ts",
-  "version": "0.0.0"
+	"name": "tempo.ts",
+	"type": "module",
+	"version": "0.0.1",
+	"scripts": {
+		"build": "zshy --project ./tsconfig.build.json",
+		"changeset:publish": "bun run build && changeset publish",
+		"changeset:version": "changeset version && bun run check",
+		"check": "biome check . --write --unsafe",
+		"check:types": "tsc -b",
+		"gen:abis": "forge build --config-path ./contracts/specs/foundry.toml && bun scripts/gen:abis.ts && bun run check",
+		"test": "vitest",
+		"test:install": "cd test/tempo && cargo install --path bin/tempo"
+	},
+	"zshy": {
+		"exports": {
+			".": "./src/index.ts",
+			"./chains": "./src/chains.ts",
+			"./ox": "./src/ox/index.ts",
+			"./prool": "./src/prool/index.ts",
+			"./viem": "./src/viem/index.ts",
+			"./viem/actions": "./src/viem/actions/index.ts"
+		},
+		"cjs": false,
+		"conditions": {
+			"src": "src"
+		}
+	},
+	"dependencies": {
+		"ox": "~0.9.9"
+	},
+	"peerDependencies": {
+		"prool": "^0",
+		"viem": ">=2.38"
+	},
+	"peerDependenciesMeta": {
+		"prool": {
+			"optional": true
+		},
+		"viem": {
+			"optional": true
+		}
+	},
+	"author": "jxom <j@wevm.dev>",
+	"license": "MIT",
+	"devDependencies": {
+		"@ark/attest": "^0.49.0",
+		"@biomejs/biome": "^2.2.4",
+		"@changesets/changelog-github": "^0.5.0",
+		"@changesets/cli": "^2.27.7",
+		"@elysiajs/node": "^1.4.1",
+		"@types/bun": "latest",
+		"elysia": "latest",
+		"prool": "latest",
+		"simple-git-hooks": "^2.13.1",
+		"typescript": "^5.9.2",
+		"viem": "^2.38.0",
+		"vitest": "^3.2.4",
+		"zshy": "^0.4.2"
+	},
+	"files": [
+		"dist",
+		"src"
+	],
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"src": "./src/index.ts",
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./chains": {
+			"src": "./src/chains.ts",
+			"types": "./dist/chains.d.ts",
+			"import": "./dist/chains.js"
+		},
+		"./ox": {
+			"src": "./src/ox/index.ts",
+			"types": "./dist/ox/index.d.ts",
+			"import": "./dist/ox/index.js"
+		},
+		"./prool": {
+			"src": "./src/prool/index.ts",
+			"types": "./dist/prool/index.d.ts",
+			"import": "./dist/prool/index.js"
+		},
+		"./viem": {
+			"src": "./src/viem/index.ts",
+			"types": "./dist/viem/index.d.ts",
+			"import": "./dist/viem/index.js"
+		},
+		"./viem/actions": {
+			"src": "./src/viem/actions/index.ts",
+			"types": "./dist/viem/actions/index.d.ts",
+			"import": "./dist/viem/actions/index.js"
+		}
+	},
+	"simple-git-hooks": {
+		"pre-commit": "bun run check"
+	}
 }

package/src/chains.ts

@@ -0,0 +1,46 @@
+import { defineChain } from 'viem'
+import { chainConfig } from './viem/chain.js'
+
+export const tempoAdagietto = /*#__PURE__*/ defineChain({
+  ...chainConfig,
+  id: 1337,
+  name: 'Tempo',
+  nativeCurrency: {
+    name: 'USD',
+    symbol: 'USD',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: { http: ['https://rpc-adagietto.tempoxyz.dev'] },
+  },
+})
+
+export const tempoLento = /*#__PURE__*/ defineChain({
+  ...chainConfig,
+  id: 4246,
+  name: 'Tempo',
+  nativeCurrency: {
+    name: 'USD',
+    symbol: 'USD',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: { http: ['https://rpc-lento.tempoxyz.dev'] },
+  },
+})
+
+export const tempoLocal = /*#__PURE__*/ defineChain({
+  ...chainConfig,
+  id: 1337,
+  name: 'Tempo',
+  nativeCurrency: {
+    name: 'USD',
+    symbol: 'USD',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: { http: ['http://localhost:8545'] },
+  },
+})
+
+export const tempo = /*#__PURE__*/ defineChain(tempoLento)

package/src/index.ts

@@ -0,0 +1 @@
+export {}

package/src/internal/types.ts

@@ -0,0 +1,414 @@
+/** Combines members of an intersection into a readable type. */
+// https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg
+export type Compute<type> = { [key in keyof type]: type[key] } & unknown
+
+declare const symbol: unique symbol
+
+/**
+ * Creates a branded type of `T` with the brand `U`.
+ *
+ * @example
+ * ```ts
+ * type Result = Branded<string, 'foo'>
+ * //   ^? type Result = string & { [symbol]: 'foo' }
+ * ```
+ */
+export type Branded<T, U> = T & { [symbol]: U }
+
+/**
+ * Filters out all members of `T` that are not `P`
+ *
+ * @example
+ * ```ts
+ * type Result = Filter<['a', 'b', 'c'], 'b'>
+ * //   ^? type Result = ['a', 'c']
+ * ```
+ *
+ * @internal
+ */
+export type Filter<
+  T extends readonly unknown[],
+  P,
+  Acc extends readonly unknown[] = [],
+> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]]
+  ? [F] extends [P]
+    ? Filter<Rest, P, [...Acc, F]>
+    : Filter<Rest, P, Acc>
+  : readonly [...Acc]
+
+/**
+ * Checks if `T` can be narrowed further than `U`
+ *
+ * @example
+ * ```ts
+ * type Result = IsNarrowable<'foo', string>
+ * //   ^? true
+ * ```
+ */
+export type IsNarrowable<T, U> = IsNever<
+  (T extends U ? true : false) & (U extends T ? false : true)
+> extends true
+  ? false
+  : true
+
+/**
+ * Checks if `T` is `never`
+ *
+ * @example
+ * ```ts
+ * type Result = IsNever<never>
+ * //   ^? type Result = true
+ * ```
+ */
+export type IsNever<T> = [T] extends [never] ? true : false
+
+/**
+ * Removes `readonly` from all properties of an object.
+ *
+ * @internal
+ */
+export type Mutable<type extends object> = {
+  -readonly [key in keyof type]: type[key]
+}
+
+/**
+ * Evaluates boolean "or" condition for `T` properties.
+ *
+ * * @example
+ * ```ts
+ * type Result = Or<[false, true, false]>
+ * //   ^? type Result = true
+ * ```
+ *
+ * @example
+ * ```ts
+ * type Result = Or<[false, false, false]>
+ * //   ^? type Result = false
+ * ```
+ *
+ * @internal
+ */
+export type Or<T extends readonly unknown[]> = T extends readonly [
+  infer Head,
+  ...infer Tail,
+]
+  ? Head extends true
+    ? true
+    : Or<Tail>
+  : false
+
+/**
+ * Checks if `T` is `undefined`
+ *
+ * @example
+ * ```ts
+ * type Result = IsUndefined<undefined>
+ * //   ^? type Result = true
+ * ```
+ *
+ * @internal
+ */
+export type IsUndefined<T> = [undefined] extends [T] ? true : false
+
+/**
+ * Checks if type `T` is the `unknown` type.
+ *
+ * @internal
+ */
+export type IsUnknown<T> = unknown extends T
+  ? [T] extends [null]
+    ? false
+    : true
+  : false
+
+/** @internal */
+export type MaybePromise<T> = T | Promise<T>
+
+/**
+ * Makes attributes on the type T required if required is true.
+ *
+ * @example
+ * ```ts
+ * MaybeRequired<{ a: string, b?: number }, true>
+ * // { a: string, b: number }
+ *
+ * MaybeRequired<{ a: string, b?: number }, false>
+ * // { a: string, b?: number }
+ * ```
+ *
+ * @internal
+ */
+export type MaybeRequired<T, required extends boolean> = required extends true
+  ? ExactRequired<T>
+  : T
+
+/**
+ * Assigns the properties of U onto T.
+ *
+ * @example
+ * ```ts
+ * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
+ * // { a: undefined, b: number, c: boolean }
+ * ```
+ *
+ * @internal
+ */
+export type Assign<T, U> = Assign_inner<T, U> & U
+
+/** @internal */
+export type Assign_inner<T, U> = {
+  [K in keyof T as K extends keyof U
+    ? U[K] extends void
+      ? never
+      : K
+    : K]: K extends keyof U ? U[K] : T[K]
+}
+
+/**
+ * Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * ```ts
+ * NoUndefined<string | undefined>
+ * // string
+ * ```
+ *
+ * @internal
+ */
+export type NoUndefined<T> = T extends undefined ? never : T
+
+/**
+ * Strict version of built-in Omit type
+ *
+ * @internal
+ */
+export type Omit<type, keys extends keyof type> = Pick<
+  type,
+  Exclude<keyof type, keys>
+>
+
+/**
+ * Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * ```ts
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * // { a?: string, b: number }
+ * ```
+ *
+ * @internal
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> &
+  ExactPartial<Pick<T, K>>
+
+export type RecursiveArray<T> = T | readonly RecursiveArray<T>[]
+
+/**
+ * Creates a type that is T with the required keys K.
+ *
+ * @example
+ * ```ts
+ * RequiredBy<{ a?: string, b: number }, 'a'>
+ * // { a: string, b: number }
+ * ```
+ *
+ * @internal
+ */
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> &
+  ExactRequired<Pick<T, K>>
+
+/**
+ * Returns truthy if `array` contains `value`.
+ *
+ * @example
+ * ```ts
+ * Some<[1, 2, 3], 2>
+ * // true
+ * ```
+ *
+ * @internal
+ */
+export type Some<
+  array extends readonly unknown[],
+  value,
+> = array extends readonly [value, ...unknown[]]
+  ? true
+  : array extends readonly [unknown, ...infer rest]
+    ? Some<rest, value>
+    : false
+
+/**
+ * Prints custom error message
+ *
+ * @param messages - Error message
+ * @returns Custom error message
+ *
+ * @example
+ * ```ts
+ * type Result = TypeErrorMessage<'Custom error message'>
+ * //   ^? type Result = ['Error: Custom error message']
+ * ```
+ */
+export type TypeErrorMessage<messages extends string | string[]> =
+  messages extends string
+    ? [
+        // Surrounding with array to prevent `messages` from being widened to `string`
+        `Error: ${messages}`,
+      ]
+    : {
+        [key in keyof messages]: messages[key] extends infer message extends
+          string
+          ? `Error: ${message}`
+          : never
+      }
+
+/** @internal */
+export type UnionToTuple<
+  union,
+  ///
+  last = LastInUnion<union>,
+> = [union] extends [never] ? [] : [...UnionToTuple<Exclude<union, last>>, last]
+
+/** @internal */
+export type LastInUnion<U> = UnionToIntersection<
+  U extends unknown ? (x: U) => 0 : never
+> extends (x: infer l) => 0
+  ? l
+  : never
+
+/** @internal */
+export type UnionToIntersection<union> = (
+  union extends unknown
+    ? (arg: union) => 0
+    : never
+) extends (arg: infer i) => 0
+  ? i
+  : never
+
+/** @internal */
+export type IsUnion<
+  union,
+  ///
+  union2 = union,
+> = union extends union2 ? ([union2] extends [union] ? false : true) : never
+
+/** @internal */
+export type MaybePartial<
+  type,
+  enabled extends boolean | undefined,
+> = enabled extends true ? Compute<ExactPartial<type>> : type
+
+export type ExactPartial<type> = {
+  [key in keyof type]?: type[key] | undefined
+}
+
+/** @internal */
+export type ExactRequired<type> = {
+  [key in keyof type]-?: Exclude<type[key], undefined>
+}
+
+export type OneOf<
+  union extends object,
+  fallback extends object | undefined = undefined,
+  ///
+  keys extends KeyofUnion<union> = KeyofUnion<union>,
+> = union extends infer item
+  ? Compute<
+      item & {
+        [key in Exclude<keys, keyof item>]?: fallback extends object
+          ? key extends keyof fallback
+            ? fallback[key]
+            : undefined
+          : undefined
+      }
+    >
+  : never
+
+/** @internal */
+export type KeyofUnion<type> = type extends type ? keyof type : never
+
+/** @internal */
+export type Undefined<type> = {
+  [key in keyof type]?: undefined
+}
+
+///////////////////////////////////////////////////////////////////////////
+// Loose types
+
+/**
+ * Loose version of {@link Omit}
+ * @internal
+ */
+export type LooseOmit<type, keys extends string> = Pick<
+  type,
+  Exclude<keyof type, keys>
+>
+
+///////////////////////////////////////////////////////////////////////////
+// Union types
+
+/** @internal */
+export type UnionCompute<type> = type extends object ? Compute<type> : type
+
+/** @internal */
+export type UnionLooseOmit<type, keys extends string> = type extends any
+  ? LooseOmit<type, keys>
+  : never
+
+/**
+ * Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * ```ts
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { b: number } | { b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionOmit<type, keys extends keyof type> = type extends any
+  ? Omit<type, keys>
+  : never
+
+/**
+ * Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * ```ts
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { b: number } | { b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionPick<type, keys extends keyof type> = type extends any
+  ? Pick<type, keys>
+  : never
+
+/**
+ * Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * ```ts
+ * PartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { a?: string, b: number } | { a?: string, b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionPartialBy<T, K extends keyof T> = T extends any
+  ? PartialBy<T, K>
+  : never
+
+/**
+ * Creates a type that is T with the required keys K.
+ *
+ * @example
+ * ```ts
+ * RequiredBy<{ a?: string, b: number } | { a?: string, c?: number }, 'a'>
+ * // { a: string, b: number } | { a: string, c?: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionRequiredBy<T, K extends keyof T> = T extends any
+  ? RequiredBy<T, K>
+  : never

package/src/ox/TokenId.test.ts

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

@@ -0,0 +1,35 @@
+import * as Address from 'ox/Address'
+import * as Hex from 'ox/Hex'
+
+const tip20Prefix = '0x20c0'
+
+export type TokenId = bigint
+export type TokenIdOrAddress = TokenId | Address.Address
+
+/**
+ * Converts a TIP20 token address to a token ID.
+ *
+ * @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 TIP20 token ID to an address.
+ *
+ * @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/src/ox/TokenRole.test.ts

@@ -0,0 +1,20 @@
+import { Hash, Hex } from 'ox'
+import { TokenRole } from 'tempo.ts/ox'
+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])),
+      )
+  })
+
+  expect(TokenRole.serialize('ARBITRARY_ROLE')).toBe(
+    '0x1288a906030fe58348e9da8c4847d9d03a41eabb4999a3d64d7c0a7fb8b15c5c',
+  )
+})

package/src/ox/TokenRole.ts

@@ -0,0 +1,27 @@
+import * as Hash from 'ox/Hash'
+import * as Hex from 'ox/Hex'
+
+export const roles = [
+  'defaultAdmin',
+  'pause',
+  'unpause',
+  'issuer',
+  'burnBlocked',
+] as const
+export type TokenRole = (typeof roles)[number] | (string & {})
+
+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>
+
+export function serialize(role: TokenRole) {
+  if (role === 'defaultAdmin')
+    return '0x0000000000000000000000000000000000000000000000000000000000000000'
+  return Hash.keccak256(
+    Hex.fromString(toPreHashed[role as keyof typeof toPreHashed] ?? role),
+  )
+}