@alephium/web3 1.4.0 → 1.5.0

package/dist/src/exchange/exchange.js

@@ -106,7 +106,7 @@ function getAddressFromUnlockScript(unlockScript) {
     if (unlockScriptType === UnlockScriptType.P2SH) {
         let p2sh;
         try {
-            p2sh = unlock_script_codec_1.unlockScriptCodec.decode(decoded).script;
+            p2sh = unlock_script_codec_1.unlockScriptCodec.decode(decoded).value;
         }
         catch (_) {
             throw new Error(`Invalid p2sh unlock script: ${unlockScript}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -33,7 +33,7 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "3.5.0",
+    "alephium_version": "3.5.2",
     "explorer_backend_version": "2.0.0"
   },
   "type": "commonjs",
@@ -48,8 +48,7 @@
     "elliptic": "6.5.4",
     "eventemitter3": "^4.0.7",
     "path-browserify": "^1.0.1",
-    "stream-browserify": "^3.0.0",
-    "binary-parser": "2.2.1"
+    "stream-browserify": "^3.0.0"
   },
   "devDependencies": {
     "@babel/eslint-parser": "^7.21.3",

package/src/address/address.ts

@@ -24,8 +24,8 @@ import bs58 from '../utils/bs58'
 import djb2 from '../utils/djb2'
 import { binToHex, concatBytes, hexToBinUnsafe, isHexString } from '../utils'
 import { KeyType } from '../signer'
-import { MultiSig, lockupScriptCodec } from '../codec/lockup-script-codec'
-import { compactSignedIntCodec } from '../codec'
+import { P2MPKH, lockupScriptCodec } from '../codec/lockup-script-codec'
+import { i32Codec } from '../codec'
 
 const ec = new EC('secp256k1')
 const PublicKeyHashSize = 32
@@ -61,19 +61,19 @@ function decodeAndValidateAddress(address: string): Uint8Array {
   if (decoded.length === 0) throw new Error('Address is empty')
   const addressType = decoded[0]
   if (addressType === AddressType.P2MPKH) {
-    let multisig: MultiSig
+    let multisig: P2MPKH
     try {
-      multisig = lockupScriptCodec.decode(decoded).script as MultiSig
+      multisig = lockupScriptCodec.decode(decoded).value as P2MPKH
     } catch (_) {
       throw new Error(`Invalid multisig address: ${address}`)
     }
-    const n = multisig.publicKeyHashes.value.length
-    const m = compactSignedIntCodec.toI32(multisig.m)
+    const n = multisig.publicKeyHashes.length
+    const m = multisig.m
     if (n < m || m <= 0) {
       throw new Error(`Invalid multisig address, n: ${n}, m: ${m}`)
     }
-    const encodedNSize = compactSignedIntCodec.encodeI32(n).length
-    const encodedMSize = multisig.m.rest.length + 1
+    const encodedNSize = i32Codec.encode(n).length
+    const encodedMSize = i32Codec.encode(m).length
     const size = encodedNSize + PublicKeyHashSize * n + encodedMSize + 1 // 1 for the P2MPKH prefix
     if (decoded.length === size) return decoded
   } else if (addressType === AddressType.P2PKH || addressType === AddressType.P2SH || addressType === AddressType.P2C) {

package/src/api/api-alephium.ts

@@ -1493,7 +1493,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 3.5.0
+ * @version 3.5.2
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/src/codec/array-codec.ts

@@ -15,48 +15,30 @@ 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 { compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
+import { i32Codec } from './compact-int-codec'
 import { Codec } from './codec'
+import { Reader } from './reader'
+import { concatBytes } from '../utils'
 
-export interface DecodedArray<T> {
-  length: DecodedCompactInt
-  value: T[]
-}
-
-export class ArrayCodec<T> implements Codec<T[]> {
-  constructor(private childCodec: Codec<T>, public parser = ArrayCodec.arrayParser(childCodec.parser)) {}
+export class ArrayCodec<T> extends Codec<T[]> {
+  constructor(private childCodec: Codec<T>) {
+    super()
+  }
 
   encode(input: T[]): Uint8Array {
-    const result = [...compactSignedIntCodec.encodeI256(BigInt(input.length))]
+    const bytes: Uint8Array[] = [i32Codec.encode(input.length)]
     for (const element of input) {
-      result.push(...this.childCodec.encode(element))
+      bytes.push(this.childCodec.encode(element))
     }
-    return new Uint8Array(result)
-  }
-
-  decode(input: Uint8Array): T[] {
-    const result = this.parser.parse(input)
-    return result.value.map((v) => this.childCodec.decode(v.value))
-  }
-
-  static arrayParser(parser: Parser) {
-    return new Parser()
-      .nest('length', {
-        type: compactSignedIntCodec.parser
-      })
-      .array('value', {
-        length: function (ctx) {
-          return compactSignedIntCodec.toI32(this['length']! as any as DecodedCompactInt)
-        },
-        type: parser
-      })
+    return concatBytes(bytes)
   }
 
-  fromArray(inputs: T[]): DecodedArray<T> {
-    return {
-      length: compactSignedIntCodec.fromI32(inputs.length),
-      value: inputs
+  _decode(input: Reader): T[] {
+    const length = i32Codec._decode(input)
+    const array: T[] = []
+    for (let index = 0; index < length; index += 1) {
+      array.push(this.childCodec._decode(input))
     }
+    return array
   }
 }

package/src/codec/asset-output-codec.ts

@@ -15,89 +15,54 @@ 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, compactUnsignedIntCodec } from './compact-int-codec'
-import { signedIntCodec } from './signed-int-codec'
-import { longCodec } from './long-codec'
+import { ArrayCodec } from './array-codec'
+import { u256Codec } from './compact-int-codec'
+import { intAs4BytesCodec } from './int-as-4bytes-codec'
+import { timestampCodec } from './timestamp-codec'
 import { ByteString, byteStringCodec } from './bytestring-codec'
-import { LockupScript, MultiSig, P2SH, lockupScriptCodec } from './lockup-script-codec'
+import { LockupScript, P2MPKH, P2PKH, P2SH, lockupScriptCodec } from './lockup-script-codec'
 import { FixedAssetOutput } from '../api/api-alephium'
 import { blakeHash, createHint } from './hash'
 import { bs58, binToHex, hexToBinUnsafe, concatBytes } from '../utils'
-import { Codec } from './codec'
-import { PublicKeyHash } from './lockup-script-codec'
+import { ObjectCodec } from './codec'
 import { Token, tokensCodec } from './token-codec'
 
 export interface AssetOutput {
-  amount: DecodedCompactInt
+  amount: bigint
   lockupScript: LockupScript
-  lockTime: Uint8Array
-  tokens: DecodedArray<Token>
+  lockTime: bigint
+  tokens: Token[]
   additionalData: ByteString
 }
 
-export class AssetOutputCodec implements Codec<AssetOutput> {
-  parser = Parser.start()
-    .nest('amount', {
-      type: compactSignedIntCodec.parser
-    })
-    .nest('lockupScript', {
-      type: lockupScriptCodec.parser
-    })
-    .buffer('lockTime', {
-      length: 8
-    })
-    .nest('tokens', {
-      type: tokensCodec.parser
-    })
-    .nest('additionalData', {
-      type: byteStringCodec.parser
-    })
-
-  encode(input: AssetOutput): Uint8Array {
-    const amount = compactUnsignedIntCodec.encode(input.amount)
-    const lockupScript = lockupScriptCodec.encode(input.lockupScript)
-    const tokens = tokensCodec.encode(input.tokens.value)
-    const additionalData = byteStringCodec.encode(input.additionalData)
-
-    return concatBytes([amount, lockupScript, input.lockTime, tokens, additionalData])
-  }
-
-  decode(input: Uint8Array): AssetOutput {
-    return this.parser.parse(input)
-  }
-
+export class AssetOutputCodec extends ObjectCodec<AssetOutput> {
   static toFixedAssetOutputs(txIdBytes: Uint8Array, outputs: AssetOutput[]): FixedAssetOutput[] {
     return outputs.map((output, index) => AssetOutputCodec.toFixedAssetOutput(txIdBytes, output, index))
   }
 
   static toFixedAssetOutput(txIdBytes: Uint8Array, output: AssetOutput, index: number): FixedAssetOutput {
-    const attoAlphAmount = compactUnsignedIntCodec.toU256(output.amount).toString()
-    const lockTime = Number(longCodec.decode(output.lockTime))
-    const tokens = output.tokens.value.map((token) => {
+    const attoAlphAmount = output.amount.toString()
+    const lockTime = Number(output.lockTime)
+    const tokens = output.tokens.map((token) => {
       return {
         id: binToHex(token.tokenId),
-        amount: compactUnsignedIntCodec.toU256(token.amount).toString()
+        amount: token.amount.toString()
       }
     })
-    const message = binToHex(output.additionalData.value)
-    const scriptType = output.lockupScript.scriptType
-    const key = binToHex(blakeHash(concatBytes([txIdBytes, signedIntCodec.encode(index)])))
-    const outputLockupScript = output.lockupScript.script
+    const message = binToHex(output.additionalData)
+    const scriptType = output.lockupScript.kind
+    const key = binToHex(blakeHash(concatBytes([txIdBytes, intAs4BytesCodec.encode(index)])))
+    const outputLockupScript = output.lockupScript.value
     const address = bs58.encode(lockupScriptCodec.encode(output.lockupScript))
 
     let hint: number | undefined = undefined
-    if (scriptType === 0) {
-      // P2PKH
-      hint = createHint((outputLockupScript as PublicKeyHash).publicKeyHash)
-    } else if (scriptType === 1) {
-      // P2MPKH
-      hint = createHint((outputLockupScript as MultiSig).publicKeyHashes.value[0].publicKeyHash)
-    } else if (scriptType === 2) {
-      // P2SH
-      hint = createHint((outputLockupScript as P2SH).scriptHash)
-    } else if (scriptType === 3) {
+    if (scriptType === 'P2PKH') {
+      hint = createHint(outputLockupScript as P2PKH)
+    } else if (scriptType === 'P2MPKH') {
+      hint = createHint((outputLockupScript as P2MPKH).publicKeyHashes[0])
+    } else if (scriptType === 'P2SH') {
+      hint = createHint(outputLockupScript as P2SH)
+    } else if (scriptType === 'P2C') {
       throw new Error(`P2C script type not allowed for asset output`)
     } else {
       throw new Error(`Unexpected output script type: ${scriptType}`)
@@ -113,35 +78,25 @@ export class AssetOutputCodec implements Codec<AssetOutput> {
   }
 
   static fromFixedAssetOutput(fixedOutput: FixedAssetOutput): AssetOutput {
-    const amount: DecodedCompactInt = compactUnsignedIntCodec.fromU256(BigInt(fixedOutput.attoAlphAmount))
-
-    const lockTime = longCodec.encode(BigInt(fixedOutput.lockTime))
+    const amount = BigInt(fixedOutput.attoAlphAmount)
+    const lockTime = BigInt(fixedOutput.lockTime)
     const lockupScript: LockupScript = lockupScriptCodec.decode(bs58.decode(fixedOutput.address))
-    const tokensValue = fixedOutput.tokens.map((token) => {
+    const tokens = fixedOutput.tokens.map((token) => {
       return {
         tokenId: hexToBinUnsafe(token.id),
-        amount: compactUnsignedIntCodec.fromU256(BigInt(token.amount))
+        amount: BigInt(token.amount)
       }
     })
-    const tokens: DecodedArray<Token> = {
-      length: compactSignedIntCodec.fromI32(tokensValue.length),
-      value: tokensValue
-    }
-    const additionalDataValue = hexToBinUnsafe(fixedOutput.message)
-    const additionalData: ByteString = {
-      length: compactSignedIntCodec.fromI32(additionalDataValue.length),
-      value: additionalDataValue
-    }
-
-    return {
-      amount,
-      lockupScript,
-      lockTime,
-      tokens,
-      additionalData
-    }
+    const additionalData = hexToBinUnsafe(fixedOutput.message)
+    return { amount, lockupScript, lockTime, tokens, additionalData }
   }
 }
 
-export const assetOutputCodec = new AssetOutputCodec()
+export const assetOutputCodec = new AssetOutputCodec({
+  amount: u256Codec,
+  lockupScript: lockupScriptCodec,
+  lockTime: timestampCodec,
+  tokens: tokensCodec,
+  additionalData: byteStringCodec
+})
 export const assetOutputsCodec = new ArrayCodec(assetOutputCodec)

package/src/codec/bigint-codec.ts

@@ -64,14 +64,28 @@ export class BigIntCodec {
     return new Uint8Array(bytes.reverse())
   }
 
-  static decode(encoded: Uint8Array, signed: boolean): bigint {
+  static decodeUnsigned(encoded: Uint8Array): bigint {
+    // Special case for zero.
+    if (encoded.length === 1 && encoded[0] === 0) {
+      return 0n
+    }
+
+    // Convert the byte array to a bigint
+    let value = 0n
+    for (const byte of encoded) {
+      value = (value << 8n) | BigInt(byte)
+    }
+    return value
+  }
+
+  static decodeSigned(encoded: Uint8Array): bigint {
     // Special case for zero.
     if (encoded.length === 1 && encoded[0] === 0) {
       return 0n
     }
 
     // Determine if the number is negative by checking the most significant byte (MSB)
-    const isNegative = signed ? encoded[0] === 0xff : signed
+    const isNegative = (encoded[0] & 0x80) !== 0
 
     // Convert the byte array to a bigint
     let value = 0n

package/src/codec/bytestring-codec.ts

@@ -15,42 +15,24 @@ 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 { i32Codec } from './compact-int-codec'
 import { Codec } from './codec'
 import { concatBytes } from '../utils'
+import { Reader } from './reader'
+import { ArrayCodec } from './array-codec'
 
-export interface ByteString {
-  length: DecodedCompactInt
-  value: Uint8Array
-}
-
-export class ByteStringCodec implements Codec<ByteString> {
-  parser = new Parser()
-    .nest('length', {
-      type: compactSignedIntCodec.parser
-    })
-    .buffer('value', {
-      length: function (ctx) {
-        return compactSignedIntCodec.toI32(this['length']! as any as DecodedCompactInt)
-      }
-    })
+export type ByteString = Uint8Array
 
+export class ByteStringCodec extends Codec<ByteString> {
   encode(input: ByteString): Uint8Array {
-    return concatBytes([compactSignedIntCodec.encode(input.length), input.value])
-  }
-
-  decode(input: Uint8Array): ByteString {
-    return this.parser.parse(input)
-  }
-
-  encodeBytes(input: Uint8Array): Uint8Array {
-    return concatBytes([compactSignedIntCodec.encodeI32(input.length), input])
+    return concatBytes([i32Codec.encode(input.length), input])
   }
 
-  decodeBytes(input: Uint8Array): Uint8Array {
-    return this.decode(input).value
+  _decode(input: Reader): ByteString {
+    const length = i32Codec._decode(input)
+    return input.consumeBytes(length)
   }
 }
 
 export const byteStringCodec = new ByteStringCodec()
+export const byteStringsCodec = new ArrayCodec(byteStringCodec)

package/src/codec/codec.ts

@@ -15,12 +15,33 @@ 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'
 
-export interface Codec<T> {
-  parser: Parser
-  encode(input: T): Uint8Array
-  decode(input: Uint8Array): T
+import { concatBytes } from '../utils'
+import { Reader } from './reader'
+
+export abstract class Codec<T> {
+  abstract encode(input: T): Uint8Array
+  decode(input: Uint8Array): T {
+    const reader = new Reader(input)
+    return this._decode(reader)
+  }
+
+  abstract _decode(input: Reader): T
+
+  bimap<R>(from: (v: T) => R, to: (v: R) => T): Codec<R> {
+    return new (class extends Codec<R> {
+      constructor(private readonly codecT: Codec<T>) {
+        super()
+      }
+
+      encode(input: R): Uint8Array {
+        return this.codecT.encode(to(input))
+      }
+      _decode(input: Reader): R {
+        return from(this.codecT._decode(input))
+      }
+    })(this)
+  }
 }
 
 export function assert(value: boolean, message: string) {
@@ -29,15 +50,100 @@ export function assert(value: boolean, message: string) {
   }
 }
 
-export function fixedSizeBytes(name: string, length: number): Parser {
-  return Parser.start().wrapped({
-    length,
-    type: Parser.start().buffer(name, { length }),
-    wrapper: function (result) {
-      if (result.length === length) {
-        return result
-      }
-      throw new Error(`Too few bytes when parsing ${name}, expected ${length}, got ${result.length}`)
+export class FixedSizeCodec extends Codec<Uint8Array> {
+  constructor(private readonly size: number) {
+    super()
+  }
+
+  encode(input: Uint8Array): Uint8Array {
+    assert(input.length === this.size, `Invalid length, expected ${this.size}, got ${input.length}`)
+    return input
+  }
+
+  _decode(input: Reader): Uint8Array {
+    return input.consumeBytes(this.size)
+  }
+}
+
+export class ObjectCodec<T> extends Codec<T> {
+  private keys: (keyof T)[]
+
+  constructor(private codecs: { [K in keyof T]: Codec<T[K]> }) {
+    super()
+    this.keys = Object.keys(codecs) as (keyof T)[]
+  }
+
+  encode(value: T): Uint8Array {
+    const bytes: Uint8Array[] = []
+    for (const key of this.keys) {
+      bytes.push(this.codecs[key].encode(value[key]))
+    }
+    return concatBytes(bytes)
+  }
+
+  _decode(input: Reader): T {
+    const result: T = {} as T
+    for (const key of this.keys) {
+      result[key] = this.codecs[key]._decode(input)
     }
-  })
+    return result as T
+  }
 }
+
+type ExtractKind<T> = T extends { kind: infer U extends string } ? U : never
+type ExtractValue<T, K> = T extends { kind: K; value: infer V } ? V : never
+
+export class EnumCodec<T extends { kind: ExtractKind<T>; value: ExtractValue<T, ExtractKind<T>> }> extends Codec<T> {
+  private kinds: ExtractKind<T>[]
+
+  constructor(private name: string, private codecs: { [K in ExtractKind<T>]: Codec<ExtractValue<T, K>> }) {
+    super()
+    this.kinds = Object.keys(codecs) as ExtractKind<T>[]
+  }
+
+  encode(value: T): Uint8Array {
+    const index = this.kinds.findIndex((t) => t === value.kind)
+    if (index === -1) {
+      throw new Error(`Invalid ${this.name} kind ${value.kind}, expected one of ${this.kinds}`)
+    }
+    const codec = this.codecs[value.kind]
+    return new Uint8Array([index, ...codec.encode(value.value)])
+  }
+
+  _decode(input: Reader): T {
+    const index = input.consumeByte()
+    if (index >= 0 && index < this.kinds.length) {
+      const kind = this.kinds[`${index}`]
+      const codec = this.codecs[kind as ExtractKind<T>]
+      return { kind, value: codec._decode(input) } as T
+    }
+    throw new Error(`Invalid encoded ${this.name} kind: ${index}`)
+  }
+}
+
+export const byte32Codec = new FixedSizeCodec(32)
+export const byteCodec = new (class extends Codec<number> {
+  encode(input: number): Uint8Array {
+    assert(input >= 0 && input < 256, `Invalid byte: ${input}`)
+    return new Uint8Array([input])
+  }
+  _decode(input: Reader): number {
+    return input.consumeByte()
+  }
+})()
+
+export const boolCodec = new (class extends Codec<boolean> {
+  encode(input: boolean): Uint8Array {
+    return new Uint8Array([input ? 1 : 0])
+  }
+  _decode(input: Reader): boolean {
+    const byte = input.consumeByte()
+    if (byte === 1) {
+      return true
+    } else if (byte === 0) {
+      return false
+    } else {
+      throw new Error(`Invalid encoded bool value ${byte}, expected 0 or 1`)
+    }
+  }
+})()