@alephium/web3 0.29.2 → 0.30.0-beta.1

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

@@ -0,0 +1,98 @@
+/*
+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 { Parser } from 'binary-parser'
+import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { Codec } from './codec'
+import { ArrayCodec, DecodedArray } from './array-codec'
+
+export interface PublicKeyHash {
+  publicKeyHash: Buffer
+}
+
+class PublicKeyHashCodec implements Codec<PublicKeyHash> {
+  parser = Parser.start().buffer('publicKeyHash', { length: 32 })
+
+  encode(input: PublicKeyHash): Buffer {
+    return input.publicKeyHash
+  }
+
+  decode(input: Buffer): 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: compactUnsignedIntCodec.parser })
+export interface MultiSig {
+  publicKeyHashes: DecodedArray<PublicKeyHash>
+  m: DecodedCompactInt
+}
+
+export interface P2SH {
+  scriptHash: Buffer
+}
+
+export interface P2C {
+  contractId: Buffer
+}
+
+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): Buffer {
+    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(...compactUnsignedIntCodec.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}`)
+    }
+
+    return Buffer.from(result)
+  }
+
+  decode(input: Buffer): LockupScript {
+    return this.parser.parse(input)
+  }
+}
+
+export const lockupScriptCodec = new LockupScriptCodec()

package/src/codec/long-codec.ts

@@ -0,0 +1,58 @@
+/*
+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 { Parser } from 'binary-parser'
+import { Codec, assert } from './codec'
+
+export class LongCodec implements Codec<bigint> {
+  parser = Parser.start().buffer('value', {
+    length: 8
+  })
+
+  encode(input: bigint): Buffer {
+    const byteArray = new Uint8Array(8)
+
+    assert(byteArray.length <= 8, 'Length should be less than or equal to 8')
+    for (let index = 0; index < byteArray.length; index++) {
+      const byte = input & BigInt(0xff)
+      byteArray[byteArray.length - index - 1] = Number(byte)
+      input >>= BigInt(8)
+    }
+
+    return Buffer.from(byteArray)
+  }
+
+  decode(bytes: Buffer): bigint {
+    assert(bytes.length == 8, 'Length should be 8')
+    let int64 = BigInt(0)
+    let pow = BigInt(1)
+
+    for (let i = bytes.length - 1; i >= 0; i--) {
+      int64 += BigInt(bytes[i]) * pow
+      pow *= BigInt(256)
+    }
+
+    // Determine if the number is negative (check the sign bit of the first byte)
+    if (bytes[0] & 0x80) {
+      int64 -= BigInt(1) << BigInt(64)
+    }
+
+    return int64
+  }
+}
+
+export const longCodec = new LongCodec()

package/src/codec/method-codec.ts

@@ -0,0 +1,85 @@
+/*
+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 { Parser } from 'binary-parser'
+import { ArrayCodec, DecodedArray } from './array-codec'
+import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { 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>
+}
+
+export interface Method {
+  isPublic: boolean
+  assetModifier: number
+  argsLength: number
+  localsLength: number
+  returnLength: number
+  instrs: Instr[]
+}
+
+export class MethodCodec implements Codec<DecodedMethod> {
+  parser = Parser.start()
+    .uint8('isPublic')
+    .uint8('assetModifier')
+    .nest('argsLength', {
+      type: compactUnsignedIntCodec.parser
+    })
+    .nest('localsLength', {
+      type: compactUnsignedIntCodec.parser
+    })
+    .nest('returnLength', {
+      type: compactUnsignedIntCodec.parser
+    })
+    .nest('instrs', {
+      type: instrsCodec.parser
+    })
+
+  encode(input: DecodedMethod): Buffer {
+    const result = [input.isPublic, input.assetModifier]
+    result.push(...compactUnsignedIntCodec.encode(input.argsLength))
+    result.push(...compactUnsignedIntCodec.encode(input.localsLength))
+    result.push(...compactUnsignedIntCodec.encode(input.returnLength))
+    result.push(...instrsCodec.encode(input.instrs.value))
+    return Buffer.from(result)
+  }
+
+  decode(input: Buffer): DecodedMethod {
+    return this.parser.parse(input)
+  }
+
+  static toMethod(decodedMethod: DecodedMethod): Method {
+    return {
+      isPublic: decodedMethod.isPublic === 1,
+      assetModifier: decodedMethod.assetModifier,
+      argsLength: compactUnsignedIntCodec.toU32(decodedMethod.argsLength),
+      localsLength: compactUnsignedIntCodec.toU32(decodedMethod.localsLength),
+      returnLength: compactUnsignedIntCodec.toU32(decodedMethod.returnLength),
+      instrs: decodedMethod.instrs.value
+    }
+  }
+}
+
+export const methodCodec = new MethodCodec()
+export const methodsCodec = new ArrayCodec(methodCodec)

package/src/codec/option-codec.ts

@@ -0,0 +1,59 @@
+/*
+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 { Parser } from 'binary-parser'
+import { Codec } 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
+      }
+    })
+  ) {}
+
+  encode(input: Option<T>): Buffer {
+    const result = [input.option]
+    if (input.option === 1) {
+      result.push(...this.childCodec.encode(input.value!))
+    }
+    return Buffer.from(result)
+  }
+
+  decode(input: Buffer): Option<T> {
+    const result = this.parser.parse(input)
+    return {
+      ...result,
+      value: result.option ? this.childCodec.decode(result.value.value) : undefined
+    }
+  }
+
+  fromBuffer(input?: Buffer): Option<T> {
+    return {
+      option: input ? 1 : 0,
+      value: input ? this.childCodec.decode(input) : undefined
+    }
+  }
+}

package/src/codec/output-codec.ts

@@ -0,0 +1,26 @@
+/*
+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 { ArrayCodec } from './array-codec'
+import { Either, EitherCodec } 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 outputsCodec = new ArrayCodec(outputCodec)

package/src/codec/script-codec.ts

@@ -0,0 +1,44 @@
+/*
+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 { Parser } from 'binary-parser'
+import { DecodedArray } from './array-codec'
+import { Codec } from './codec'
+import { DecodedMethod, methodsCodec } from './method-codec'
+import { OptionCodec } from './option-codec'
+
+export interface Script {
+  methods: DecodedArray<DecodedMethod>
+}
+
+export class ScriptCodec implements Codec<Script> {
+  parser = Parser.start().nest('methods', {
+    type: methodsCodec.parser
+  })
+
+  encode(input: Script): Buffer {
+    const script = methodsCodec.encode(input.methods.value)
+    return Buffer.from(script)
+  }
+
+  decode(input: Buffer): Script {
+    return this.parser.parse(input)
+  }
+}
+
+export const scriptCodec = new ScriptCodec()
+export const statefulScriptCodecOpt = new OptionCodec(scriptCodec)

package/src/codec/signature-codec.ts

@@ -0,0 +1,39 @@
+/*
+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 { Parser } from 'binary-parser'
+import { ArrayCodec } from './array-codec'
+import { Codec } from './codec'
+
+export interface Signature {
+  value: Buffer
+}
+
+export class SignatureCodec implements Codec<Signature> {
+  parser = Parser.start().buffer('value', { length: 64 })
+
+  encode(input: Signature): Buffer {
+    return input.value
+  }
+
+  decode(input: Buffer): Signature {
+    return this.parser.parse(input)
+  }
+}
+
+export const signatureCodec = new SignatureCodec()
+export const signaturesCodec = new ArrayCodec(signatureCodec)

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

@@ -0,0 +1,36 @@
+/*
+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 { Parser } from 'binary-parser'
+import { Codec, assert } from './codec'
+
+export class SignedIntCodec implements Codec<number> {
+  parser = Parser.start().buffer('value', {
+    length: 4
+  })
+
+  encode(value: number): Buffer {
+    return Buffer.from([(value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff])
+  }
+
+  decode(bytes: Buffer): number {
+    assert(bytes.length === 4, 'Length should be 4')
+    return ((bytes[0] & 0xff) << 24) | ((bytes[1] & 0xff) << 16) | ((bytes[2] & 0xff) << 8) | (bytes[3] & 0xff)
+  }
+}
+
+export const signedIntCodec = new SignedIntCodec()

package/src/codec/token-codec.ts

@@ -0,0 +1,49 @@
+/*
+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 { Parser } from 'binary-parser'
+import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { Codec } from './codec'
+import { ArrayCodec } from './array-codec'
+
+export interface Token {
+  tokenId: Buffer
+  amount: DecodedCompactInt
+}
+
+export class TokenCodec implements Codec<Token> {
+  parser = Parser.start()
+    .buffer('tokenId', {
+      length: 32
+    })
+    .nest('amount', {
+      type: compactUnsignedIntCodec.parser
+    })
+
+  encode(input: Token): Buffer {
+    const tokenId = input.tokenId
+    const amount = Buffer.from(compactUnsignedIntCodec.encode(input.amount))
+    return Buffer.concat([tokenId, amount])
+  }
+
+  decode(input: Buffer): Token {
+    return this.parser.parse(input)
+  }
+}
+
+export const tokenCodec = new TokenCodec()
+export const tokensCodec = new ArrayCodec(tokenCodec)

package/src/codec/transaction-codec.ts

@@ -0,0 +1,146 @@
+/*
+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 { Parser } from 'binary-parser'
+import { DecodedArray } from './array-codec'
+
+import { UnsignedTxCodec, UnsignedTx, unsignedTxCodec } from './unsigned-tx-codec'
+import { Signature, signaturesCodec } from './signature-codec'
+import { ContractOutputRef, contractOutputRefsCodec } from './contract-output-ref-codec'
+import { Either } from './either-codec'
+import { AssetOutput, AssetOutputCodec } from './asset-output-codec'
+import { ContractOutput, ContractOutputCodec } from './contract-output-codec'
+import { FixedAssetOutput, Transaction as ApiTransaction } from '../api/api-alephium'
+import { hexToBinUnsafe } from '..'
+import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
+import { Codec } from './codec'
+import { Output, outputCodec, outputsCodec } from './output-codec'
+
+export interface Transaction {
+  unsigned: UnsignedTx
+  scriptExecutionOk: number
+  contractInputs: DecodedArray<ContractOutputRef>
+  generatedOutputs: DecodedArray<Output>
+  inputSignatures: DecodedArray<Signature>
+  scriptSignatures: DecodedArray<Signature>
+}
+
+export class TransactionCodec implements Codec<Transaction> {
+  parser = new Parser()
+    .nest('unsigned', {
+      type: unsignedTxCodec.parser
+    })
+    .uint8('scriptExecutionOk')
+    .nest('contractInputs', {
+      type: contractOutputRefsCodec.parser
+    })
+    .nest('generatedOutputs', {
+      type: outputsCodec.parser
+    })
+    .nest('inputSignatures', {
+      type: signaturesCodec.parser
+    })
+    .nest('scriptSignatures', {
+      type: signaturesCodec.parser
+    })
+
+  encode(decodedTx: Transaction): Buffer {
+    return Buffer.concat([
+      unsignedTxCodec.encode(decodedTx.unsigned),
+      Buffer.from([decodedTx.scriptExecutionOk]),
+      Buffer.from([...contractOutputRefsCodec.encode(decodedTx.contractInputs.value)]),
+      Buffer.from([...outputsCodec.encode(decodedTx.generatedOutputs.value)]),
+      Buffer.from([...signaturesCodec.encode(decodedTx.inputSignatures.value)]),
+      Buffer.from([...signaturesCodec.encode(decodedTx.scriptSignatures.value)])
+    ])
+  }
+
+  decode(input: Buffer): Transaction {
+    return this.parser.parse(input)
+  }
+
+  encodeApiTransaction(input: ApiTransaction): Buffer {
+    const decodedTx = TransactionCodec.fromApiTransaction(input)
+    return this.encode(decodedTx)
+  }
+
+  decodeApiTransaction(input: Buffer): ApiTransaction {
+    const decodedTx = this.parser.parse(input)
+    return TransactionCodec.toApiTransaction(decodedTx)
+  }
+
+  static toApiTransaction(transaction: Transaction): ApiTransaction {
+    const txId = UnsignedTxCodec.txId(transaction.unsigned)
+    const unsigned = UnsignedTxCodec.toApiUnsignedTx(transaction.unsigned)
+    const scriptExecutionOk = !!transaction.scriptExecutionOk
+    const contractInputs = transaction.contractInputs.value.map((contractInput) => {
+      const hint = contractInput.hint
+      const key = contractInput.key.toString('hex')
+      return { hint, key }
+    })
+    const txIdBytes = hexToBinUnsafe(txId)
+    const generatedOutputs = transaction.generatedOutputs.value.map((output, index) => {
+      if (output.either === 0) {
+        const fixedAssetOutput = AssetOutputCodec.toFixedAssetOutput(txIdBytes, output.value as AssetOutput, index)
+        return { ...fixedAssetOutput, type: 'AssetOutput' }
+      } else {
+        return ContractOutputCodec.convertToApiContractOutput(txIdBytes, output.value as ContractOutput, index)
+      }
+    })
+
+    const inputSignatures = transaction.inputSignatures.value.map((signature) => signature.value.toString('hex'))
+    const scriptSignatures = transaction.scriptSignatures.value.map((signature) => signature.value.toString('hex'))
+
+    return { unsigned, scriptExecutionOk, contractInputs, generatedOutputs, inputSignatures, scriptSignatures }
+  }
+
+  static fromApiTransaction(tx: ApiTransaction): Transaction {
+    const unsigned = UnsignedTxCodec.fromApiUnsignedTx(tx.unsigned)
+    const scriptExecutionOk = tx.scriptExecutionOk ? 1 : 0
+    const contractInputs: ContractOutputRef[] = tx.contractInputs.map((contractInput) => {
+      return { hint: contractInput.hint, key: Buffer.from(contractInput.key, 'hex') }
+    })
+    const generatedOutputs: Either<AssetOutput, ContractOutput>[] = tx.generatedOutputs.map((output) => {
+      if (output.type === 'AssetOutput') {
+        return outputCodec.fromLeft(AssetOutputCodec.fromFixedAssetOutput(output as FixedAssetOutput))
+      } else if (output.type === 'ContractOutput') {
+        return outputCodec.fromRight(ContractOutputCodec.convertToOutput(output as ApiContractOutput))
+      } else {
+        throw new Error('Invalid output type')
+      }
+    })
+
+    const inputSignatures: Signature[] = tx.inputSignatures.map((signature) => {
+      return { value: Buffer.from(signature, 'hex') }
+    })
+    const scriptSignatures: Signature[] = tx.scriptSignatures.map((signature) => {
+      return { value: Buffer.from(signature, 'hex') }
+    })
+
+    return {
+      unsigned,
+      scriptExecutionOk,
+      contractInputs: contractOutputRefsCodec.fromArray(contractInputs),
+      generatedOutputs: outputsCodec.fromArray(generatedOutputs),
+      inputSignatures: signaturesCodec.fromArray(inputSignatures),
+      scriptSignatures: signaturesCodec.fromArray(scriptSignatures)
+    }
+  }
+}
+
+export const transactionCodec = new TransactionCodec()