@alephium/web3 0.36.1 → 0.38.0

package/src/codec/method-codec.ts

@@ -0,0 +1,97 @@
+/*
+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 { 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
+    }
+  }
+
+  static fromMethod(method: Method): DecodedMethod {
+    return {
+      isPublic: method.isPublic ? 1 : 0,
+      assetModifier: method.assetModifier,
+      argsLength: compactUnsignedIntCodec.fromU32(method.argsLength),
+      localsLength: compactUnsignedIntCodec.fromU32(method.localsLength),
+      returnLength: compactUnsignedIntCodec.fromU32(method.returnLength),
+      instrs: instrsCodec.fromArray(method.instrs)
+    }
+  }
+}
+
+export const methodCodec = new MethodCodec()
+export const methodsCodec = new ArrayCodec(methodCodec)

package/src/codec/option-codec.ts

@@ -0,0 +1,60 @@
+/*
+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 } 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,45 @@
+/*
+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 { 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,40 @@
+/*
+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 } 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,37 @@
+/*
+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'
+
+import { Buffer } from 'buffer/'
+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,51 @@
+/*
+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'
+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,147 @@
+/*
+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 { 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()