@subsquid/evm-codec 0.0.0

package/src/codecs/primitives.ts

@@ -0,0 +1,225 @@
+import { Codec } from '../codec'
+import { Sink } from '../sink'
+import { Src } from '../src'
+import { ArrayCodec, FixedSizeArrayCodec } from './array'
+import { StructCodec } from './struct'
+
+export const bool: Codec<boolean> = {
+  encode: function (sink: Sink, val: boolean) {
+    sink.bool(val)
+  },
+  decode(src: Src): boolean {
+    return src.bool()
+  },
+  isDynamic: false,
+}
+
+export const uint8: Codec<number> = {
+  encode(sink: Sink, val: number) {
+    sink.u8(val)
+  },
+  decode(src: Src): number {
+    return src.u8()
+  },
+  isDynamic: false,
+}
+
+export const int8: Codec<number> = {
+  encode(sink: Sink, val: number) {
+    sink.i8(val)
+  },
+  decode(src: Src): number {
+    return src.i8()
+  },
+  isDynamic: false,
+}
+
+export const uint16: Codec<number> = {
+  encode(sink: Sink, val: number) {
+    sink.u16(val)
+  },
+  decode(src: Src): number {
+    return src.u16()
+  },
+  isDynamic: false,
+}
+
+export const int16: Codec<number> = {
+  encode(sink: Sink, val: number) {
+    sink.i16(val)
+  },
+  decode(src: Src): number {
+    return src.i16()
+  },
+  isDynamic: false,
+}
+
+export const uint32: Codec<number> = {
+  encode(sink: Sink, val: number) {
+    sink.u32(val)
+  },
+  decode(src: Src): number {
+    return src.u32()
+  },
+  isDynamic: false,
+}
+
+export const int32: Codec<number> = {
+  encode(sink: Sink, val: number) {
+    sink.i32(val)
+  },
+  decode(src: Src): number {
+    return src.i32()
+  },
+  isDynamic: false,
+}
+
+export const uint64: Codec<bigint> = {
+  encode(sink: Sink, val: bigint) {
+    sink.u64(val)
+  },
+  decode(src: Src): bigint {
+    return src.u64()
+  },
+  isDynamic: false,
+}
+
+export const int64: Codec<bigint> = {
+  encode(sink: Sink, val: bigint) {
+    sink.i64(val)
+  },
+  decode(src: Src): bigint {
+    return src.i64()
+  },
+  isDynamic: false,
+}
+
+export const uint128: Codec<bigint> = {
+  encode(sink: Sink, val: bigint) {
+    sink.u128(val)
+  },
+  decode(src: Src): bigint {
+    return src.u128()
+  },
+  isDynamic: false,
+}
+
+export const int128: Codec<bigint> = {
+  encode(sink: Sink, val: bigint) {
+    sink.i128(val)
+  },
+  decode(src: Src): bigint {
+    return src.i128()
+  },
+  isDynamic: false,
+}
+
+export const uint256: Codec<bigint> = {
+  encode(sink: Sink, val: bigint) {
+    sink.u256(val)
+  },
+  decode(src: Src): bigint {
+    return src.u256()
+  },
+  isDynamic: false,
+}
+
+export const int256: Codec<bigint> = {
+  encode(sink: Sink, val: bigint) {
+    sink.i256(val)
+  },
+  decode(src: Src): bigint {
+    return src.i256()
+  },
+  isDynamic: false,
+}
+
+export const string = <const>{
+  encode(sink: Sink, val: string) {
+    sink.newStaticDataArea()
+    sink.string(val)
+    sink.endCurrentDataArea()
+  },
+  decode(src: Src): string {
+    return src.string()
+  },
+  isDynamic: true,
+}
+
+export const bytes = <const>{
+  encode(sink: Sink, val: Uint8Array) {
+    sink.newStaticDataArea()
+    sink.bytes(val)
+    sink.endCurrentDataArea()
+  },
+  decode(src: Src): Uint8Array {
+    return src.bytes()
+  },
+  isDynamic: true,
+}
+
+const bytesN = (size: number): Codec<Uint8Array> => ({
+  encode(sink: Sink, val: Uint8Array) {
+    sink.staticBytes(size, val)
+  },
+  decode(src: Src): Uint8Array {
+    return src.staticBytes(size)
+  },
+  isDynamic: false,
+})
+
+export const bytes0 = bytesN(0)
+export const bytes1 = bytesN(1)
+export const bytes2 = bytesN(2)
+export const bytes3 = bytesN(3)
+export const bytes4 = bytesN(4)
+export const bytes5 = bytesN(5)
+export const bytes6 = bytesN(6)
+export const bytes7 = bytesN(7)
+export const bytes8 = bytesN(8)
+export const bytes9 = bytesN(9)
+export const bytes10 = bytesN(10)
+export const bytes11 = bytesN(11)
+export const bytes12 = bytesN(12)
+export const bytes13 = bytesN(13)
+export const bytes14 = bytesN(14)
+export const bytes15 = bytesN(15)
+export const bytes16 = bytesN(16)
+export const bytes17 = bytesN(17)
+export const bytes18 = bytesN(18)
+export const bytes19 = bytesN(19)
+export const bytes20 = bytesN(20)
+export const bytes21 = bytesN(21)
+export const bytes22 = bytesN(22)
+export const bytes23 = bytesN(23)
+export const bytes24 = bytesN(24)
+export const bytes25 = bytesN(25)
+export const bytes26 = bytesN(26)
+export const bytes27 = bytesN(27)
+export const bytes28 = bytesN(28)
+export const bytes29 = bytesN(29)
+export const bytes30 = bytesN(30)
+export const bytes31 = bytesN(31)
+export const bytes32 = bytesN(32)
+
+export const address: Codec<string> = {
+  encode(sink: Sink, val: string) {
+    sink.address(val)
+  },
+  decode(src: Src): string {
+    return src.address()
+  },
+  isDynamic: false,
+}
+
+export const fixedSizeArray = <T>(item: Codec<T>, size: number): Codec<T[]> => new FixedSizeArrayCodec(item, size)
+
+export const array = <T>(item: Codec<T>): Codec<T[]> => new ArrayCodec(item)
+
+type Struct = {
+  [key: string]: Codec<any>
+}
+
+export const struct = <const T extends Struct>(components: T) => new StructCodec<T>(components)
+
+export const tuple = struct

package/src/codecs/struct.ts

@@ -0,0 +1,74 @@
+import { Codec, Struct, StructTypes } from '../codec'
+import { Sink } from '../sink'
+import { Src } from '../src'
+
+function slotsCount(codecs: readonly Codec<any>[]) {
+  let count = 0
+  for (const codec of codecs) {
+    count += codec.slotsCount ?? 1
+  }
+  return count
+}
+
+export class StructCodec<const T extends Struct> implements Codec<StructTypes<T>> {
+  public readonly isDynamic: boolean
+  public readonly slotsCount: number
+  private readonly childrenSlotsCount: number
+  private readonly components: T
+
+  constructor(components: T) {
+    this.components = components
+    const codecs = Object.values(components)
+    this.isDynamic = codecs.some((codec) => codec.isDynamic)
+    this.childrenSlotsCount = slotsCount(codecs)
+    if (this.isDynamic) {
+      this.slotsCount = 1
+    } else {
+      this.slotsCount = this.childrenSlotsCount
+    }
+  }
+
+  public encode(sink: Sink, val: StructTypes<T>): void {
+    if (this.isDynamic) {
+      this.encodeDynamic(sink, val)
+      return
+    }
+    for (let i in this.components) {
+      let prop = this.components[i]
+      prop.encode(sink, val[i])
+    }
+  }
+
+  private encodeDynamic(sink: Sink, val: StructTypes<T>): void {
+    sink.newStaticDataArea(this.childrenSlotsCount)
+    for (let i in this.components) {
+      let prop = this.components[i]
+      prop.encode(sink, val[i])
+    }
+    sink.endCurrentDataArea()
+  }
+
+  public decode(src: Src): StructTypes<T> {
+    if (this.isDynamic) {
+      return this.decodeDynamic(src)
+    }
+    let result: any = {}
+    for (let i in this.components) {
+      let prop = this.components[i]
+      result[i] = prop.decode(src)
+    }
+    return result
+  }
+
+  private decodeDynamic(src: Src): StructTypes<T> {
+    let result: any = {}
+
+    const offset = src.u32()
+    const tmpSrc = src.slice(offset)
+    for (let i in this.components) {
+      let prop = this.components[i]
+      result[i] = prop.decode(tmpSrc)
+    }
+    return result
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { Src } from './src'
+export { Sink } from './sink'
+export type { Codec, Struct, StructTypes } from './codec'
+export * from './codecs/primitives'

package/src/sink.ts

@@ -0,0 +1,213 @@
+import assert from 'node:assert'
+import { WORD_SIZE } from './codec'
+
+export class Sink {
+  private pos = 0
+  private buf: Buffer
+  private view: DataView
+  private stack: { start: number; jumpBackPtr: number; size: number }[] = []
+  constructor(fields: number, capacity: number = 1280) {
+    this.stack.push({
+      start: 0,
+      jumpBackPtr: 0,
+      size: fields * WORD_SIZE,
+    })
+    this.buf = Buffer.alloc(capacity)
+    this.view = new DataView(this.buf.buffer, this.buf.byteOffset, this.buf.byteLength)
+  }
+
+  result(): Buffer {
+    assert(this.stack.length === 1, 'Cannot get result during dynamic encoding')
+    return this.buf.subarray(0, this.size())
+  }
+
+  toString() {
+    return '0x' + this.result().toString('hex')
+  }
+
+  reserve(additional: number): void {
+    if (this.buf.length - this.pos < additional) {
+      this._allocate(this.pos + additional)
+    }
+  }
+
+  size() {
+    return this.stack[this.stack.length - 1].size
+  }
+
+  private _allocate(cap: number): void {
+    cap = Math.max(cap, this.buf.length * 2)
+    let buf = Buffer.alloc(cap)
+    buf.set(this.buf)
+    this.buf = buf
+    this.view = new DataView(this.buf.buffer, this.buf.byteOffset, this.buf.byteLength)
+  }
+
+  u8(val: number) {
+    this.reserve(WORD_SIZE)
+    this.pos += WORD_SIZE - 1
+    this.view.setUint8(this.pos, val)
+    this.pos += 1
+  }
+
+  i8(val: number) {
+    this.i256(BigInt(val))
+  }
+
+  u16(val: number) {
+    this.reserve(WORD_SIZE)
+    this.pos += WORD_SIZE - 2
+    this.view.setUint16(this.pos, val, false)
+    this.pos += 2
+  }
+
+  i16(val: number) {
+    this.i256(BigInt(val))
+  }
+
+  u32(val: number) {
+    this.reserve(WORD_SIZE)
+    this.pos += WORD_SIZE - 4
+    this.view.setUint32(this.pos, val, false)
+    this.pos += 4
+  }
+
+  i32(val: number) {
+    this.i256(BigInt(val))
+  }
+
+  u64(val: bigint) {
+    this.reserve(WORD_SIZE)
+    this.pos += WORD_SIZE - 8
+    this.view.setBigUint64(this.pos, val, false)
+    this.pos += 8
+  }
+
+  i64(val: bigint) {
+    this.i256(val)
+  }
+
+  #u64(val: bigint) {
+    this.view.setBigUint64(this.pos, val, false)
+    this.pos += 8
+  }
+
+  u128(val: bigint) {
+    this.reserve(WORD_SIZE)
+    this.pos += WORD_SIZE - 16
+    this.#u64(val & 0xffffffffffffffffn)
+    this.#u64(val >> 64n)
+  }
+
+  i128(val: bigint) {
+    this.i256(BigInt(val))
+  }
+
+  #u128(val: bigint) {
+    this.reserve(WORD_SIZE)
+    this.#u64(val >> 64n)
+    this.#u64(val & 0xffffffffffffffffn)
+  }
+
+  u256(val: bigint) {
+    this.reserve(WORD_SIZE)
+    this.#u128(val >> 128n)
+    this.#u128(val & (2n ** 128n - 1n))
+  }
+
+  i256(val: bigint) {
+    let base = 2n ** 256n
+    val = (val + base) % base
+    this.u256(val)
+  }
+
+  bytes(val: Uint8Array) {
+    const size = Buffer.byteLength(val)
+    this.u32(size)
+    const wordsCount = Math.ceil(size / WORD_SIZE)
+    const reservedSize = WORD_SIZE * wordsCount
+    this.reserve(reservedSize)
+    this.buf.set(val, this.pos)
+    this.pos += reservedSize
+    this.increaseCurrentDataAreaSize(reservedSize + WORD_SIZE)
+  }
+
+  staticBytes(len: number, val: Uint8Array) {
+    if (len > 32) {
+      throw new Error(`bytes${len} is not a valid type`)
+    }
+    const size = Buffer.byteLength(val)
+    if (size > len) {
+      throw new Error(`invalid data size for bytes${len}`)
+    }
+    this.reserve(WORD_SIZE)
+    this.buf.set(val, this.pos)
+    this.pos += WORD_SIZE
+  }
+
+  address(val: string) {
+    this.u256(BigInt(val))
+  }
+
+  string(val: string) {
+    const size = Buffer.byteLength(val)
+    this.u32(size)
+    const wordsCount = Math.ceil(size / WORD_SIZE)
+    const reservedSize = WORD_SIZE * wordsCount
+    this.reserve(reservedSize)
+    this.buf.write(val, this.pos)
+    this.pos += reservedSize
+    this.increaseCurrentDataAreaSize(reservedSize + WORD_SIZE)
+  }
+
+  bool(val: boolean) {
+    this.u8(val ? 1 : 0)
+  }
+
+  /**
+   * @example
+   * @link [Solidity docs](https://docs.soliditylang.org/en/latest/abi-spec.html#use-of-dynamic-types)
+   */
+  newStaticDataArea(slotsCount = 0) {
+    const offset = this.size()
+    this.u32(offset)
+    const dataAreaStart = this.currentDataAreaStart()
+    this.pushDataArea(dataAreaStart + offset, slotsCount)
+    this.pos = dataAreaStart + offset
+  }
+
+  // Adds elements count before the data area in an additional slot
+  newDynamicDataArea(slotsCount: number) {
+    const offset = this.size()
+    this.u32(offset)
+    const dataAreaStart = this.currentDataAreaStart()
+    this.pushDataArea(dataAreaStart + offset + WORD_SIZE, slotsCount)
+    this.pos = dataAreaStart + offset
+    this.u32(slotsCount)
+  }
+
+  private currentDataAreaStart() {
+    return this.stack[this.stack.length - 1].start
+  }
+
+  public increaseCurrentDataAreaSize(amount: number) {
+    this.stack[this.stack.length - 1].size += amount
+  }
+
+  private pushDataArea(dataAreaStart: number, slotsCount: number) {
+    const size = slotsCount * WORD_SIZE
+    this.reserve(dataAreaStart + size)
+    this.stack.push({
+      start: dataAreaStart,
+      jumpBackPtr: this.pos,
+      size,
+    })
+  }
+
+  public endCurrentDataArea() {
+    assert(this.stack.length > 1, 'No dynamic encoding started')
+    const { jumpBackPtr, size } = this.stack.pop()!
+    this.increaseCurrentDataAreaSize(size)
+    this.pos = jumpBackPtr
+  }
+}

package/src/src.ts

@@ -0,0 +1,158 @@
+import { WORD_SIZE } from './codec'
+
+export class Src {
+  private view: DataView
+  private pos = 0
+  private oldPos = 0
+  constructor(private buf: Uint8Array) {
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+  }
+
+  slice(start: number, end?: number): Src {
+    return new Src(this.buf.subarray(start, end))
+  }
+
+  u8(): number {
+    this.pos += WORD_SIZE - 1
+    let val = this.view.getUint8(this.pos)
+    this.pos += 1
+    return val
+  }
+
+  i8(): number {
+    return Number(this.i256())
+  }
+
+  u16(): number {
+    this.pos += WORD_SIZE - 2
+    let val = this.view.getUint16(this.pos, false)
+    this.pos += 2
+    return val
+  }
+
+  i16(): number {
+    return Number(this.i256())
+  }
+
+  u32(): number {
+    this.pos += WORD_SIZE - 4
+    let val = this.view.getUint32(this.pos, false)
+    this.pos += 4
+    return val
+  }
+
+  i32(): number {
+    return Number(this.i256())
+  }
+
+  u64(): bigint {
+    this.pos += WORD_SIZE - 8
+    return this.#u64()
+  }
+
+  #u64(): bigint {
+    let val = this.view.getBigUint64(this.pos, false)
+    this.pos += 8
+    return val
+  }
+
+  i64(): bigint {
+    this.pos += WORD_SIZE - 8
+    return this.#i64()
+  }
+
+  #i64(): bigint {
+    let val = this.view.getBigInt64(this.pos, false)
+    this.pos += 8
+    return val
+  }
+
+  u128(): bigint {
+    this.pos += WORD_SIZE - 16
+    return this.#u128()
+  }
+
+  #u128(): bigint {
+    let hi = this.#u64()
+    let lo = this.#u64()
+    return lo + (hi << 64n)
+  }
+
+  i128(): bigint {
+    this.pos += WORD_SIZE - 16
+    return this.#i128()
+  }
+
+  #i128(): bigint {
+    let hi = this.#i64()
+    let lo = this.#u64()
+    return lo + (hi << 64n)
+  }
+
+  u256(): bigint {
+    let hi = this.#u128()
+    let lo = this.#u128()
+    return lo + (hi << 128n)
+  }
+
+  i256(): bigint {
+    let hi = this.#i128()
+    let lo = this.#u128()
+    return lo + (hi << 128n)
+  }
+
+  address(): string {
+    return '0x' + this.u256().toString(16).padStart(40, '0')
+  }
+
+  bytes(): Uint8Array {
+    const ptr = this.u32()
+    this.safeJump(ptr)
+    const len = this.u32()
+    this.assertLength(len)
+    const val = this.buf.subarray(this.pos, this.pos + len)
+    this.jumpBack()
+    return val
+  }
+
+  staticBytes(len: number): Uint8Array {
+    if (len > 32) {
+      throw new Error(`bytes${len} is not a valid type`)
+    }
+    const val = this.buf.subarray(this.pos, this.pos + len)
+    this.pos += WORD_SIZE
+    return val
+  }
+
+  string(): string {
+    const ptr = this.u32()
+    this.safeJump(ptr)
+    const len = this.u32()
+    this.assertLength(len)
+    const val = Buffer.from(this.buf.buffer, this.buf.byteOffset + this.pos, len).toString('utf-8')
+    this.jumpBack()
+    return val
+  }
+
+  bool(): boolean {
+    return !!this.u8()
+  }
+
+  private assertLength(len: number): void {
+    if (this.buf.length - this.pos < len) {
+      throw new RangeError('Unexpected end of input')
+    }
+  }
+
+  public safeJump(pos: number): void {
+    if (pos < 0 || pos >= this.buf.length) {
+      throw new RangeError(`Unexpected pointer location: 0x${pos.toString(16)}`)
+    }
+    this.oldPos = this.pos
+    this.pos = pos
+  }
+
+  public jumpBack(): void {
+    this.pos = this.oldPos
+  }
+}