ox 0.0.1 → 0.1.0

package/internal/base58.ts

@@ -0,0 +1,106 @@
+import * as Bytes from '../Bytes.js'
+import type * as Errors from '../Errors.js'
+import * as Hex from '../Hex.js'
+
+/** @internal */
+export const integerToAlphabet =
+  '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+
+/** @internal */
+export const alphabetToInteger = /* __PURE__ */ Object.freeze<
+  Record<string, bigint>
+>({
+  1: 0n,
+  2: 1n,
+  3: 2n,
+  4: 3n,
+  5: 4n,
+  6: 5n,
+  7: 6n,
+  8: 7n,
+  9: 8n,
+  A: 9n,
+  B: 10n,
+  C: 11n,
+  D: 12n,
+  E: 13n,
+  F: 14n,
+  G: 15n,
+  H: 16n,
+  J: 17n,
+  K: 18n,
+  L: 19n,
+  M: 20n,
+  N: 21n,
+  P: 22n,
+  Q: 23n,
+  R: 24n,
+  S: 25n,
+  T: 26n,
+  U: 27n,
+  V: 28n,
+  W: 29n,
+  X: 30n,
+  Y: 31n,
+  Z: 32n,
+  a: 33n,
+  b: 34n,
+  c: 35n,
+  d: 36n,
+  e: 37n,
+  f: 38n,
+  g: 39n,
+  h: 40n,
+  i: 41n,
+  j: 42n,
+  k: 43n,
+  m: 44n,
+  n: 45n,
+  o: 46n,
+  p: 47n,
+  q: 48n,
+  r: 49n,
+  s: 50n,
+  t: 51n,
+  u: 52n,
+  v: 53n,
+  w: 54n,
+  x: 55n,
+  y: 56n,
+  z: 57n,
+})
+
+/** @internal */
+export function from(value: Hex.Hex | Bytes.Bytes) {
+  let bytes = Bytes.from(value)
+
+  let integer = (() => {
+    let hex = value
+    if (value instanceof Uint8Array) hex = Hex.fromBytes(bytes)
+    return BigInt(hex as string)
+  })()
+
+  let result = ''
+  while (integer > 0n) {
+    const remainder = Number(integer % 58n)
+    integer = integer / 58n
+    result = integerToAlphabet[remainder] + result
+  }
+
+  while (bytes.length > 1 && bytes[0] === 0) {
+    result = '1' + result
+    bytes = bytes.slice(1)
+  }
+
+  return result
+}
+
+/** @internal */
+export declare namespace from {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+/** @internal */
+from.parseError = (error: unknown) =>
+  /* v8 ignore next */
+  error as from.ErrorType

package/internal/bytes.ts

@@ -0,0 +1,152 @@
+import * as Bytes from '../Bytes.js'
+import type * as Errors from '../Errors.js'
+
+/** @internal */
+export function assertSize(bytes: Bytes.Bytes, size_: number): void {
+  if (Bytes.size(bytes) > size_)
+    throw new Bytes.SizeOverflowError({
+      givenSize: Bytes.size(bytes),
+      maxSize: size_,
+    })
+}
+
+/** @internal */
+export declare namespace assertSize {
+  type ErrorType =
+    | Bytes.size.ErrorType
+    | Bytes.SizeOverflowError
+    | Errors.GlobalErrorType
+}
+
+/** @internal */
+export function assertStartOffset(
+  value: Bytes.Bytes,
+  start?: number | undefined,
+) {
+  if (typeof start === 'number' && start > 0 && start > Bytes.size(value) - 1)
+    throw new Bytes.SliceOffsetOutOfBoundsError({
+      offset: start,
+      position: 'start',
+      size: Bytes.size(value),
+    })
+}
+
+export declare namespace assertStartOffset {
+  export type ErrorType =
+    | Bytes.SliceOffsetOutOfBoundsError
+    | Bytes.size.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/** @internal */
+export function assertEndOffset(
+  value: Bytes.Bytes,
+  start?: number | undefined,
+  end?: number | undefined,
+) {
+  if (
+    typeof start === 'number' &&
+    typeof end === 'number' &&
+    Bytes.size(value) !== end - start
+  ) {
+    throw new Bytes.SliceOffsetOutOfBoundsError({
+      offset: end,
+      position: 'end',
+      size: Bytes.size(value),
+    })
+  }
+}
+
+/** @internal */
+export declare namespace assertEndOffset {
+  type ErrorType =
+    | Bytes.SliceOffsetOutOfBoundsError
+    | Bytes.size.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/** @internal */
+export const charCodeMap = {
+  zero: 48,
+  nine: 57,
+  A: 65,
+  F: 70,
+  a: 97,
+  f: 102,
+} as const
+
+/** @internal */
+export function charCodeToBase16(char: number) {
+  if (char >= charCodeMap.zero && char <= charCodeMap.nine)
+    return char - charCodeMap.zero
+  if (char >= charCodeMap.A && char <= charCodeMap.F)
+    return char - (charCodeMap.A - 10)
+  if (char >= charCodeMap.a && char <= charCodeMap.f)
+    return char - (charCodeMap.a - 10)
+  return undefined
+}
+
+/** @internal */
+export function pad(bytes: Bytes.Bytes, options: pad.Options = {}) {
+  const { dir, size = 32 } = options
+  if (size === 0) return bytes
+  if (bytes.length > size)
+    throw new Bytes.SizeExceedsPaddingSizeError({
+      size: bytes.length,
+      targetSize: size,
+      type: 'Bytes',
+    })
+  const paddedBytes = new Uint8Array(size)
+  for (let i = 0; i < size; i++) {
+    const padEnd = dir === 'right'
+    paddedBytes[padEnd ? i : size - i - 1] =
+      bytes[padEnd ? i : bytes.length - i - 1]!
+  }
+  return paddedBytes
+}
+
+/** @internal */
+export declare namespace pad {
+  type Options = {
+    dir?: 'left' | 'right' | undefined
+    size?: number | undefined
+  }
+
+  type ReturnType = Bytes.Bytes
+
+  type ErrorType = Bytes.SizeExceedsPaddingSizeError | Errors.GlobalErrorType
+}
+
+/** @internal */
+export function trim(
+  value: Bytes.Bytes,
+  options: trim.Options = {},
+): trim.ReturnType {
+  const { dir = 'left' } = options
+
+  let data = value
+
+  let sliceLength = 0
+  for (let i = 0; i < data.length - 1; i++) {
+    if (data[dir === 'left' ? i : data.length - i - 1]!.toString() === '0')
+      sliceLength++
+    else break
+  }
+  data =
+    dir === 'left'
+      ? data.slice(sliceLength)
+      : data.slice(0, data.length - sliceLength)
+
+  return data as trim.ReturnType
+}
+
+/** @internal */
+export declare namespace trim {
+  type Options = {
+    dir?: 'left' | 'right' | undefined
+  }
+
+  type ReturnType = Bytes.Bytes
+
+  type ErrorType = Errors.GlobalErrorType
+}

package/internal/cursor.ts

@@ -0,0 +1,252 @@
+import type { Bytes } from '../Bytes.js'
+import * as Errors from '../Errors.js'
+
+/** @internal */
+export type Cursor = {
+  bytes: Bytes
+  dataView: DataView
+  position: number
+  positionReadCount: Map<number, number>
+  recursiveReadCount: number
+  recursiveReadLimit: number
+  remaining: number
+  assertReadLimit(position?: number): void
+  assertPosition(position: number): void
+  decrementPosition(offset: number): void
+  getReadCount(position?: number): number
+  incrementPosition(offset: number): void
+  inspectByte(position?: number): Bytes[number]
+  inspectBytes(length: number, position?: number): Bytes
+  inspectUint8(position?: number): number
+  inspectUint16(position?: number): number
+  inspectUint24(position?: number): number
+  inspectUint32(position?: number): number
+  pushByte(byte: Bytes[number]): void
+  pushBytes(bytes: Bytes): void
+  pushUint8(value: number): void
+  pushUint16(value: number): void
+  pushUint24(value: number): void
+  pushUint32(value: number): void
+  readByte(): Bytes[number]
+  readBytes(length: number, size?: number): Bytes
+  readUint8(): number
+  readUint16(): number
+  readUint24(): number
+  readUint32(): number
+  setPosition(position: number): () => void
+  _touch(): void
+}
+
+const staticCursor: Cursor = /*#__PURE__*/ {
+  bytes: new Uint8Array(),
+  dataView: new DataView(new ArrayBuffer(0)),
+  position: 0,
+  positionReadCount: new Map(),
+  recursiveReadCount: 0,
+  recursiveReadLimit: Number.POSITIVE_INFINITY,
+  assertReadLimit() {
+    if (this.recursiveReadCount >= this.recursiveReadLimit)
+      throw new RecursiveReadLimitExceededError({
+        count: this.recursiveReadCount + 1,
+        limit: this.recursiveReadLimit,
+      })
+  },
+  assertPosition(position) {
+    if (position < 0 || position > this.bytes.length - 1)
+      throw new PositionOutOfBoundsError({
+        length: this.bytes.length,
+        position,
+      })
+  },
+  decrementPosition(offset) {
+    if (offset < 0) throw new NegativeOffsetError({ offset })
+    const position = this.position - offset
+    this.assertPosition(position)
+    this.position = position
+  },
+  getReadCount(position) {
+    return this.positionReadCount.get(position || this.position) || 0
+  },
+  incrementPosition(offset) {
+    if (offset < 0) throw new NegativeOffsetError({ offset })
+    const position = this.position + offset
+    this.assertPosition(position)
+    this.position = position
+  },
+  inspectByte(position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position)
+    return this.bytes[position]!
+  },
+  inspectBytes(length, position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position + length - 1)
+    return this.bytes.subarray(position, position + length)
+  },
+  inspectUint8(position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position)
+    return this.bytes[position]!
+  },
+  inspectUint16(position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position + 1)
+    return this.dataView.getUint16(position)
+  },
+  inspectUint24(position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position + 2)
+    return (
+      (this.dataView.getUint16(position) << 8) +
+      this.dataView.getUint8(position + 2)
+    )
+  },
+  inspectUint32(position_) {
+    const position = position_ ?? this.position
+    this.assertPosition(position + 3)
+    return this.dataView.getUint32(position)
+  },
+  pushByte(byte: Bytes[number]) {
+    this.assertPosition(this.position)
+    this.bytes[this.position] = byte
+    this.position++
+  },
+  pushBytes(bytes: Bytes) {
+    this.assertPosition(this.position + bytes.length - 1)
+    this.bytes.set(bytes, this.position)
+    this.position += bytes.length
+  },
+  pushUint8(value: number) {
+    this.assertPosition(this.position)
+    this.bytes[this.position] = value
+    this.position++
+  },
+  pushUint16(value: number) {
+    this.assertPosition(this.position + 1)
+    this.dataView.setUint16(this.position, value)
+    this.position += 2
+  },
+  pushUint24(value: number) {
+    this.assertPosition(this.position + 2)
+    this.dataView.setUint16(this.position, value >> 8)
+    this.dataView.setUint8(this.position + 2, value & ~4294967040)
+    this.position += 3
+  },
+  pushUint32(value: number) {
+    this.assertPosition(this.position + 3)
+    this.dataView.setUint32(this.position, value)
+    this.position += 4
+  },
+  readByte() {
+    this.assertReadLimit()
+    this._touch()
+    const value = this.inspectByte()
+    this.position++
+    return value
+  },
+  readBytes(length, size) {
+    this.assertReadLimit()
+    this._touch()
+    const value = this.inspectBytes(length)
+    this.position += size ?? length
+    return value
+  },
+  readUint8() {
+    this.assertReadLimit()
+    this._touch()
+    const value = this.inspectUint8()
+    this.position += 1
+    return value
+  },
+  readUint16() {
+    this.assertReadLimit()
+    this._touch()
+    const value = this.inspectUint16()
+    this.position += 2
+    return value
+  },
+  readUint24() {
+    this.assertReadLimit()
+    this._touch()
+    const value = this.inspectUint24()
+    this.position += 3
+    return value
+  },
+  readUint32() {
+    this.assertReadLimit()
+    this._touch()
+    const value = this.inspectUint32()
+    this.position += 4
+    return value
+  },
+  get remaining() {
+    return this.bytes.length - this.position
+  },
+  setPosition(position) {
+    const oldPosition = this.position
+    this.assertPosition(position)
+    this.position = position
+    return () => (this.position = oldPosition)
+  },
+  _touch() {
+    if (this.recursiveReadLimit === Number.POSITIVE_INFINITY) return
+    const count = this.getReadCount()
+    this.positionReadCount.set(this.position, count + 1)
+    if (count > 0) this.recursiveReadCount++
+  },
+}
+
+/** @internal */
+export function create(
+  bytes: Bytes,
+  { recursiveReadLimit = 8_192 }: create.Config = {},
+): Cursor {
+  const cursor: Cursor = Object.create(staticCursor)
+  cursor.bytes = bytes
+  cursor.dataView = new DataView(
+    bytes.buffer,
+    bytes.byteOffset,
+    bytes.byteLength,
+  )
+  cursor.positionReadCount = new Map()
+  cursor.recursiveReadLimit = recursiveReadLimit
+  return cursor
+}
+
+/** @internal */
+export declare namespace create {
+  type Config = { recursiveReadLimit?: number | undefined }
+
+  type ErrorType = Errors.GlobalErrorType
+}
+
+/** @internal */
+export class NegativeOffsetError extends Errors.BaseError {
+  override readonly name = 'Cursor.NegativeOffsetError'
+
+  constructor({ offset }: { offset: number }) {
+    super(`Offset \`${offset}\` cannot be negative.`)
+  }
+}
+
+/** @internal */
+export class PositionOutOfBoundsError extends Errors.BaseError {
+  override readonly name = 'Cursor.PositionOutOfBoundsError'
+
+  constructor({ length, position }: { length: number; position: number }) {
+    super(
+      `Position \`${position}\` is out of bounds (\`0 < position < ${length}\`).`,
+    )
+  }
+}
+
+/** @internal */
+export class RecursiveReadLimitExceededError extends Errors.BaseError {
+  override readonly name = 'Cursor.RecursiveReadLimitExceededError'
+
+  constructor({ count, limit }: { count: number; limit: number }) {
+    super(
+      `Recursive read limit of \`${limit}\` exceeded (recursive read count: \`${count}\`).`,
+    )
+  }
+}

package/internal/ens.ts

@@ -0,0 +1,64 @@
+import * as Ens from '../Ens.js'
+import type * as Errors from '../Errors.js'
+import * as Hex from '../Hex.js'
+import { Bytes } from '../index.js'
+
+/**
+ * @internal
+ * Encodes a [DNS packet](https://docs.ens.domains/resolution/names#dns) into a ByteArray containing a UDP payload.
+ */
+export function packetToBytes(packet: string): Bytes.Bytes {
+  // strip leading and trailing `.`
+  const value = packet.replace(/^\.|\.$/gm, '')
+  if (value.length === 0) return new Uint8Array(1)
+
+  const bytes = new Uint8Array(Bytes.fromString(value).byteLength + 2)
+
+  let offset = 0
+  const list = value.split('.')
+  for (let i = 0; i < list.length; i++) {
+    let encoded = Bytes.fromString(list[i]!)
+    // if the length is > 255, make the encoded label value a labelhash
+    // this is compatible with the universal resolver
+    if (encoded.byteLength > 255)
+      encoded = Bytes.fromString(wrapLabelhash(Ens.labelhash(list[i]!)))
+    bytes[offset] = encoded.length
+    bytes.set(encoded, offset + 1)
+    offset += encoded.length + 1
+  }
+
+  if (bytes.byteLength !== offset + 1) return bytes.slice(0, offset + 1)
+
+  return bytes
+}
+
+export declare namespace packetToBytes {
+  type ErrorType =
+    | wrapLabelhash.ErrorType
+    | Ens.labelhash.ErrorType
+    | Bytes.fromString.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/** @internal */
+export function wrapLabelhash(hash: Hex.Hex): `[${string}]` {
+  return `[${hash.slice(2)}]`
+}
+
+export declare namespace wrapLabelhash {
+  type ErrorType = Errors.GlobalErrorType
+}
+
+/** @internal */
+export function unwrapLabelhash(label: string): Hex.Hex | null {
+  if (label.length !== 66) return null
+  if (label.indexOf('[') !== 0) return null
+  if (label.indexOf(']') !== 65) return null
+  const hash = `0x${label.slice(1, 65)}`
+  if (!Hex.validate(hash, { strict: true })) return null
+  return hash
+}
+
+export declare namespace unwrapLabelhash {
+  type ErrorType = Hex.validate.ErrorType | Errors.GlobalErrorType
+}

package/internal/errors.ts

@@ -0,0 +1,26 @@
+import { version } from '../version.js'
+
+/** @internal */
+export function getUrl(url: string) {
+  return url
+}
+
+/** @internal */
+export function getVersion() {
+  return version
+}
+
+/** @internal */
+export function prettyPrint(args: unknown) {
+  if (!args) return ''
+  const entries = Object.entries(args)
+    .map(([key, value]) => {
+      if (value === undefined || value === false) return null
+      return [key, value]
+    })
+    .filter(Boolean) as [string, string][]
+  const maxLength = entries.reduce((acc, [key]) => Math.max(acc, key.length), 0)
+  return entries
+    .map(([key, value]) => `  ${`${key}:`.padEnd(maxLength + 1)}  ${value}`)
+    .join('\n')
+}

package/internal/hdKey.ts

@@ -0,0 +1,25 @@
+import type { HDKey } from '@scure/bip32'
+import type * as Errors from '../Errors.js'
+import type * as HdKey from '../HdKey.js'
+import * as Hex from '../Hex.js'
+import * as Secp256k1 from '../Secp256k1.js'
+
+/** @internal */
+export function fromScure(key: HDKey): HdKey.HdKey {
+  return {
+    derive: (path) => fromScure(key.derive(path)),
+    depth: key.depth,
+    identifier: Hex.fromBytes(key.identifier!),
+    index: key.index,
+    privateKey: Hex.fromBytes(key.privateKey!),
+    privateExtendedKey: key.privateExtendedKey,
+    publicKey: Secp256k1.getPublicKey({ privateKey: key.privateKey! }),
+    publicExtendedKey: key.publicExtendedKey,
+    versions: key.versions,
+  }
+}
+
+/** @internal */
+export declare namespace fromScure {
+  type ErrorType = Errors.GlobalErrorType
+}