@alephium/web3 0.30.0-beta.1 → 0.30.1

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

@@ -1,193 +0,0 @@
-/*
-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 { compactUnsignedIntCodec, compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
-import { Codec } from './codec'
-import { Script, scriptCodec } from './script-codec'
-import { ByteString, byteStringCodec } from './bytestring-codec'
-import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
-
-export interface P2PKH {
-  publicKey: Buffer
-}
-
-class P2PKHCodec implements Codec<P2PKH> {
-  parser = Parser.start().buffer('publicKey', { length: 33 })
-
-  encode(input: P2PKH): Buffer {
-    return input.publicKey
-  }
-
-  decode(input: Buffer): P2PKH {
-    return this.parser.parse(input)
-  }
-}
-const p2pkhCodec = new P2PKHCodec()
-
-export interface P2MPKH {
-  publicKeys: DecodedArray<{
-    publicKey: P2PKH
-    index: DecodedCompactInt
-  }>
-}
-
-class P2MPKHCodec implements Codec<P2MPKH> {
-  parser = Parser.start().nest('publicKeys', {
-    type: ArrayCodec.arrayParser(
-      Parser.start()
-        .nest('publicKey', { type: p2pkhCodec.parser })
-        .nest('index', { type: compactUnsignedIntCodec.parser })
-    )
-  })
-
-  encode(input: P2MPKH): Buffer {
-    return Buffer.concat([
-      Buffer.from(compactUnsignedIntCodec.encode(input.publicKeys.length)),
-      ...input.publicKeys.value.map((v) => {
-        return Buffer.concat([v.publicKey.publicKey, Buffer.from(compactUnsignedIntCodec.encode(v.index))])
-      })
-    ])
-  }
-
-  decode(input: Buffer): any {
-    return this.parser.parse(input)
-  }
-}
-const p2mpkhCodec = new P2MPKHCodec()
-
-export interface Val {
-  type: number
-  val: number | DecodedCompactInt | ByteString | LockupScript
-}
-class ValCodec implements Codec<Val> {
-  parser = Parser.start()
-    .int8('type')
-    .choice('val', {
-      tag: 'type',
-      choices: {
-        0x00: new Parser().uint8('value'), // Boolean
-        0x01: compactSignedIntCodec.parser, // I256
-        0x02: compactUnsignedIntCodec.parser, // U256
-        0x03: byteStringCodec.parser, // ByteVec
-        0x04: lockupScriptCodec.parser // Address
-      }
-    })
-
-  encode(input: Val): Buffer {
-    const valType = input.type
-
-    if (valType === 0x00) {
-      // Boolean
-      return Buffer.from([valType, input.val as number])
-    } else if (valType === 0x01) {
-      // I256
-      return Buffer.from([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
-    } else if (valType === 0x02) {
-      // U256
-      return Buffer.from([valType, ...compactUnsignedIntCodec.encode(input.val as DecodedCompactInt)])
-    } else if (valType === 0x03) {
-      // ByteVec
-      return Buffer.from([valType, ...byteStringCodec.encode(input.val as ByteString)])
-    } else if (valType === 0x04) {
-      // Address
-      return Buffer.from([valType, ...lockupScriptCodec.encode(input.val as LockupScript)])
-    } else {
-      throw new Error(`ValCodec: unsupported val type: ${valType}`)
-    }
-  }
-
-  decode(input: Buffer): Val {
-    return this.parser.parse(input)
-  }
-}
-
-const valCodec = new ValCodec()
-const valsCodec = new ArrayCodec(valCodec)
-
-export interface P2SH {
-  script: Script
-  params: DecodedArray<Val>
-}
-
-export class P2SHCodec implements Codec<P2SH> {
-  parser = Parser.start()
-    .nest('script', {
-      type: scriptCodec.parser
-    })
-    .nest('params', {
-      type: valsCodec.parser
-    })
-
-  encode(input: P2SH): Buffer {
-    return Buffer.concat([scriptCodec.encode(input.script), valsCodec.encode(input.params.value)])
-  }
-
-  decode(input: Buffer): P2SH {
-    return this.parser.parse(input)
-  }
-}
-
-const p2shCodec = new P2SHCodec()
-
-export interface UnlockScript {
-  scriptType: number
-  script: P2PKH | P2MPKH | P2SH
-}
-
-export class UnlockScriptCodec implements Codec<UnlockScript> {
-  parser = Parser.start()
-    .uint8('scriptType')
-    .choice('script', {
-      tag: 'scriptType',
-      choices: {
-        0: p2pkhCodec.parser,
-        1: p2mpkhCodec.parser,
-        2: p2shCodec.parser,
-        3: Parser.start() // TODO: SameAsPrevious, FIXME
-      }
-    })
-
-  encode(input: UnlockScript): Buffer {
-    const scriptType = input.scriptType
-    const inputUnLockScript = input.script
-    const inputUnLockScriptType = Buffer.from([scriptType])
-
-    if (scriptType === 0) {
-      // P2PKH
-      return Buffer.concat([inputUnLockScriptType, p2pkhCodec.encode(inputUnLockScript as P2PKH)])
-    } else if (scriptType === 1) {
-      // P2MPKH
-      return Buffer.concat([inputUnLockScriptType, p2mpkhCodec.encode(inputUnLockScript as P2MPKH)])
-    } else if (scriptType === 2) {
-      // P2SH
-      return Buffer.concat([inputUnLockScriptType, p2shCodec.encode(input.script as P2SH)])
-    } else if (scriptType === 3) {
-      // SameAsPrevious
-      return inputUnLockScriptType
-    } else {
-      throw new Error(`TODO: encode unlock script: ${scriptType}`)
-    }
-  }
-
-  decode(input: Buffer): UnlockScript {
-    return this.parser.parse(input)
-  }
-}
-
-export const unlockScriptCodec = new UnlockScriptCodec()

package/src/codec/unsigned-tx-codec.ts

@@ -1,123 +0,0 @@
-/*
-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 { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium'
-import { binToHex, hexToBinUnsafe } from '../utils'
-import { Script, scriptCodec, statefulScriptCodecOpt } from './script-codec'
-import { Option } from './option-codec'
-import { DecodedCompactInt, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
-import { Input, InputCodec, inputsCodec } from './input-codec'
-import { AssetOutput, AssetOutputCodec, assetOutputsCodec } from './asset-output-codec'
-import { DecodedArray } from './array-codec'
-import { blakeHash } from './hash'
-import { Codec } from './codec'
-
-export interface UnsignedTx {
-  version: number
-  networkId: number
-  statefulScript: Option<Script>
-  gasAmount: DecodedCompactInt
-  gasPrice: DecodedCompactInt
-  inputs: DecodedArray<Input>
-  fixedOutputs: DecodedArray<AssetOutput>
-}
-
-export class UnsignedTxCodec implements Codec<UnsignedTx> {
-  parser = new Parser()
-    .uint8('version')
-    .uint8('networkId')
-    .nest('statefulScript', {
-      type: statefulScriptCodecOpt.parser
-    })
-    .nest('gasAmount', {
-      type: compactSignedIntCodec.parser
-    })
-    .nest('gasPrice', {
-      type: compactUnsignedIntCodec.parser
-    })
-    .nest('inputs', {
-      type: inputsCodec.parser
-    })
-    .nest('fixedOutputs', {
-      type: assetOutputsCodec.parser
-    })
-
-  encode(decodedUnsignedTx: UnsignedTx): Buffer {
-    return Buffer.concat([
-      Buffer.from([decodedUnsignedTx.version, decodedUnsignedTx.networkId]),
-      statefulScriptCodecOpt.encode(decodedUnsignedTx.statefulScript),
-      compactSignedIntCodec.encode(decodedUnsignedTx.gasAmount),
-      compactUnsignedIntCodec.encode(decodedUnsignedTx.gasPrice),
-      inputsCodec.encode(decodedUnsignedTx.inputs.value),
-      assetOutputsCodec.encode(decodedUnsignedTx.fixedOutputs.value)
-    ])
-  }
-
-  decode(input: Buffer): UnsignedTx {
-    return this.parser.parse(input)
-  }
-
-  encodeApiUnsignedTx(input: ApiUnsignedTx): Buffer {
-    const decoded = UnsignedTxCodec.fromApiUnsignedTx(input)
-    return this.encode(decoded)
-  }
-
-  decodeApiUnsignedTx(input: Buffer): ApiUnsignedTx {
-    const decoded = this.parser.parse(input)
-    return UnsignedTxCodec.toApiUnsignedTx(decoded)
-  }
-
-  static txId(unsignedTx: UnsignedTx): string {
-    return binToHex(blakeHash(unsignedTxCodec.encode(unsignedTx)))
-  }
-
-  static toApiUnsignedTx(unsigned: UnsignedTx): ApiUnsignedTx {
-    const txId = UnsignedTxCodec.txId(unsigned)
-    const txIdBytes = hexToBinUnsafe(txId)
-    const version = unsigned.version
-    const networkId = unsigned.networkId
-    const gasAmount = compactSignedIntCodec.toI32(unsigned.gasAmount)
-    const gasPrice = compactUnsignedIntCodec.toU256(unsigned.gasPrice).toString()
-    const inputs = InputCodec.toAssetInputs(unsigned.inputs.value)
-    const fixedOutputs = AssetOutputCodec.toFixedAssetOutputs(txIdBytes, unsigned.fixedOutputs.value)
-    let scriptOpt: string | undefined = undefined
-    if (unsigned.statefulScript.option === 1) {
-      scriptOpt = scriptCodec.encode(unsigned.statefulScript.value!).toString('hex')
-    }
-
-    return { txId, version, networkId, gasAmount, scriptOpt, gasPrice, inputs, fixedOutputs }
-  }
-
-  static fromApiUnsignedTx(unsignedTx: ApiUnsignedTx): UnsignedTx {
-    const version = unsignedTx.version
-    const networkId = unsignedTx.networkId
-    const gasAmount = compactSignedIntCodec.decode(compactSignedIntCodec.encodeI32(unsignedTx.gasAmount))
-    const gasPrice = compactUnsignedIntCodec.decode(compactUnsignedIntCodec.encodeU256(BigInt(unsignedTx.gasPrice)))
-    const inputsValue = InputCodec.fromAssetInputs(unsignedTx.inputs)
-    const inputs = inputsCodec.fromArray(inputsValue)
-    const fixedOutputsValue = AssetOutputCodec.fromFixedAssetOutputs(unsignedTx.fixedOutputs)
-    const fixedOutputs = assetOutputsCodec.fromArray(fixedOutputsValue)
-    const statefulScript = statefulScriptCodecOpt.fromBuffer(
-      unsignedTx.scriptOpt ? Buffer.from(unsignedTx.scriptOpt, 'hex') : undefined
-    )
-
-    return { version, networkId, gasAmount, gasPrice, inputs, fixedOutputs, statefulScript }
-  }
-}
-
-export const unsignedTxCodec = new UnsignedTxCodec()