@alephium/web3 1.3.0 → 1.5.0

package/src/codec/{signed-int-codec.ts → int-as-4bytes-codec.ts}

@@ -15,22 +15,18 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-import { Parser } from 'binary-parser'
-import { Codec, assert } from './codec'
-
-export class SignedIntCodec implements Codec<number> {
-  parser = Parser.start().buffer('value', {
-    length: 4
-  })
+import { Codec } from './codec'
+import { Reader } from './reader'
 
+export class IntAs4BytesCodec extends Codec<number> {
   encode(value: number): Uint8Array {
     return new Uint8Array([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff])
   }
 
-  decode(bytes: Uint8Array): number {
-    assert(bytes.length === 4, 'Length should be 4')
+  _decode(input: Reader): number {
+    const bytes = input.consumeBytes(4)
     return ((bytes[0] & 0xff) << 24) | ((bytes[1] & 0xff) << 16) | ((bytes[2] & 0xff) << 8) | (bytes[3] & 0xff)
   }
 }
 
-export const signedIntCodec = new SignedIntCodec()
+export const intAs4BytesCodec = new IntAs4BytesCodec()

package/src/codec/lockup-script-codec.ts

@@ -15,84 +15,36 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-import { Parser } from 'binary-parser'
-import { DecodedCompactInt, compactSignedIntCodec } from './compact-int-codec'
-import { Codec, fixedSizeBytes } from './codec'
-import { ArrayCodec, DecodedArray } from './array-codec'
+import { i32Codec } from './compact-int-codec'
+import { byte32Codec, EnumCodec, ObjectCodec } from './codec'
+import { ArrayCodec } from './array-codec'
 
-export interface PublicKeyHash {
-  publicKeyHash: Uint8Array
-}
-
-class PublicKeyHashCodec implements Codec<PublicKeyHash> {
-  parser = fixedSizeBytes('publicKeyHash', 32)
-
-  encode(input: PublicKeyHash): Uint8Array {
-    return input.publicKeyHash
-  }
-
-  decode(input: Uint8Array): PublicKeyHash {
-    return this.parser.parse(input)
-  }
-}
-
-const publicKeyHashCodec = new PublicKeyHashCodec()
-const publicKeyHashesCodec = new ArrayCodec(publicKeyHashCodec)
-const multiSigParser = Parser.start()
-  .nest('publicKeyHashes', { type: publicKeyHashesCodec.parser })
-  .nest('m', { type: compactSignedIntCodec.parser })
-export interface MultiSig {
-  publicKeyHashes: DecodedArray<PublicKeyHash>
-  m: DecodedCompactInt
-}
-
-export interface P2SH {
-  scriptHash: Uint8Array
-}
-
-export interface P2C {
-  contractId: Uint8Array
-}
-
-export interface LockupScript {
-  scriptType: number
-  script: PublicKeyHash | MultiSig | P2SH | P2C
-}
-
-export class LockupScriptCodec implements Codec<LockupScript> {
-  parser = Parser.start()
-    .uint8('scriptType')
-    .choice('script', {
-      tag: 'scriptType',
-      choices: {
-        0: publicKeyHashCodec.parser,
-        1: multiSigParser,
-        2: Parser.start().buffer('scriptHash', { length: 32 }),
-        3: Parser.start().buffer('contractId', { length: 32 })
-      }
-    })
-
-  encode(input: LockupScript): Uint8Array {
-    const result: number[] = [input.scriptType]
-    if (input.scriptType === 0) {
-      result.push(...(input.script as PublicKeyHash).publicKeyHash)
-    } else if (input.scriptType === 1) {
-      result.push(...publicKeyHashesCodec.encode((input.script as MultiSig).publicKeyHashes.value))
-      result.push(...compactSignedIntCodec.encode((input.script as MultiSig).m))
-    } else if (input.scriptType === 2) {
-      result.push(...(input.script as P2SH).scriptHash)
-    } else if (input.scriptType === 3) {
-      result.push(...(input.script as P2C).contractId)
-    } else {
-      throw new Error(`Unsupported script type: ${input.scriptType}`)
-    }
+export type PublicKeyHash = Uint8Array
+export type P2PKH = Uint8Array
+export type P2SH = Uint8Array
+export type P2C = Uint8Array
 
-    return new Uint8Array(result)
-  }
+export const p2cCodec = byte32Codec
 
-  decode(input: Uint8Array): LockupScript {
-    return this.parser.parse(input)
-  }
+export interface P2MPKH {
+  publicKeyHashes: PublicKeyHash[]
+  m: number
 }
 
-export const lockupScriptCodec = new LockupScriptCodec()
+const p2mpkhCodec = new ObjectCodec<P2MPKH>({
+  publicKeyHashes: new ArrayCodec(byte32Codec),
+  m: i32Codec
+})
+
+export type LockupScript =
+  | { kind: 'P2PKH'; value: P2PKH }
+  | { kind: 'P2MPKH'; value: P2MPKH }
+  | { kind: 'P2SH'; value: P2SH }
+  | { kind: 'P2C'; value: P2C }
+
+export const lockupScriptCodec = new EnumCodec<LockupScript>('lockup script', {
+  P2PKH: byte32Codec,
+  P2MPKH: p2mpkhCodec,
+  P2SH: byte32Codec,
+  P2C: byte32Codec
+})

package/src/codec/method-codec.ts

@@ -15,20 +15,12 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-import { Parser } from 'binary-parser'
-import { ArrayCodec, DecodedArray } from './array-codec'
-import { DecodedCompactInt, compactSignedIntCodec } from './compact-int-codec'
-import { Codec } from './codec'
+import { ArrayCodec } from './array-codec'
+import { i32Codec } from './compact-int-codec'
+import { boolCodec, byteCodec, Codec } from './codec'
 import { instrsCodec, Instr } from './instr-codec'
-
-export interface DecodedMethod {
-  isPublic: number
-  assetModifier: number
-  argsLength: DecodedCompactInt
-  localsLength: DecodedCompactInt
-  returnLength: DecodedCompactInt
-  instrs: DecodedArray<Instr>
-}
+import { Reader } from './reader'
+import { concatBytes } from '../utils'
 
 export interface Method {
   isPublic: boolean
@@ -77,56 +69,26 @@ function encodeAssetModifier(arg: {
   return encoded | (arg.usePayToContractOnly ? 4 : 0)
 }
 
-export class MethodCodec implements Codec<DecodedMethod> {
-  parser = Parser.start()
-    .uint8('isPublic')
-    .uint8('assetModifier')
-    .nest('argsLength', {
-      type: compactSignedIntCodec.parser
-    })
-    .nest('localsLength', {
-      type: compactSignedIntCodec.parser
-    })
-    .nest('returnLength', {
-      type: compactSignedIntCodec.parser
-    })
-    .nest('instrs', {
-      type: instrsCodec.parser
-    })
-
-  encode(input: DecodedMethod): Uint8Array {
-    const result = [input.isPublic, input.assetModifier]
-    result.push(...compactSignedIntCodec.encode(input.argsLength))
-    result.push(...compactSignedIntCodec.encode(input.localsLength))
-    result.push(...compactSignedIntCodec.encode(input.returnLength))
-    result.push(...instrsCodec.encode(input.instrs.value))
-    return new Uint8Array(result)
-  }
-
-  decode(input: Uint8Array): DecodedMethod {
-    return this.parser.parse(input)
-  }
-
-  static toMethod(decodedMethod: DecodedMethod): Method {
-    return {
-      isPublic: decodedMethod.isPublic === 1,
-      ...decodeAssetModifier(decodedMethod.assetModifier),
-      argsLength: compactSignedIntCodec.toI32(decodedMethod.argsLength),
-      localsLength: compactSignedIntCodec.toI32(decodedMethod.localsLength),
-      returnLength: compactSignedIntCodec.toI32(decodedMethod.returnLength),
-      instrs: decodedMethod.instrs.value
-    }
+export class MethodCodec extends Codec<Method> {
+  encode(method: Method): Uint8Array {
+    const bytes: Uint8Array[] = []
+    bytes.push(boolCodec.encode(method.isPublic))
+    bytes.push(new Uint8Array([encodeAssetModifier(method)]))
+    bytes.push(i32Codec.encode(method.argsLength))
+    bytes.push(i32Codec.encode(method.localsLength))
+    bytes.push(i32Codec.encode(method.returnLength))
+    bytes.push(instrsCodec.encode(method.instrs))
+    return concatBytes(bytes)
   }
 
-  static fromMethod(method: Method): DecodedMethod {
-    return {
-      isPublic: method.isPublic ? 1 : 0,
-      assetModifier: encodeAssetModifier(method),
-      argsLength: compactSignedIntCodec.fromI32(method.argsLength),
-      localsLength: compactSignedIntCodec.fromI32(method.localsLength),
-      returnLength: compactSignedIntCodec.fromI32(method.returnLength),
-      instrs: instrsCodec.fromArray(method.instrs)
-    }
+  _decode(input: Reader): Method {
+    const isPublic = boolCodec._decode(input)
+    const assetModifier = decodeAssetModifier(byteCodec._decode(input))
+    const argsLength = i32Codec._decode(input)
+    const localsLength = i32Codec._decode(input)
+    const returnLength = i32Codec._decode(input)
+    const instrs = instrsCodec._decode(input)
+    return { ...assetModifier, isPublic, argsLength, localsLength, returnLength, instrs }
   }
 }
 

package/src/codec/option-codec.ts

@@ -15,45 +15,22 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-import { Parser } from 'binary-parser'
-import { Codec } from './codec'
+import { Codec, EnumCodec } from './codec'
 
-export interface Option<T> {
-  option: number
-  value?: T
-}
-export class OptionCodec<T> implements Codec<Option<T>> {
-  constructor(
-    private childCodec: Codec<T>,
-    public parser = new Parser().uint8('option').choice('value', {
-      tag: 'option',
-      choices: {
-        0: new Parser(),
-        1: childCodec.parser
-      }
-    })
-  ) {}
+export type Option<T> = { kind: 'None'; value: undefined } | { kind: 'Some'; value: T }
 
-  encode(input: Option<T>): Uint8Array {
-    const result = [input.option]
-    if (input.option === 1) {
-      result.push(...this.childCodec.encode(input.value!))
-    }
-    return new Uint8Array(result)
+const undefinedCodec = new (class extends Codec<undefined> {
+  encode(): Uint8Array {
+    return new Uint8Array([])
   }
-
-  decode(input: Uint8Array): Option<T> {
-    const result = this.parser.parse(input)
-    return {
-      ...result,
-      value: result.option ? this.childCodec.decode(result.value.value) : undefined
-    }
+  _decode(): undefined {
+    return undefined
   }
+})()
 
-  fromBytes(input?: Uint8Array): Option<T> {
-    return {
-      option: input ? 1 : 0,
-      value: input ? this.childCodec.decode(input) : undefined
-    }
-  }
+export function option<T>(codec: Codec<T>): Codec<Option<T>> {
+  return new EnumCodec<Option<T>>('option', {
+    None: undefinedCodec,
+    Some: codec
+  })
 }

package/src/codec/output-codec.ts

@@ -17,10 +17,10 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { ArrayCodec } from './array-codec'
-import { Either, EitherCodec } from './either-codec'
+import { either, Either } from './either-codec'
 import { AssetOutput, assetOutputCodec } from './asset-output-codec'
 import { ContractOutput, contractOutputCodec } from './contract-output-codec'
 
 export type Output = Either<AssetOutput, ContractOutput>
-export const outputCodec = new EitherCodec<AssetOutput, ContractOutput>(assetOutputCodec, contractOutputCodec)
+export const outputCodec = either('output', assetOutputCodec, contractOutputCodec)
 export const outputsCodec = new ArrayCodec(outputCodec)

package/src/codec/reader.ts

@@ -0,0 +1,56 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+export class Reader {
+  private index: number
+  private bytes: Uint8Array
+
+  constructor(bytes: Uint8Array) {
+    this.index = 0
+    this.bytes = bytes
+  }
+
+  consumeByte(): number {
+    if (this.index >= this.bytes.length) {
+      throw new Error(
+        `Index out of range: unable to consume byte at index ${this.index}, data length: ${this.bytes.length}`
+      )
+    }
+
+    const byte = this.bytes[`${this.index}`]
+    this.index += 1
+    return byte
+  }
+
+  consumeBytes(num: number): Uint8Array {
+    const from = this.index
+    const to = this.index + num
+    if (from > to || to > this.bytes.length) {
+      throw new Error(
+        `Index out of range: unable to consume bytes from index ${from} to ${to}, data length: ${this.bytes.length}`
+      )
+    }
+    const bytes = this.bytes.slice(from, to)
+    this.index = to
+    return bytes
+  }
+
+  consumeAll(): Uint8Array {
+    return this.consumeBytes(this.bytes.length - this.index)
+  }
+}

package/src/codec/script-codec.ts

@@ -16,46 +16,24 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { Parser } from 'binary-parser'
-import { DecodedArray } from './array-codec'
 import { Codec } from './codec'
-import { DecodedMethod, methodsCodec, Method, MethodCodec } from './method-codec'
-import { OptionCodec } from './option-codec'
-import { compactSignedIntCodec } from './compact-int-codec'
-
-export interface DecodedScript {
-  methods: DecodedArray<DecodedMethod>
-}
+import { methodsCodec, Method } from './method-codec'
+import { option } from './option-codec'
+import { Reader } from './reader'
 
 export interface Script {
   methods: Method[]
 }
 
-export class ScriptCodec implements Codec<DecodedScript> {
-  parser = Parser.start().nest('methods', {
-    type: methodsCodec.parser
-  })
-
-  encode(input: DecodedScript): Uint8Array {
-    return methodsCodec.encode(input.methods.value)
-  }
-
-  decode(input: Uint8Array): DecodedScript {
-    return this.parser.parse(input)
-  }
-
-  decodeScript(input: Uint8Array): Script {
-    const decodedTxScript = this.decode(input)
-    const methods = decodedTxScript.methods.value.map((decodedMethod) => MethodCodec.toMethod(decodedMethod))
-    return { methods }
+export class ScriptCodec extends Codec<Script> {
+  encode(input: Script): Uint8Array {
+    return methodsCodec.encode(input.methods)
   }
 
-  encodeScript(inputTxScript: Script): Uint8Array {
-    const methodLength = compactSignedIntCodec.fromI32(inputTxScript.methods.length)
-    const decodedMethods = inputTxScript.methods.map((method) => MethodCodec.fromMethod(method))
-    return this.encode({ methods: { value: decodedMethods, length: methodLength } })
+  _decode(input: Reader): Script {
+    return { methods: methodsCodec._decode(input) }
   }
 }
 
 export const scriptCodec = new ScriptCodec()
-export const statefulScriptCodecOpt = new OptionCodec(scriptCodec)
+export const statefulScriptCodecOpt = option(scriptCodec)

package/src/codec/signature-codec.ts

@@ -15,25 +15,10 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
-import { Parser } from 'binary-parser'
 import { ArrayCodec } from './array-codec'
-import { Codec } from './codec'
+import { FixedSizeCodec } from './codec'
 
-export interface Signature {
-  value: Uint8Array
-}
+export type Signature = Uint8Array
 
-export class SignatureCodec implements Codec<Signature> {
-  parser = Parser.start().buffer('value', { length: 64 })
-
-  encode(input: Signature): Uint8Array {
-    return input.value
-  }
-
-  decode(input: Uint8Array): Signature {
-    return this.parser.parse(input)
-  }
-}
-
-export const signatureCodec = new SignatureCodec()
+export const signatureCodec = new FixedSizeCodec(64)
 export const signaturesCodec = new ArrayCodec(signatureCodec)

package/src/codec/timestamp-codec.ts

@@ -0,0 +1,42 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+import { binToHex } from '../utils'
+import { Codec, assert } from './codec'
+import { Reader } from './reader'
+
+export class TimestampCodec extends Codec<bigint> {
+  static max = 1n << 64n
+
+  encode(input: bigint): Uint8Array {
+    assert(input >= 0n && input < TimestampCodec.max, `Invalid timestamp: ${input}`)
+
+    const byteArray = new Uint8Array(8)
+    for (let index = 0; index < 8; index += 1) {
+      byteArray[`${index}`] = Number((input >> BigInt((7 - index) * 8)) & BigInt(0xff))
+    }
+
+    return byteArray
+  }
+
+  _decode(input: Reader): bigint {
+    const bytes = input.consumeBytes(8)
+    return BigInt(`0x${binToHex(bytes)}`)
+  }
+}
+
+export const timestampCodec = new TimestampCodec()

package/src/codec/token-codec.ts

@@ -16,36 +16,17 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { Parser } from 'binary-parser'
-import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
-import { Codec } from './codec'
+import { u256Codec } from './compact-int-codec'
+import { byte32Codec, ObjectCodec } from './codec'
 import { ArrayCodec } from './array-codec'
-import { concatBytes } from '../utils'
 
 export interface Token {
   tokenId: Uint8Array
-  amount: DecodedCompactInt
+  amount: bigint
 }
 
-export class TokenCodec implements Codec<Token> {
-  parser = Parser.start()
-    .buffer('tokenId', {
-      length: 32
-    })
-    .nest('amount', {
-      type: compactUnsignedIntCodec.parser
-    })
-
-  encode(input: Token): Uint8Array {
-    const tokenId = input.tokenId
-    const amount = compactUnsignedIntCodec.encode(input.amount)
-    return concatBytes([tokenId, amount])
-  }
-
-  decode(input: Uint8Array): Token {
-    return this.parser.parse(input)
-  }
-}
-
-export const tokenCodec = new TokenCodec()
+export const tokenCodec = new ObjectCodec<Token>({
+  tokenId: byte32Codec,
+  amount: u256Codec
+})
 export const tokensCodec = new ArrayCodec(tokenCodec)