@alephium/web3 0.36.1 → 0.38.0

package/src/codec/contract-codec.ts

@@ -0,0 +1,95 @@
+/*
+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 { Codec } from './codec'
+import { compactSignedIntCodec, compactUnsignedIntCodec, DecodedCompactInt } from './compact-int-codec'
+import { Method, MethodCodec, methodCodec } from './method-codec'
+
+const compactSignedIntsCodec = new ArrayCodec(compactSignedIntCodec)
+
+export interface HalfDecodedContract {
+  fieldLength: DecodedCompactInt
+  methodIndexes: DecodedArray<DecodedCompactInt>
+  methods: Buffer
+}
+
+export interface Contract {
+  fieldLength: number
+  methods: Method[]
+}
+
+export function toHalfDecoded(contract: Contract): HalfDecodedContract {
+  const fieldLength = compactSignedIntCodec.fromI32(contract.fieldLength)
+  const methods = contract.methods.map((m) => methodCodec.encode(MethodCodec.fromMethod(m)))
+  let count = 0
+  const methodIndexes = Array.from(Array(methods.length).keys()).map((index) => {
+    count += methods[`${index}`].length
+    return count
+  })
+  return {
+    fieldLength,
+    methodIndexes: {
+      length: compactSignedIntCodec.fromI32(methodIndexes.length),
+      value: methodIndexes.map((value) => compactSignedIntCodec.fromI32(value))
+    },
+    methods: methods.reduce((acc, buffer) => Buffer.concat([acc, buffer]))
+  }
+}
+
+export class ContractCodec implements Codec<HalfDecodedContract> {
+  parser = Parser.start()
+    .nest('fieldLength', {
+      type: compactSignedIntCodec.parser
+    })
+    .nest('methodIndexes', {
+      type: compactSignedIntsCodec.parser
+    })
+    .buffer('methods', { readUntil: 'eof' })
+
+  encode(input: HalfDecodedContract): Buffer {
+    return Buffer.from([
+      ...compactSignedIntCodec.encode(input.fieldLength),
+      ...compactSignedIntsCodec.encode(input.methodIndexes.value),
+      ...input.methods
+    ])
+  }
+
+  decode(input: Buffer): HalfDecodedContract {
+    return this.parser.parse(input)
+  }
+
+  decodeContract(input: Buffer): Contract {
+    const halfDecoded = this.decode(input)
+    const fieldLength = compactUnsignedIntCodec.toU32(halfDecoded.fieldLength)
+    const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compactUnsignedIntCodec.toU32(v))
+    const methods: Method[] = []
+    for (let i = 0, start = 0; i < methodIndexes.length; i++) {
+      const end = methodIndexes[i]
+      const method = MethodCodec.toMethod(methodCodec.decode(halfDecoded.methods.slice(start, end)))
+      methods.push(method)
+      start = end
+    }
+
+    return { fieldLength, methods }
+  }
+}
+
+export const contractCodec = new ContractCodec()

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

@@ -0,0 +1,95 @@
+/*
+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 { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { P2C } from './lockup-script-codec'
+import { Codec } from './codec'
+import { Token, tokensCodec } from './token-codec'
+import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
+import { blakeHash, createHint } from './hash'
+import { binToHex, bs58 } from '..'
+import { signedIntCodec } from './signed-int-codec'
+import { lockupScriptCodec } from './lockup-script-codec'
+
+export interface ContractOutput {
+  amount: DecodedCompactInt
+  lockupScript: P2C
+  tokens: DecodedArray<Token>
+}
+
+export class ContractOutputCodec implements Codec<ContractOutput> {
+  parser = Parser.start()
+    .nest('amount', {
+      type: compactUnsignedIntCodec.parser
+    })
+    .nest('lockupScript', {
+      type: Parser.start().buffer('contractId', { length: 32 })
+    })
+    .nest('tokens', {
+      type: tokensCodec.parser
+    })
+
+  encode(input: ContractOutput): Buffer {
+    const amount = Buffer.from(compactUnsignedIntCodec.encode(input.amount))
+    const lockupScript = input.lockupScript.contractId
+    const tokens = Buffer.from(tokensCodec.encode(input.tokens.value))
+
+    return Buffer.concat([amount, lockupScript, tokens])
+  }
+
+  decode(input: Buffer): ContractOutput {
+    return this.parser.parse(input)
+  }
+
+  static convertToApiContractOutput(txIdBytes: Uint8Array, output: ContractOutput, index: number): ApiContractOutput {
+    const hint = createHint(output.lockupScript.contractId)
+    const key = binToHex(blakeHash(Buffer.concat([txIdBytes, signedIntCodec.encode(index)])))
+    const attoAlphAmount = compactUnsignedIntCodec.toU256(output.amount).toString()
+    const address = bs58.encode(Buffer.concat([Buffer.from([0x03]), output.lockupScript.contractId]))
+    const tokens = output.tokens.value.map((token) => {
+      return {
+        id: token.tokenId.toString('hex'),
+        amount: compactUnsignedIntCodec.toU256(token.amount).toString()
+      }
+    })
+    return { hint, key, attoAlphAmount, address, tokens, type: 'ContractOutput' }
+  }
+
+  static convertToOutput(apiContractOutput: ApiContractOutput): ContractOutput {
+    const amount: DecodedCompactInt = compactUnsignedIntCodec.fromU256(BigInt(apiContractOutput.attoAlphAmount))
+    const lockupScript: P2C = lockupScriptCodec.decode(Buffer.from(bs58.decode(apiContractOutput.address)))
+      .script as P2C
+
+    const tokensValue = apiContractOutput.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
+    }
+
+    return { amount, lockupScript, tokens }
+  }
+}
+
+export const contractOutputCodec = new ContractOutputCodec()

package/src/codec/contract-output-ref-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 { Buffer } from 'buffer/'
+import { Parser } from 'binary-parser'
+import { ArrayCodec } from './array-codec'
+import { Codec } from './codec'
+import { signedIntCodec } from './signed-int-codec'
+
+export interface ContractOutputRef {
+  hint: number
+  key: Buffer
+}
+
+export class ContractOutputRefCodec implements Codec<ContractOutputRef> {
+  parser = Parser.start().int32('hint').buffer('key', { length: 32 })
+
+  encode(input: ContractOutputRef): Buffer {
+    return Buffer.concat([Buffer.from([...signedIntCodec.encode(input.hint), ...input.key])])
+  }
+
+  decode(input: Buffer): ContractOutputRef {
+    return this.parser.parse(input)
+  }
+}
+
+export const contractOutputRefCodec = new ContractOutputRefCodec()
+export const contractOutputRefsCodec = new ArrayCodec(contractOutputRefCodec)

package/src/codec/either-codec.ts

@@ -0,0 +1,74 @@
+/*
+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 Either<L, R> {
+  either: number
+  value: L | R
+}
+
+export class EitherCodec<L, R> implements Codec<Either<L, R>> {
+  constructor(
+    private leftCodec: Codec<L>,
+    private rightCodec: Codec<R>,
+    public parser = Parser.start()
+      .uint8('either')
+      .choice('value', {
+        tag: 'either',
+        choices: {
+          0: leftCodec.parser,
+          1: rightCodec.parser
+        }
+      })
+  ) {}
+
+  encode(input: Either<L, R>): Buffer {
+    const result = [input.either]
+    if (input.either === 0) {
+      result.push(...this.leftCodec.encode(input.value as L))
+    } else {
+      result.push(...this.rightCodec.encode(input.value as R))
+    }
+    return Buffer.from(result)
+  }
+
+  decode(input: Buffer): Either<L, R> {
+    const result = this.parser.parse(input)
+    return {
+      ...result,
+      value:
+        result.either === 0 ? this.leftCodec.decode(result.value.value) : this.rightCodec.decode(result.value.value)
+    }
+  }
+
+  fromLeft(left: L): Either<L, R> {
+    return {
+      either: 0,
+      value: left
+    }
+  }
+
+  fromRight(right: R): Either<L, R> {
+    return {
+      either: 1,
+      value: right
+    }
+  }
+}

package/src/codec/hash.ts

@@ -0,0 +1,35 @@
+/*
+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 blake from 'blakejs'
+
+export function blakeHash(raw: Uint8Array) {
+  return blake.blake2b(raw, undefined, 32)
+}
+
+export function djbIntHash(bytes: Buffer): number {
+  let hash = 5381
+  bytes.forEach((byte) => {
+    hash = (hash << 5) + hash + (byte & 0xff)
+  })
+  return hash
+}
+
+export function createHint(input: Buffer): number {
+  return djbIntHash(input) | 1
+}

package/src/codec/index.ts

@@ -0,0 +1,41 @@
+/*
+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 * from './array-codec'
+export * as assetOutput from './asset-output-codec'
+export * from './bigint-codec'
+export * from './bytestring-codec'
+export * from './codec'
+export * from './compact-int-codec'
+export * as contractOutput from './contract-output-codec'
+export * from './contract-output-ref-codec'
+export * from './either-codec'
+export * from './input-codec'
+export * from './instr-codec'
+export * as lockupScript from './lockup-script-codec'
+export * as unlockScript from './unlock-script-codec'
+export * from './long-codec'
+export * from './method-codec'
+export * from './option-codec'
+export * as script from './script-codec'
+export * from './signature-codec'
+export * from './signed-int-codec'
+export * as token from './token-codec'
+export * from './transaction-codec'
+export * from './unsigned-tx-codec'
+export * as contract from './contract-codec'

package/src/codec/input-codec.ts

@@ -0,0 +1,81 @@
+/*
+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 { AssetInput } from '../api/api-alephium'
+import { binToHex } from '../utils'
+import { UnlockScript, unlockScriptCodec } from './unlock-script-codec'
+import { Codec } from './codec'
+import { signedIntCodec } from './signed-int-codec'
+import { ArrayCodec } from './array-codec'
+
+export interface Input {
+  outputRef: {
+    hint: number
+    key: Buffer
+  }
+  unlockScript: UnlockScript
+}
+
+export class InputCodec implements Codec<Input> {
+  parser = Parser.start()
+    .nest('outputRef', {
+      type: Parser.start().int32('hint').buffer('key', { length: 32 })
+    })
+    .nest('unlockScript', {
+      type: unlockScriptCodec.parser
+    })
+
+  encode(input: Input): Buffer {
+    return Buffer.concat([
+      Buffer.from([...signedIntCodec.encode(input.outputRef.hint), ...input.outputRef.key]),
+      unlockScriptCodec.encode(input.unlockScript)
+    ])
+  }
+
+  decode(input: Buffer): Input {
+    return this.parser.parse(input)
+  }
+
+  static toAssetInputs(inputs: Input[]): AssetInput[] {
+    return inputs.map((input) => {
+      const hint = input.outputRef.hint
+      const key = binToHex(input.outputRef.key)
+      const unlockScript = unlockScriptCodec.encode(input.unlockScript)
+      return {
+        outputRef: { hint, key },
+        unlockScript: unlockScript.toString('hex')
+      }
+    })
+  }
+
+  static fromAssetInputs(inputs: AssetInput[]): Input[] {
+    return inputs.map((input) => {
+      const hint = input.outputRef.hint
+      const key = Buffer.from(input.outputRef.key, 'hex')
+      const unlockScript = unlockScriptCodec.decode(Buffer.from(input.unlockScript, 'hex'))
+      return {
+        outputRef: { hint, key },
+        unlockScript
+      }
+    })
+  }
+}
+
+export const inputCodec = new InputCodec()
+export const inputsCodec = new ArrayCodec(inputCodec)