@alephium/web3 0.36.1 → 0.38.0

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

@@ -0,0 +1,149 @@
+/*
+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 { Buffer } from 'buffer/'
+import { Parser } from 'binary-parser'
+import { ArrayCodec, DecodedArray } from './array-codec'
+import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { signedIntCodec } from './signed-int-codec'
+import { longCodec } from './long-codec'
+import { ByteString, byteStringCodec } from './bytestring-codec'
+import { LockupScript, MultiSig, P2C, P2SH, lockupScriptCodec } from './lockup-script-codec'
+import { FixedAssetOutput } from '../api/api-alephium'
+import { blakeHash, createHint } from './hash'
+import { bs58, binToHex } from '../utils'
+import { Codec } from './codec'
+import { PublicKeyHash } from './lockup-script-codec'
+import { Token, tokensCodec } from './token-codec'
+
+export interface AssetOutput {
+  amount: DecodedCompactInt
+  lockupScript: LockupScript
+  lockTime: Buffer
+  tokens: DecodedArray<Token>
+  additionalData: ByteString
+}
+
+export class AssetOutputCodec implements Codec<AssetOutput> {
+  parser = Parser.start()
+    .nest('amount', {
+      type: compactUnsignedIntCodec.parser
+    })
+    .nest('lockupScript', {
+      type: lockupScriptCodec.parser
+    })
+    .buffer('lockTime', {
+      length: 8
+    })
+    .nest('tokens', {
+      type: tokensCodec.parser
+    })
+    .nest('additionalData', {
+      type: byteStringCodec.parser
+    })
+
+  encode(input: AssetOutput): Buffer {
+    const amount = Buffer.from(compactUnsignedIntCodec.encode(input.amount))
+    const lockupScript = lockupScriptCodec.encode(input.lockupScript)
+    const lockTime = Buffer.from(input.lockTime)
+    const tokens = Buffer.from(tokensCodec.encode(input.tokens.value))
+    const additionalData = Buffer.from(byteStringCodec.encode(input.additionalData))
+
+    return Buffer.concat([amount, lockupScript, lockTime, tokens, additionalData])
+  }
+
+  decode(input: Buffer): AssetOutput {
+    return this.parser.parse(input)
+  }
+
+  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) => {
+      return {
+        id: token.tokenId.toString('hex'),
+        amount: compactUnsignedIntCodec.toU256(token.amount).toString()
+      }
+    })
+    const message = output.additionalData.value.toString('hex')
+    const scriptType = output.lockupScript.scriptType
+    const key = binToHex(blakeHash(Buffer.concat([txIdBytes, signedIntCodec.encode(index)])))
+    const outputLockupScript = output.lockupScript.script
+    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) {
+      throw new Error(`P2C script type not allowed for asset output`)
+    } else {
+      throw new Error(`Unexpected output script type: ${scriptType}`)
+    }
+
+    return { hint, key, attoAlphAmount, lockTime, tokens, address, message }
+  }
+
+  static fromFixedAssetOutputs(fixedOutputs: FixedAssetOutput[]): AssetOutput[] {
+    return fixedOutputs.map((output) => {
+      return AssetOutputCodec.fromFixedAssetOutput(output)
+    })
+  }
+
+  static fromFixedAssetOutput(fixedOutput: FixedAssetOutput): AssetOutput {
+    const amount: DecodedCompactInt = compactUnsignedIntCodec.fromU256(BigInt(fixedOutput.attoAlphAmount))
+
+    const lockTime: Buffer = longCodec.encode(BigInt(fixedOutput.lockTime))
+    const lockupScript: LockupScript = lockupScriptCodec.decode(Buffer.from(bs58.decode(fixedOutput.address)))
+    const tokensValue = fixedOutput.tokens.map((token) => {
+      return {
+        tokenId: Buffer.from(token.id, 'hex'),
+        amount: compactUnsignedIntCodec.fromU256(BigInt(token.amount))
+      }
+    })
+    const tokens: DecodedArray<Token> = {
+      length: compactUnsignedIntCodec.fromU32(tokensValue.length),
+      value: tokensValue
+    }
+    const additionalDataValue = Buffer.from(fixedOutput.message, 'hex')
+    const additionalData: ByteString = {
+      length: compactUnsignedIntCodec.fromU32(additionalDataValue.length),
+      value: additionalDataValue
+    }
+
+    return {
+      amount,
+      lockupScript,
+      lockTime,
+      tokens,
+      additionalData
+    }
+  }
+}
+
+export const assetOutputCodec = new AssetOutputCodec()
+export const assetOutputsCodec = new ArrayCodec(assetOutputCodec)

package/src/codec/bigint-codec.ts

@@ -0,0 +1,92 @@
+/*
+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 { Buffer } from 'buffer/'
+export class BigIntCodec {
+  static encode(value: bigint): Buffer {
+    // Special case for zero.
+    if (value === 0n) {
+      return Buffer.from([0])
+    }
+
+    const isNegative = value < 0n
+    let absValue = isNegative ? -value : value
+    const bytes: number[] = []
+
+    // Extract bytes from absolute value.
+    while (absValue > 0n) {
+      bytes.push(Number(absValue & 0xffn))
+      absValue >>= 8n
+    }
+
+    // If the bigint is positive and the most significant byte has its high bit set,
+    // prefix the byte array with a zero byte to signify positive value.
+    if (!isNegative && (bytes[bytes.length - 1] & 0x80) !== 0) {
+      bytes.push(0)
+    }
+
+    // If the bigint is negative, compute the two's complement of the byte array.
+    if (isNegative) {
+      let carry = true
+      for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = ~bytes[i] & 0xff // Invert the bits of the byte.
+        if (carry) {
+          if (bytes[i] === 0xff) {
+            bytes[i] = 0
+          } else {
+            bytes[i] += 1
+            carry = false
+          }
+        }
+      }
+
+      // If there's still a carry, and the most significant byte is not 0xFF (to store the negative sign bit),
+      // or if no bytes were set (which means the value was -1), append a 0xFF byte to hold the carry.
+      if (carry || bytes.length === 0 || (bytes[bytes.length - 1] & 0x80) === 0) {
+        bytes.push(0xff)
+      }
+    }
+
+    // The byte array needs to be reversed since we've constructed it in little-endian order.
+    return Buffer.from(new Uint8Array(bytes.reverse()))
+  }
+
+  static decode(encoded: Buffer, signed: boolean): 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
+
+    // Convert the byte array to a bigint
+    let value = 0n
+    for (const byte of encoded) {
+      value = (value << 8n) | BigInt(byte)
+    }
+
+    // If the number is negative, convert from two's complement
+    if (isNegative) {
+      // Create a mask for the value's bit length
+      const mask = (1n << (8n * BigInt(encoded.length))) - 1n
+      value = -(~value & mask) - 1n
+    }
+
+    return value
+  }
+}

package/src/codec/bytestring-codec.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/>.
+*/
+import { Buffer } from 'buffer/'
+import { Parser } from 'binary-parser'
+import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { Codec } from './codec'
+
+export interface ByteString {
+  length: DecodedCompactInt
+  value: Buffer
+}
+
+export class ByteStringCodec implements Codec<ByteString> {
+  parser = new Parser()
+    .nest('length', {
+      type: compactUnsignedIntCodec.parser
+    })
+    .buffer('value', {
+      length: function (ctx) {
+        return compactUnsignedIntCodec.toU32(this['length']! as any as DecodedCompactInt)
+      }
+    })
+
+  encode(input: ByteString): Buffer {
+    return Buffer.from([...compactUnsignedIntCodec.encode(input.length), ...input.value])
+  }
+
+  decode(input: Buffer): ByteString {
+    return this.parser.parse(input)
+  }
+
+  encodeBuffer(input: Buffer): Buffer {
+    return Buffer.from([...compactUnsignedIntCodec.encodeU32(input.length), ...input])
+  }
+
+  decodeBuffer(input: Buffer): Buffer {
+    return this.decode(input).value
+  }
+}
+
+export const byteStringCodec = new ByteStringCodec()

package/src/codec/codec.ts

@@ -0,0 +1,31 @@
+/*
+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 { Buffer } from 'buffer/'
+import { Parser } from 'binary-parser'
+
+export interface Codec<T> {
+  parser: Parser
+  encode(input: T): Buffer
+  decode(input: Buffer): T
+}
+
+export function assert(value: boolean, message: string) {
+  if (!value) {
+    throw new Error(message)
+  }
+}

package/src/codec/compact-int-codec.ts

@@ -0,0 +1,316 @@
+/*
+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 { Buffer } from 'buffer/'
+import { Parser } from 'binary-parser'
+import { Codec, assert } from './codec'
+import { BigIntCodec } from './bigint-codec'
+import { ArrayCodec } from './array-codec'
+
+export class CompactInt {
+  static readonly oneBytePrefix = 0x00
+  static readonly oneByteNegPrefix = 0xc0
+  static readonly twoBytePrefix = 0x40
+  static readonly twoByteNegPrefix = 0x80
+  static readonly fourBytePrefix = 0x80
+  static readonly fourByteNegPrefix = 0x40
+  static readonly multiBytePrefix = 0xc0
+}
+
+const maskRest = 0xc0
+const maskMode = 0x3f
+const maskModeNeg = 0xffffffc0
+const signFlag = 0x20 // 0b00100000
+
+export interface DecodedCompactInt {
+  mode: number
+  rest: Uint8Array
+}
+
+const compactIntParser = new Parser().uint8('mode').buffer('rest', {
+  length: function (ctx) {
+    const rawMode = this['mode']
+    const mode = rawMode & maskRest
+
+    switch (mode) {
+      case CompactInt.oneBytePrefix:
+        return 0
+      case CompactInt.twoBytePrefix:
+        return 1
+      case CompactInt.fourBytePrefix:
+        return 3
+      default:
+        return (rawMode & maskMode) + 4
+    }
+  }
+})
+
+export class CompactUnsignedIntCodec implements Codec<DecodedCompactInt> {
+  private oneByteBound = 0x40
+  private twoByteBound = this.oneByteBound << 8
+  private fourByteBound = this.oneByteBound << (8 * 3)
+
+  parser = compactIntParser
+
+  encode(input: DecodedCompactInt): Buffer {
+    return Buffer.from([input.mode, ...input.rest])
+  }
+
+  encodeU32(value: number): Buffer {
+    if (value < this.oneByteBound) {
+      return Buffer.from([(CompactInt.oneBytePrefix + value) & 0xff])
+    } else if (value < this.twoByteBound) {
+      return Buffer.from([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff])
+    } else if (value < this.fourByteBound) {
+      return Buffer.from([
+        (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
+        (value >> 16) & 0xff,
+        (value >> 8) & 0xff,
+        value & 0xff
+      ])
+    } else {
+      return Buffer.from([
+        CompactInt.multiBytePrefix,
+        (value >> 24) & 0xff,
+        (value >> 16) & 0xff,
+        (value >> 8) & 0xff,
+        value & 0xff
+      ])
+    }
+  }
+
+  encodeU256(value: bigint): Buffer {
+    assert(value >= 0n, 'Value should be positive')
+
+    if (value < this.fourByteBound) {
+      return this.encodeU32(Number(value))
+    } else {
+      let bytes = BigIntCodec.encode(value)
+      if (bytes[0] === 0) {
+        bytes = bytes.slice(1)
+      }
+
+      assert(bytes.length <= 32, 'Expect <= 32 bytes for U256')
+
+      const header = (bytes.length - 4 + CompactInt.multiBytePrefix) & 0xff
+      return Buffer.concat([Buffer.from([header]), bytes])
+    }
+  }
+
+  decodeU32(input: Buffer): number {
+    const decoded = this.decode(input)
+    return this.toU32(decoded)
+  }
+
+  decodeU256(input: Buffer): bigint {
+    const decoded = this.decode(input)
+    return this.toU256(decoded)
+  }
+
+  decode(input: Buffer): DecodedCompactInt {
+    return this.parser.parse(input)
+  }
+
+  toU32(value: DecodedCompactInt): number {
+    const body = Buffer.from([value.mode, ...value.rest])
+    return decodePositiveInt(value.mode, body)
+  }
+
+  fromU32(value: number): DecodedCompactInt {
+    return this.decode(this.encodeU32(value))
+  }
+
+  toU256(value: DecodedCompactInt): bigint {
+    const mode = value.mode & maskRest
+    if (fixedSize(mode)) {
+      return BigInt(this.toU32(value))
+    } else {
+      assert(value.rest.length <= 32, 'Expect <= 32 bytes for U256')
+      return BigIntCodec.decode(Buffer.from(value.rest), false)
+    }
+  }
+
+  fromU256(value: bigint): DecodedCompactInt {
+    return this.decode(this.encodeU256(value))
+  }
+}
+
+export const compactUnsignedIntCodec = new CompactUnsignedIntCodec()
+
+export class CompactSignedIntCodec implements Codec<DecodedCompactInt> {
+  private signFlag = 0x20 // 0b00100000
+  private oneByteBound = 0x20 // 0b00100000
+  private twoByteBound = this.oneByteBound << 8
+  private fourByteBound = this.oneByteBound << (8 * 3)
+
+  parser = compactIntParser
+
+  encode(input: DecodedCompactInt): Buffer {
+    return Buffer.from([input.mode, ...input.rest])
+  }
+
+  decode(input: Buffer): DecodedCompactInt {
+    return this.parser.parse(input)
+  }
+
+  decodeI32(input: Buffer): number {
+    const decoded = this.decode(input)
+    return this.toI32(decoded)
+  }
+
+  encodeI32(value: number): Buffer {
+    if (value >= 0) {
+      if (value < this.oneByteBound) {
+        return Buffer.from([(CompactInt.oneBytePrefix + value) & 0xff])
+      } else if (value < this.twoByteBound) {
+        return Buffer.from([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff])
+      } else if (value < this.fourByteBound) {
+        return Buffer.from([
+          (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
+          (value >> 16) & 0xff,
+          (value >> 8) & 0xff,
+          value & 0xff
+        ])
+      } else {
+        return Buffer.from([
+          CompactInt.multiBytePrefix,
+          (value >> 24) & 0xff,
+          (value >> 16) & 0xff,
+          (value >> 8) & 0xff,
+          value & 0xff
+        ])
+      }
+    } else {
+      if (value >= -this.oneByteBound) {
+        return Buffer.from([(value ^ CompactInt.oneByteNegPrefix) & 0xff])
+      } else if (value >= -this.twoByteBound) {
+        return Buffer.from([((value >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, value & 0xff])
+      } else if (value >= -this.fourByteBound) {
+        return Buffer.from([
+          ((value >> 24) ^ CompactInt.fourByteNegPrefix) & 0xff,
+          (value >> 16) & 0xff,
+          (value >> 8) & 0xff,
+          value & 0xff
+        ])
+      } else {
+        return Buffer.from([
+          CompactInt.multiBytePrefix,
+          (value >> 24) & 0xff,
+          (value >> 16) & 0xff,
+          (value >> 8) & 0xff,
+          value & 0xff
+        ])
+      }
+    }
+  }
+
+  encodeI256(value: bigint): Buffer {
+    if (value >= -0x20000000 && value < 0x20000000) {
+      return this.encodeI32(Number(value))
+    } else {
+      const bytes = BigIntCodec.encode(value)
+      const header = (bytes.length - 4 + CompactInt.multiBytePrefix) & 0xff
+      return Buffer.concat([Buffer.from([header]), bytes])
+    }
+  }
+
+  decodeI256(input: Buffer): bigint {
+    const decoded = this.decode(input)
+    return this.toI256(decoded)
+  }
+
+  toI32(value: DecodedCompactInt): number {
+    const body = Buffer.from([value.mode, ...value.rest])
+    const mode = value.mode & maskRest
+    if (fixedSize(mode)) {
+      const isPositive = (value.mode & signFlag) == 0
+      if (isPositive) {
+        return decodePositiveInt(value.mode, body)
+      } else {
+        return decodeNegativeInt(value.mode, body)
+      }
+    } else {
+      if (body.length === 5) {
+        return ((body[1] & 0xff) << 24) | ((body[2] & 0xff) << 16) | ((body[3] & 0xff) << 8) | (body[4] & 0xff)
+      } else {
+        throw new Error(`Expect 4 bytes int, but get ${body.length - 1} bytes int`)
+      }
+    }
+  }
+
+  fromI32(value: number): DecodedCompactInt {
+    return this.decode(this.encodeI32(value))
+  }
+
+  toI256(value: DecodedCompactInt): bigint {
+    const mode = value.mode & maskRest
+
+    if (fixedSize(mode)) {
+      return BigInt(this.toI32(value))
+    } else {
+      assert(value.rest.length <= 32, 'Expect <= 32 bytes for I256')
+      return BigIntCodec.decode(Buffer.from(value.rest), true)
+    }
+  }
+
+  fromI256(value: bigint): DecodedCompactInt {
+    return this.decode(this.encodeI256(value))
+  }
+}
+
+export const compactSignedIntCodec = new CompactSignedIntCodec()
+
+function decodePositiveInt(rawMode: number, body: Buffer): number {
+  const mode = rawMode & maskRest
+
+  switch (mode) {
+    case CompactInt.oneBytePrefix:
+      return rawMode
+    case CompactInt.twoBytePrefix:
+      assert(body.length === 2, 'Length should be 2')
+      return ((body[0] & maskMode) << 8) | (body[1] & 0xff)
+    case CompactInt.fourBytePrefix:
+      assert(body.length === 4, 'Length should be 4')
+      return ((body[0] & maskMode) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff)
+    default:
+      if (body.length === 5) {
+        return Number(BigInt('0x' + body.slice(1).toString('hex')))
+      } else {
+        throw new Error(`decodePositiveInt: Expect 4 bytes int, but get ${body.length - 1} bytes int`)
+      }
+  }
+}
+
+function decodeNegativeInt(rawMode: number, body: Buffer) {
+  const mode = rawMode & maskRest
+  switch (mode) {
+    case CompactInt.oneBytePrefix:
+      return rawMode | maskModeNeg
+    case CompactInt.twoBytePrefix:
+      assert(body.length === 2, 'Length should be 2')
+      return ((body[0] | maskModeNeg) << 8) | (body[1] & 0xff)
+    case CompactInt.fourBytePrefix:
+      assert(body.length === 4, 'Length should be 4')
+      return ((body[0] | maskModeNeg) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff)
+    default:
+      throw new Error(`decodeNegativeInt: Expect 4 bytes int, but get ${body.length - 1} bytes int`)
+  }
+}
+
+function fixedSize(mode: number): boolean {
+  return mode === CompactInt.oneBytePrefix || mode === CompactInt.twoBytePrefix || mode === CompactInt.fourBytePrefix
+}