@ckb-ccc/core 0.0.10-alpha.4 → 0.0.10-alpha.5

package/dist.commonjs/ckb/molecule.advanced/generated.js

@@ -1,1740 +1,1536 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SerializeTransaction =
-  exports.Transaction =
-  exports.SerializeRawTransaction =
-  exports.RawTransaction =
-  exports.SerializeCellDep =
-  exports.CellDep =
-  exports.SerializeCellOutput =
-  exports.CellOutput =
-  exports.SerializeCellInput =
-  exports.CellInput =
-  exports.SerializeOutPoint =
-  exports.OutPoint =
-  exports.SerializeScript =
-  exports.Script =
-  exports.SerializeCellOutputVec =
-  exports.CellOutputVec =
-  exports.SerializeCellInputVec =
-  exports.CellInputVec =
-  exports.SerializeCellDepVec =
-  exports.CellDepVec =
-  exports.SerializeProposalShortIdVec =
-  exports.ProposalShortIdVec =
-  exports.SerializeTransactionVec =
-  exports.TransactionVec =
-  exports.SerializeUncleBlockVec =
-  exports.UncleBlockVec =
-  exports.SerializeProposalShortId =
-  exports.ProposalShortId =
-  exports.SerializeScriptOpt =
-  exports.ScriptOpt =
-  exports.SerializeByte32Vec =
-  exports.Byte32Vec =
-  exports.SerializeBytesVec =
-  exports.BytesVec =
-  exports.SerializeBytesOptVec =
-  exports.BytesOptVec =
-  exports.SerializeBytesOpt =
-  exports.BytesOpt =
-  exports.SerializeBytes =
-  exports.Bytes =
-  exports.SerializeUint256 =
-  exports.Uint256 =
-  exports.SerializeByte32 =
-  exports.Byte32 =
-  exports.SerializeUint128 =
-  exports.Uint128 =
-  exports.SerializeUint64 =
-  exports.Uint64 =
-  exports.SerializeUint32 =
-  exports.Uint32 =
-    void 0;
-exports.SerializeWitnessArgs =
-  exports.WitnessArgs =
-  exports.SerializeCellbaseWitness =
-  exports.CellbaseWitness =
-  exports.SerializeBlockV1 =
-  exports.BlockV1 =
-  exports.SerializeBlock =
-  exports.Block =
-  exports.SerializeUncleBlock =
-  exports.UncleBlock =
-  exports.SerializeHeader =
-  exports.Header =
-  exports.SerializeRawHeader =
-  exports.RawHeader =
-    void 0;
+exports.SerializeTransaction = exports.Transaction = exports.SerializeRawTransaction = exports.RawTransaction = exports.SerializeCellDep = exports.CellDep = exports.SerializeCellOutput = exports.CellOutput = exports.SerializeCellInput = exports.CellInput = exports.SerializeOutPoint = exports.OutPoint = exports.SerializeScript = exports.Script = exports.SerializeCellOutputVec = exports.CellOutputVec = exports.SerializeCellInputVec = exports.CellInputVec = exports.SerializeCellDepVec = exports.CellDepVec = exports.SerializeProposalShortIdVec = exports.ProposalShortIdVec = exports.SerializeTransactionVec = exports.TransactionVec = exports.SerializeUncleBlockVec = exports.UncleBlockVec = exports.SerializeProposalShortId = exports.ProposalShortId = exports.SerializeScriptOpt = exports.ScriptOpt = exports.SerializeByte32Vec = exports.Byte32Vec = exports.SerializeBytesVec = exports.BytesVec = exports.SerializeBytesOptVec = exports.BytesOptVec = exports.SerializeBytesOpt = exports.BytesOpt = exports.SerializeBytes = exports.Bytes = exports.SerializeUint256 = exports.Uint256 = exports.SerializeByte32 = exports.Byte32 = exports.SerializeUint128 = exports.Uint128 = exports.SerializeUint64 = exports.Uint64 = exports.SerializeUint32 = exports.Uint32 = void 0;
+exports.SerializeWitnessArgs = exports.WitnessArgs = exports.SerializeCellbaseWitness = exports.CellbaseWitness = exports.SerializeBlockV1 = exports.BlockV1 = exports.SerializeBlock = exports.Block = exports.SerializeUncleBlock = exports.UncleBlock = exports.SerializeHeader = exports.Header = exports.SerializeRawHeader = exports.RawHeader = void 0;
 function dataLengthError(actual, required) {
-  throw new Error(
-    `Invalid data length! Required: ${required}, actual: ${actual}`,
-  );
+    throw new Error(`Invalid data length! Required: ${required}, actual: ${actual}`);
 }
 function assertDataLength(actual, required) {
-  if (actual !== required) {
-    dataLengthError(actual, required);
-  }
+    if (actual !== required) {
+        dataLengthError(actual, required);
+    }
 }
 function assertArrayBuffer(reader) {
-  if (reader instanceof Object && reader.toArrayBuffer instanceof Function) {
-    reader = reader.toArrayBuffer();
-  }
-  if (reader instanceof Uint8Array) {
-    return reader.buffer.slice(
-      reader.byteOffset,
-      reader.byteLength + reader.byteOffset,
-    );
-  }
-  if (!(reader instanceof ArrayBuffer)) {
-    throw new Error(
-      "Provided value must be an ArrayBuffer or can be transformed into ArrayBuffer!",
-    );
-  }
-  return reader;
+    if (reader instanceof Object && reader.toArrayBuffer instanceof Function) {
+        reader = reader.toArrayBuffer();
+    }
+    if (reader instanceof Uint8Array) {
+        return reader.buffer.slice(reader.byteOffset, reader.byteLength + reader.byteOffset);
+    }
+    if (!(reader instanceof ArrayBuffer)) {
+        throw new Error("Provided value must be an ArrayBuffer or can be transformed into ArrayBuffer!");
+    }
+    return reader;
 }
 function verifyAndExtractOffsets(view, expectedFieldCount, compatible) {
-  if (view.byteLength < 4) {
-    dataLengthError(view.byteLength, ">4");
-  }
-  const requiredByteLength = view.getUint32(0, true);
-  assertDataLength(view.byteLength, requiredByteLength);
-  if (requiredByteLength === 4) {
-    return [requiredByteLength];
-  }
-  if (requiredByteLength < 8) {
-    dataLengthError(view.byteLength, ">8");
-  }
-  const firstOffset = view.getUint32(4, true);
-  if (firstOffset % 4 !== 0 || firstOffset < 8) {
-    throw new Error(`Invalid first offset: ${firstOffset}`);
-  }
-  const itemCount = firstOffset / 4 - 1;
-  if (itemCount < expectedFieldCount) {
-    throw new Error(
-      `Item count not enough! Required: ${expectedFieldCount}, actual: ${itemCount}`,
-    );
-  } else if (!compatible && itemCount > expectedFieldCount) {
-    throw new Error(
-      `Item count is more than required! Required: ${expectedFieldCount}, actual: ${itemCount}`,
-    );
-  }
-  if (requiredByteLength < firstOffset) {
-    throw new Error(`First offset is larger than byte length: ${firstOffset}`);
-  }
-  const offsets = [];
-  for (let i = 0; i < itemCount; i++) {
-    const start = 4 + i * 4;
-    offsets.push(view.getUint32(start, true));
-  }
-  offsets.push(requiredByteLength);
-  for (let i = 0; i < offsets.length - 1; i++) {
-    if (offsets[i] > offsets[i + 1]) {
-      throw new Error(
-        `Offset index ${i}: ${offsets[i]} is larger than offset index ${i + 1}: ${offsets[i + 1]}`,
-      );
-    }
-  }
-  return offsets;
+    if (view.byteLength < 4) {
+        dataLengthError(view.byteLength, ">4");
+    }
+    const requiredByteLength = view.getUint32(0, true);
+    assertDataLength(view.byteLength, requiredByteLength);
+    if (requiredByteLength === 4) {
+        return [requiredByteLength];
+    }
+    if (requiredByteLength < 8) {
+        dataLengthError(view.byteLength, ">8");
+    }
+    const firstOffset = view.getUint32(4, true);
+    if (firstOffset % 4 !== 0 || firstOffset < 8) {
+        throw new Error(`Invalid first offset: ${firstOffset}`);
+    }
+    const itemCount = firstOffset / 4 - 1;
+    if (itemCount < expectedFieldCount) {
+        throw new Error(`Item count not enough! Required: ${expectedFieldCount}, actual: ${itemCount}`);
+    }
+    else if (!compatible && itemCount > expectedFieldCount) {
+        throw new Error(`Item count is more than required! Required: ${expectedFieldCount}, actual: ${itemCount}`);
+    }
+    if (requiredByteLength < firstOffset) {
+        throw new Error(`First offset is larger than byte length: ${firstOffset}`);
+    }
+    const offsets = [];
+    for (let i = 0; i < itemCount; i++) {
+        const start = 4 + i * 4;
+        offsets.push(view.getUint32(start, true));
+    }
+    offsets.push(requiredByteLength);
+    for (let i = 0; i < offsets.length - 1; i++) {
+        if (offsets[i] > offsets[i + 1]) {
+            throw new Error(`Offset index ${i}: ${offsets[i]} is larger than offset index ${i + 1}: ${offsets[i + 1]}`);
+        }
+    }
+    return offsets;
 }
 function serializeTable(buffers) {
-  const itemCount = buffers.length;
-  let totalSize = 4 * (itemCount + 1);
-  const offsets = [];
-  for (let i = 0; i < itemCount; i++) {
-    offsets.push(totalSize);
-    totalSize += buffers[i].byteLength;
-  }
-  const buffer = new ArrayBuffer(totalSize);
-  const array = new Uint8Array(buffer);
-  const view = new DataView(buffer);
-  view.setUint32(0, totalSize, true);
-  for (let i = 0; i < itemCount; i++) {
-    view.setUint32(4 + i * 4, offsets[i], true);
-    array.set(new Uint8Array(buffers[i]), offsets[i]);
-  }
-  return buffer;
+    const itemCount = buffers.length;
+    let totalSize = 4 * (itemCount + 1);
+    const offsets = [];
+    for (let i = 0; i < itemCount; i++) {
+        offsets.push(totalSize);
+        totalSize += buffers[i].byteLength;
+    }
+    const buffer = new ArrayBuffer(totalSize);
+    const array = new Uint8Array(buffer);
+    const view = new DataView(buffer);
+    view.setUint32(0, totalSize, true);
+    for (let i = 0; i < itemCount; i++) {
+        view.setUint32(4 + i * 4, offsets[i], true);
+        array.set(new Uint8Array(buffers[i]), offsets[i]);
+    }
+    return buffer;
 }
 class Uint32 {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, 4);
-  }
-  indexAt(i) {
-    return this.view.getUint8(i);
-  }
-  raw() {
-    return this.view.buffer;
-  }
-  toBigEndianUint32() {
-    return this.view.getUint32(0, false);
-  }
-  toLittleEndianUint32() {
-    return this.view.getUint32(0, true);
-  }
-  static size() {
-    return 4;
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, 4);
+    }
+    indexAt(i) {
+        return this.view.getUint8(i);
+    }
+    raw() {
+        return this.view.buffer;
+    }
+    toBigEndianUint32() {
+        return this.view.getUint32(0, false);
+    }
+    toLittleEndianUint32() {
+        return this.view.getUint32(0, true);
+    }
+    static size() {
+        return 4;
+    }
 }
 exports.Uint32 = Uint32;
 function SerializeUint32(value) {
-  const buffer = assertArrayBuffer(value);
-  assertDataLength(buffer.byteLength, 4);
-  return buffer;
+    const buffer = assertArrayBuffer(value);
+    assertDataLength(buffer.byteLength, 4);
+    return buffer;
 }
 exports.SerializeUint32 = SerializeUint32;
 class Uint64 {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, 8);
-  }
-  indexAt(i) {
-    return this.view.getUint8(i);
-  }
-  raw() {
-    return this.view.buffer;
-  }
-  static size() {
-    return 8;
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, 8);
+    }
+    indexAt(i) {
+        return this.view.getUint8(i);
+    }
+    raw() {
+        return this.view.buffer;
+    }
+    static size() {
+        return 8;
+    }
 }
 exports.Uint64 = Uint64;
 function SerializeUint64(value) {
-  const buffer = assertArrayBuffer(value);
-  assertDataLength(buffer.byteLength, 8);
-  return buffer;
+    const buffer = assertArrayBuffer(value);
+    assertDataLength(buffer.byteLength, 8);
+    return buffer;
 }
 exports.SerializeUint64 = SerializeUint64;
 class Uint128 {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, 16);
-  }
-  indexAt(i) {
-    return this.view.getUint8(i);
-  }
-  raw() {
-    return this.view.buffer;
-  }
-  static size() {
-    return 16;
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, 16);
+    }
+    indexAt(i) {
+        return this.view.getUint8(i);
+    }
+    raw() {
+        return this.view.buffer;
+    }
+    static size() {
+        return 16;
+    }
 }
 exports.Uint128 = Uint128;
 function SerializeUint128(value) {
-  const buffer = assertArrayBuffer(value);
-  assertDataLength(buffer.byteLength, 16);
-  return buffer;
+    const buffer = assertArrayBuffer(value);
+    assertDataLength(buffer.byteLength, 16);
+    return buffer;
 }
 exports.SerializeUint128 = SerializeUint128;
 class Byte32 {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, 32);
-  }
-  indexAt(i) {
-    return this.view.getUint8(i);
-  }
-  raw() {
-    return this.view.buffer;
-  }
-  static size() {
-    return 32;
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, 32);
+    }
+    indexAt(i) {
+        return this.view.getUint8(i);
+    }
+    raw() {
+        return this.view.buffer;
+    }
+    static size() {
+        return 32;
+    }
 }
 exports.Byte32 = Byte32;
 function SerializeByte32(value) {
-  const buffer = assertArrayBuffer(value);
-  assertDataLength(buffer.byteLength, 32);
-  return buffer;
+    const buffer = assertArrayBuffer(value);
+    assertDataLength(buffer.byteLength, 32);
+    return buffer;
 }
 exports.SerializeByte32 = SerializeByte32;
 class Uint256 {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, 32);
-  }
-  indexAt(i) {
-    return this.view.getUint8(i);
-  }
-  raw() {
-    return this.view.buffer;
-  }
-  static size() {
-    return 32;
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, 32);
+    }
+    indexAt(i) {
+        return this.view.getUint8(i);
+    }
+    raw() {
+        return this.view.buffer;
+    }
+    static size() {
+        return 32;
+    }
 }
 exports.Uint256 = Uint256;
 function SerializeUint256(value) {
-  const buffer = assertArrayBuffer(value);
-  assertDataLength(buffer.byteLength, 32);
-  return buffer;
+    const buffer = assertArrayBuffer(value);
+    assertDataLength(buffer.byteLength, 32);
+    return buffer;
 }
 exports.SerializeUint256 = SerializeUint256;
 class Bytes {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    if (this.view.byteLength < 4) {
-      dataLengthError(this.view.byteLength, ">4");
-    }
-    const requiredByteLength = this.length() + 4;
-    assertDataLength(this.view.byteLength, requiredByteLength);
-  }
-  raw() {
-    return this.view.buffer.slice(4);
-  }
-  indexAt(i) {
-    return this.view.getUint8(4 + i);
-  }
-  length() {
-    return this.view.getUint32(0, true);
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        if (this.view.byteLength < 4) {
+            dataLengthError(this.view.byteLength, ">4");
+        }
+        const requiredByteLength = this.length() + 4;
+        assertDataLength(this.view.byteLength, requiredByteLength);
+    }
+    raw() {
+        return this.view.buffer.slice(4);
+    }
+    indexAt(i) {
+        return this.view.getUint8(4 + i);
+    }
+    length() {
+        return this.view.getUint32(0, true);
+    }
 }
 exports.Bytes = Bytes;
 function SerializeBytes(value) {
-  const item = assertArrayBuffer(value);
-  const array = new Uint8Array(4 + item.byteLength);
-  new DataView(array.buffer).setUint32(0, item.byteLength, true);
-  array.set(new Uint8Array(item), 4);
-  return array.buffer;
+    const item = assertArrayBuffer(value);
+    const array = new Uint8Array(4 + item.byteLength);
+    new DataView(array.buffer).setUint32(0, item.byteLength, true);
+    array.set(new Uint8Array(item), 4);
+    return array.buffer;
 }
 exports.SerializeBytes = SerializeBytes;
 class BytesOpt {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    if (this.hasValue()) {
-      this.value().validate(compatible);
-    }
-  }
-  value() {
-    return new Bytes(this.view.buffer, { validate: false });
-  }
-  hasValue() {
-    return this.view.byteLength > 0;
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        if (this.hasValue()) {
+            this.value().validate(compatible);
+        }
+    }
+    value() {
+        return new Bytes(this.view.buffer, { validate: false });
+    }
+    hasValue() {
+        return this.view.byteLength > 0;
+    }
 }
 exports.BytesOpt = BytesOpt;
 function SerializeBytesOpt(value) {
-  if (value) {
-    return SerializeBytes(value);
-  } else {
-    return new ArrayBuffer(0);
-  }
+    if (value) {
+        return SerializeBytes(value);
+    }
+    else {
+        return new ArrayBuffer(0);
+    }
 }
 exports.SerializeBytesOpt = SerializeBytesOpt;
 class BytesOptVec {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    for (let i = 0; i < offsets.length - 1; i++) {
-      new BytesOpt(this.view.buffer.slice(offsets[i], offsets[i + 1]), {
-        validate: false,
-      }).validate();
-    }
-  }
-  length() {
-    if (this.view.byteLength < 8) {
-      return 0;
-    } else {
-      return this.view.getUint32(4, true) / 4 - 1;
-    }
-  }
-  indexAt(i) {
-    const start = 4 + i * 4;
-    const offset = this.view.getUint32(start, true);
-    let offset_end = this.view.byteLength;
-    if (i + 1 < this.length()) {
-      offset_end = this.view.getUint32(start + 4, true);
-    }
-    return new BytesOpt(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        for (let i = 0; i < offsets.length - 1; i++) {
+            new BytesOpt(this.view.buffer.slice(offsets[i], offsets[i + 1]), {
+                validate: false,
+            }).validate();
+        }
+    }
+    length() {
+        if (this.view.byteLength < 8) {
+            return 0;
+        }
+        else {
+            return this.view.getUint32(4, true) / 4 - 1;
+        }
+    }
+    indexAt(i) {
+        const start = 4 + i * 4;
+        const offset = this.view.getUint32(start, true);
+        let offset_end = this.view.byteLength;
+        if (i + 1 < this.length()) {
+            offset_end = this.view.getUint32(start + 4, true);
+        }
+        return new BytesOpt(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.BytesOptVec = BytesOptVec;
 function SerializeBytesOptVec(value) {
-  return serializeTable(value.map((item) => SerializeBytesOpt(item)));
+    return serializeTable(value.map((item) => SerializeBytesOpt(item)));
 }
 exports.SerializeBytesOptVec = SerializeBytesOptVec;
 class BytesVec {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    for (let i = 0; i < offsets.length - 1; i++) {
-      new Bytes(this.view.buffer.slice(offsets[i], offsets[i + 1]), {
-        validate: false,
-      }).validate();
-    }
-  }
-  length() {
-    if (this.view.byteLength < 8) {
-      return 0;
-    } else {
-      return this.view.getUint32(4, true) / 4 - 1;
-    }
-  }
-  indexAt(i) {
-    const start = 4 + i * 4;
-    const offset = this.view.getUint32(start, true);
-    let offset_end = this.view.byteLength;
-    if (i + 1 < this.length()) {
-      offset_end = this.view.getUint32(start + 4, true);
-    }
-    return new Bytes(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        for (let i = 0; i < offsets.length - 1; i++) {
+            new Bytes(this.view.buffer.slice(offsets[i], offsets[i + 1]), {
+                validate: false,
+            }).validate();
+        }
+    }
+    length() {
+        if (this.view.byteLength < 8) {
+            return 0;
+        }
+        else {
+            return this.view.getUint32(4, true) / 4 - 1;
+        }
+    }
+    indexAt(i) {
+        const start = 4 + i * 4;
+        const offset = this.view.getUint32(start, true);
+        let offset_end = this.view.byteLength;
+        if (i + 1 < this.length()) {
+            offset_end = this.view.getUint32(start + 4, true);
+        }
+        return new Bytes(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.BytesVec = BytesVec;
 function SerializeBytesVec(value) {
-  return serializeTable(value.map((item) => SerializeBytes(item)));
+    return serializeTable(value.map((item) => SerializeBytes(item)));
 }
 exports.SerializeBytesVec = SerializeBytesVec;
 class Byte32Vec {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    if (this.view.byteLength < 4) {
-      dataLengthError(this.view.byteLength, ">4");
-    }
-    const requiredByteLength = this.length() * Byte32.size() + 4;
-    assertDataLength(this.view.byteLength, requiredByteLength);
-    for (let i = 0; i < 0; i++) {
-      const item = this.indexAt(i);
-      item.validate(compatible);
-    }
-  }
-  indexAt(i) {
-    return new Byte32(
-      this.view.buffer.slice(
-        4 + i * Byte32.size(),
-        4 + (i + 1) * Byte32.size(),
-      ),
-      { validate: false },
-    );
-  }
-  length() {
-    return this.view.getUint32(0, true);
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        if (this.view.byteLength < 4) {
+            dataLengthError(this.view.byteLength, ">4");
+        }
+        const requiredByteLength = this.length() * Byte32.size() + 4;
+        assertDataLength(this.view.byteLength, requiredByteLength);
+        for (let i = 0; i < 0; i++) {
+            const item = this.indexAt(i);
+            item.validate(compatible);
+        }
+    }
+    indexAt(i) {
+        return new Byte32(this.view.buffer.slice(4 + i * Byte32.size(), 4 + (i + 1) * Byte32.size()), { validate: false });
+    }
+    length() {
+        return this.view.getUint32(0, true);
+    }
 }
 exports.Byte32Vec = Byte32Vec;
 function SerializeByte32Vec(value) {
-  const array = new Uint8Array(4 + Byte32.size() * value.length);
-  new DataView(array.buffer).setUint32(0, value.length, true);
-  for (let i = 0; i < value.length; i++) {
-    const itemBuffer = SerializeByte32(value[i]);
-    array.set(new Uint8Array(itemBuffer), 4 + i * Byte32.size());
-  }
-  return array.buffer;
+    const array = new Uint8Array(4 + Byte32.size() * value.length);
+    new DataView(array.buffer).setUint32(0, value.length, true);
+    for (let i = 0; i < value.length; i++) {
+        const itemBuffer = SerializeByte32(value[i]);
+        array.set(new Uint8Array(itemBuffer), 4 + i * Byte32.size());
+    }
+    return array.buffer;
 }
 exports.SerializeByte32Vec = SerializeByte32Vec;
 class ScriptOpt {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    if (this.hasValue()) {
-      this.value().validate(compatible);
-    }
-  }
-  value() {
-    return new Script(this.view.buffer, { validate: false });
-  }
-  hasValue() {
-    return this.view.byteLength > 0;
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        if (this.hasValue()) {
+            this.value().validate(compatible);
+        }
+    }
+    value() {
+        return new Script(this.view.buffer, { validate: false });
+    }
+    hasValue() {
+        return this.view.byteLength > 0;
+    }
 }
 exports.ScriptOpt = ScriptOpt;
 function SerializeScriptOpt(value) {
-  if (value) {
-    return SerializeScript(value);
-  } else {
-    return new ArrayBuffer(0);
-  }
+    if (value) {
+        return SerializeScript(value);
+    }
+    else {
+        return new ArrayBuffer(0);
+    }
 }
 exports.SerializeScriptOpt = SerializeScriptOpt;
 class ProposalShortId {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, 10);
-  }
-  indexAt(i) {
-    return this.view.getUint8(i);
-  }
-  raw() {
-    return this.view.buffer;
-  }
-  static size() {
-    return 10;
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, 10);
+    }
+    indexAt(i) {
+        return this.view.getUint8(i);
+    }
+    raw() {
+        return this.view.buffer;
+    }
+    static size() {
+        return 10;
+    }
 }
 exports.ProposalShortId = ProposalShortId;
 function SerializeProposalShortId(value) {
-  const buffer = assertArrayBuffer(value);
-  assertDataLength(buffer.byteLength, 10);
-  return buffer;
+    const buffer = assertArrayBuffer(value);
+    assertDataLength(buffer.byteLength, 10);
+    return buffer;
 }
 exports.SerializeProposalShortId = SerializeProposalShortId;
 class UncleBlockVec {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    for (let i = 0; i < offsets.length - 1; i++) {
-      new UncleBlock(this.view.buffer.slice(offsets[i], offsets[i + 1]), {
-        validate: false,
-      }).validate();
-    }
-  }
-  length() {
-    if (this.view.byteLength < 8) {
-      return 0;
-    } else {
-      return this.view.getUint32(4, true) / 4 - 1;
-    }
-  }
-  indexAt(i) {
-    const start = 4 + i * 4;
-    const offset = this.view.getUint32(start, true);
-    let offset_end = this.view.byteLength;
-    if (i + 1 < this.length()) {
-      offset_end = this.view.getUint32(start + 4, true);
-    }
-    return new UncleBlock(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        for (let i = 0; i < offsets.length - 1; i++) {
+            new UncleBlock(this.view.buffer.slice(offsets[i], offsets[i + 1]), {
+                validate: false,
+            }).validate();
+        }
+    }
+    length() {
+        if (this.view.byteLength < 8) {
+            return 0;
+        }
+        else {
+            return this.view.getUint32(4, true) / 4 - 1;
+        }
+    }
+    indexAt(i) {
+        const start = 4 + i * 4;
+        const offset = this.view.getUint32(start, true);
+        let offset_end = this.view.byteLength;
+        if (i + 1 < this.length()) {
+            offset_end = this.view.getUint32(start + 4, true);
+        }
+        return new UncleBlock(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.UncleBlockVec = UncleBlockVec;
 function SerializeUncleBlockVec(value) {
-  return serializeTable(value.map((item) => SerializeUncleBlock(item)));
+    return serializeTable(value.map((item) => SerializeUncleBlock(item)));
 }
 exports.SerializeUncleBlockVec = SerializeUncleBlockVec;
 class TransactionVec {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    for (let i = 0; i < offsets.length - 1; i++) {
-      new Transaction(this.view.buffer.slice(offsets[i], offsets[i + 1]), {
-        validate: false,
-      }).validate();
-    }
-  }
-  length() {
-    if (this.view.byteLength < 8) {
-      return 0;
-    } else {
-      return this.view.getUint32(4, true) / 4 - 1;
-    }
-  }
-  indexAt(i) {
-    const start = 4 + i * 4;
-    const offset = this.view.getUint32(start, true);
-    let offset_end = this.view.byteLength;
-    if (i + 1 < this.length()) {
-      offset_end = this.view.getUint32(start + 4, true);
-    }
-    return new Transaction(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        for (let i = 0; i < offsets.length - 1; i++) {
+            new Transaction(this.view.buffer.slice(offsets[i], offsets[i + 1]), {
+                validate: false,
+            }).validate();
+        }
+    }
+    length() {
+        if (this.view.byteLength < 8) {
+            return 0;
+        }
+        else {
+            return this.view.getUint32(4, true) / 4 - 1;
+        }
+    }
+    indexAt(i) {
+        const start = 4 + i * 4;
+        const offset = this.view.getUint32(start, true);
+        let offset_end = this.view.byteLength;
+        if (i + 1 < this.length()) {
+            offset_end = this.view.getUint32(start + 4, true);
+        }
+        return new Transaction(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.TransactionVec = TransactionVec;
 function SerializeTransactionVec(value) {
-  return serializeTable(value.map((item) => SerializeTransaction(item)));
+    return serializeTable(value.map((item) => SerializeTransaction(item)));
 }
 exports.SerializeTransactionVec = SerializeTransactionVec;
 class ProposalShortIdVec {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    if (this.view.byteLength < 4) {
-      dataLengthError(this.view.byteLength, ">4");
-    }
-    const requiredByteLength = this.length() * ProposalShortId.size() + 4;
-    assertDataLength(this.view.byteLength, requiredByteLength);
-    for (let i = 0; i < 0; i++) {
-      const item = this.indexAt(i);
-      item.validate(compatible);
-    }
-  }
-  indexAt(i) {
-    return new ProposalShortId(
-      this.view.buffer.slice(
-        4 + i * ProposalShortId.size(),
-        4 + (i + 1) * ProposalShortId.size(),
-      ),
-      { validate: false },
-    );
-  }
-  length() {
-    return this.view.getUint32(0, true);
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        if (this.view.byteLength < 4) {
+            dataLengthError(this.view.byteLength, ">4");
+        }
+        const requiredByteLength = this.length() * ProposalShortId.size() + 4;
+        assertDataLength(this.view.byteLength, requiredByteLength);
+        for (let i = 0; i < 0; i++) {
+            const item = this.indexAt(i);
+            item.validate(compatible);
+        }
+    }
+    indexAt(i) {
+        return new ProposalShortId(this.view.buffer.slice(4 + i * ProposalShortId.size(), 4 + (i + 1) * ProposalShortId.size()), { validate: false });
+    }
+    length() {
+        return this.view.getUint32(0, true);
+    }
 }
 exports.ProposalShortIdVec = ProposalShortIdVec;
 function SerializeProposalShortIdVec(value) {
-  const array = new Uint8Array(4 + ProposalShortId.size() * value.length);
-  new DataView(array.buffer).setUint32(0, value.length, true);
-  for (let i = 0; i < value.length; i++) {
-    const itemBuffer = SerializeProposalShortId(value[i]);
-    array.set(new Uint8Array(itemBuffer), 4 + i * ProposalShortId.size());
-  }
-  return array.buffer;
+    const array = new Uint8Array(4 + ProposalShortId.size() * value.length);
+    new DataView(array.buffer).setUint32(0, value.length, true);
+    for (let i = 0; i < value.length; i++) {
+        const itemBuffer = SerializeProposalShortId(value[i]);
+        array.set(new Uint8Array(itemBuffer), 4 + i * ProposalShortId.size());
+    }
+    return array.buffer;
 }
 exports.SerializeProposalShortIdVec = SerializeProposalShortIdVec;
 class CellDepVec {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    if (this.view.byteLength < 4) {
-      dataLengthError(this.view.byteLength, ">4");
-    }
-    const requiredByteLength = this.length() * CellDep.size() + 4;
-    assertDataLength(this.view.byteLength, requiredByteLength);
-    for (let i = 0; i < 0; i++) {
-      const item = this.indexAt(i);
-      item.validate(compatible);
-    }
-  }
-  indexAt(i) {
-    return new CellDep(
-      this.view.buffer.slice(
-        4 + i * CellDep.size(),
-        4 + (i + 1) * CellDep.size(),
-      ),
-      { validate: false },
-    );
-  }
-  length() {
-    return this.view.getUint32(0, true);
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        if (this.view.byteLength < 4) {
+            dataLengthError(this.view.byteLength, ">4");
+        }
+        const requiredByteLength = this.length() * CellDep.size() + 4;
+        assertDataLength(this.view.byteLength, requiredByteLength);
+        for (let i = 0; i < 0; i++) {
+            const item = this.indexAt(i);
+            item.validate(compatible);
+        }
+    }
+    indexAt(i) {
+        return new CellDep(this.view.buffer.slice(4 + i * CellDep.size(), 4 + (i + 1) * CellDep.size()), { validate: false });
+    }
+    length() {
+        return this.view.getUint32(0, true);
+    }
 }
 exports.CellDepVec = CellDepVec;
 function SerializeCellDepVec(value) {
-  const array = new Uint8Array(4 + CellDep.size() * value.length);
-  new DataView(array.buffer).setUint32(0, value.length, true);
-  for (let i = 0; i < value.length; i++) {
-    const itemBuffer = SerializeCellDep(value[i]);
-    array.set(new Uint8Array(itemBuffer), 4 + i * CellDep.size());
-  }
-  return array.buffer;
+    const array = new Uint8Array(4 + CellDep.size() * value.length);
+    new DataView(array.buffer).setUint32(0, value.length, true);
+    for (let i = 0; i < value.length; i++) {
+        const itemBuffer = SerializeCellDep(value[i]);
+        array.set(new Uint8Array(itemBuffer), 4 + i * CellDep.size());
+    }
+    return array.buffer;
 }
 exports.SerializeCellDepVec = SerializeCellDepVec;
 class CellInputVec {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    if (this.view.byteLength < 4) {
-      dataLengthError(this.view.byteLength, ">4");
-    }
-    const requiredByteLength = this.length() * CellInput.size() + 4;
-    assertDataLength(this.view.byteLength, requiredByteLength);
-    for (let i = 0; i < 0; i++) {
-      const item = this.indexAt(i);
-      item.validate(compatible);
-    }
-  }
-  indexAt(i) {
-    return new CellInput(
-      this.view.buffer.slice(
-        4 + i * CellInput.size(),
-        4 + (i + 1) * CellInput.size(),
-      ),
-      { validate: false },
-    );
-  }
-  length() {
-    return this.view.getUint32(0, true);
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        if (this.view.byteLength < 4) {
+            dataLengthError(this.view.byteLength, ">4");
+        }
+        const requiredByteLength = this.length() * CellInput.size() + 4;
+        assertDataLength(this.view.byteLength, requiredByteLength);
+        for (let i = 0; i < 0; i++) {
+            const item = this.indexAt(i);
+            item.validate(compatible);
+        }
+    }
+    indexAt(i) {
+        return new CellInput(this.view.buffer.slice(4 + i * CellInput.size(), 4 + (i + 1) * CellInput.size()), { validate: false });
+    }
+    length() {
+        return this.view.getUint32(0, true);
+    }
 }
 exports.CellInputVec = CellInputVec;
 function SerializeCellInputVec(value) {
-  const array = new Uint8Array(4 + CellInput.size() * value.length);
-  new DataView(array.buffer).setUint32(0, value.length, true);
-  for (let i = 0; i < value.length; i++) {
-    const itemBuffer = SerializeCellInput(value[i]);
-    array.set(new Uint8Array(itemBuffer), 4 + i * CellInput.size());
-  }
-  return array.buffer;
+    const array = new Uint8Array(4 + CellInput.size() * value.length);
+    new DataView(array.buffer).setUint32(0, value.length, true);
+    for (let i = 0; i < value.length; i++) {
+        const itemBuffer = SerializeCellInput(value[i]);
+        array.set(new Uint8Array(itemBuffer), 4 + i * CellInput.size());
+    }
+    return array.buffer;
 }
 exports.SerializeCellInputVec = SerializeCellInputVec;
 class CellOutputVec {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    for (let i = 0; i < offsets.length - 1; i++) {
-      new CellOutput(this.view.buffer.slice(offsets[i], offsets[i + 1]), {
-        validate: false,
-      }).validate();
-    }
-  }
-  length() {
-    if (this.view.byteLength < 8) {
-      return 0;
-    } else {
-      return this.view.getUint32(4, true) / 4 - 1;
-    }
-  }
-  indexAt(i) {
-    const start = 4 + i * 4;
-    const offset = this.view.getUint32(start, true);
-    let offset_end = this.view.byteLength;
-    if (i + 1 < this.length()) {
-      offset_end = this.view.getUint32(start + 4, true);
-    }
-    return new CellOutput(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        for (let i = 0; i < offsets.length - 1; i++) {
+            new CellOutput(this.view.buffer.slice(offsets[i], offsets[i + 1]), {
+                validate: false,
+            }).validate();
+        }
+    }
+    length() {
+        if (this.view.byteLength < 8) {
+            return 0;
+        }
+        else {
+            return this.view.getUint32(4, true) / 4 - 1;
+        }
+    }
+    indexAt(i) {
+        const start = 4 + i * 4;
+        const offset = this.view.getUint32(start, true);
+        let offset_end = this.view.byteLength;
+        if (i + 1 < this.length()) {
+            offset_end = this.view.getUint32(start + 4, true);
+        }
+        return new CellOutput(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.CellOutputVec = CellOutputVec;
 function SerializeCellOutputVec(value) {
-  return serializeTable(value.map((item) => SerializeCellOutput(item)));
+    return serializeTable(value.map((item) => SerializeCellOutput(item)));
 }
 exports.SerializeCellOutputVec = SerializeCellOutputVec;
 class Script {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    new Byte32(this.view.buffer.slice(offsets[0], offsets[1]), {
-      validate: false,
-    }).validate();
-    if (offsets[2] - offsets[1] !== 1) {
-      throw new Error(
-        `Invalid offset for hashType: ${offsets[1]} - ${offsets[2]}`,
-      );
-    }
-    new Bytes(this.view.buffer.slice(offsets[2], offsets[3]), {
-      validate: false,
-    }).validate();
-  }
-  getCodeHash() {
-    const start = 4;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new Byte32(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getHashType() {
-    const start = 8;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new DataView(this.view.buffer.slice(offset, offset_end)).getUint8(0);
-  }
-  getArgs() {
-    const start = 12;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.byteLength;
-    return new Bytes(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        new Byte32(this.view.buffer.slice(offsets[0], offsets[1]), {
+            validate: false,
+        }).validate();
+        if (offsets[2] - offsets[1] !== 1) {
+            throw new Error(`Invalid offset for hashType: ${offsets[1]} - ${offsets[2]}`);
+        }
+        new Bytes(this.view.buffer.slice(offsets[2], offsets[3]), {
+            validate: false,
+        }).validate();
+    }
+    getCodeHash() {
+        const start = 4;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new Byte32(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getHashType() {
+        const start = 8;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new DataView(this.view.buffer.slice(offset, offset_end)).getUint8(0);
+    }
+    getArgs() {
+        const start = 12;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.byteLength;
+        return new Bytes(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.Script = Script;
 function SerializeScript(value) {
-  const buffers = [];
-  buffers.push(SerializeByte32(value.codeHash));
-  const hashTypeView = new DataView(new ArrayBuffer(1));
-  hashTypeView.setUint8(0, value.hashType);
-  buffers.push(hashTypeView.buffer);
-  buffers.push(SerializeBytes(value.args));
-  return serializeTable(buffers);
+    const buffers = [];
+    buffers.push(SerializeByte32(value.codeHash));
+    const hashTypeView = new DataView(new ArrayBuffer(1));
+    hashTypeView.setUint8(0, value.hashType);
+    buffers.push(hashTypeView.buffer);
+    buffers.push(SerializeBytes(value.args));
+    return serializeTable(buffers);
 }
 exports.SerializeScript = SerializeScript;
 class OutPoint {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  getTxHash() {
-    return new Byte32(this.view.buffer.slice(0, 0 + Byte32.size()), {
-      validate: false,
-    });
-  }
-  getIndex() {
-    return new Uint32(
-      this.view.buffer.slice(
-        0 + Byte32.size(),
-        0 + Byte32.size() + Uint32.size(),
-      ),
-      { validate: false },
-    );
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, OutPoint.size());
-    this.getTxHash().validate(compatible);
-    this.getIndex().validate(compatible);
-  }
-  static size() {
-    return 0 + Byte32.size() + Uint32.size();
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    getTxHash() {
+        return new Byte32(this.view.buffer.slice(0, 0 + Byte32.size()), {
+            validate: false,
+        });
+    }
+    getIndex() {
+        return new Uint32(this.view.buffer.slice(0 + Byte32.size(), 0 + Byte32.size() + Uint32.size()), { validate: false });
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, OutPoint.size());
+        this.getTxHash().validate(compatible);
+        this.getIndex().validate(compatible);
+    }
+    static size() {
+        return 0 + Byte32.size() + Uint32.size();
+    }
 }
 exports.OutPoint = OutPoint;
 function SerializeOutPoint(value) {
-  const array = new Uint8Array(0 + Byte32.size() + Uint32.size());
-  const view = new DataView(array.buffer);
-  array.set(new Uint8Array(SerializeByte32(value.txHash)), 0);
-  array.set(new Uint8Array(SerializeUint32(value.index)), 0 + Byte32.size());
-  return array.buffer;
+    const array = new Uint8Array(0 + Byte32.size() + Uint32.size());
+    const view = new DataView(array.buffer);
+    array.set(new Uint8Array(SerializeByte32(value.txHash)), 0);
+    array.set(new Uint8Array(SerializeUint32(value.index)), 0 + Byte32.size());
+    return array.buffer;
 }
 exports.SerializeOutPoint = SerializeOutPoint;
 class CellInput {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  getSince() {
-    return new Uint64(this.view.buffer.slice(0, 0 + Uint64.size()), {
-      validate: false,
-    });
-  }
-  getPreviousOutput() {
-    return new OutPoint(
-      this.view.buffer.slice(
-        0 + Uint64.size(),
-        0 + Uint64.size() + OutPoint.size(),
-      ),
-      { validate: false },
-    );
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, CellInput.size());
-    this.getSince().validate(compatible);
-    this.getPreviousOutput().validate(compatible);
-  }
-  static size() {
-    return 0 + Uint64.size() + OutPoint.size();
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    getSince() {
+        return new Uint64(this.view.buffer.slice(0, 0 + Uint64.size()), {
+            validate: false,
+        });
+    }
+    getPreviousOutput() {
+        return new OutPoint(this.view.buffer.slice(0 + Uint64.size(), 0 + Uint64.size() + OutPoint.size()), { validate: false });
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, CellInput.size());
+        this.getSince().validate(compatible);
+        this.getPreviousOutput().validate(compatible);
+    }
+    static size() {
+        return 0 + Uint64.size() + OutPoint.size();
+    }
 }
 exports.CellInput = CellInput;
 function SerializeCellInput(value) {
-  const array = new Uint8Array(0 + Uint64.size() + OutPoint.size());
-  const view = new DataView(array.buffer);
-  array.set(new Uint8Array(SerializeUint64(value.since)), 0);
-  array.set(
-    new Uint8Array(SerializeOutPoint(value.previousOutput)),
-    0 + Uint64.size(),
-  );
-  return array.buffer;
+    const array = new Uint8Array(0 + Uint64.size() + OutPoint.size());
+    const view = new DataView(array.buffer);
+    array.set(new Uint8Array(SerializeUint64(value.since)), 0);
+    array.set(new Uint8Array(SerializeOutPoint(value.previousOutput)), 0 + Uint64.size());
+    return array.buffer;
 }
 exports.SerializeCellInput = SerializeCellInput;
 class CellOutput {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    new Uint64(this.view.buffer.slice(offsets[0], offsets[1]), {
-      validate: false,
-    }).validate();
-    new Script(this.view.buffer.slice(offsets[1], offsets[2]), {
-      validate: false,
-    }).validate();
-    new ScriptOpt(this.view.buffer.slice(offsets[2], offsets[3]), {
-      validate: false,
-    }).validate();
-  }
-  getCapacity() {
-    const start = 4;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new Uint64(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getLock() {
-    const start = 8;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new Script(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getType() {
-    const start = 12;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.byteLength;
-    return new ScriptOpt(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        new Uint64(this.view.buffer.slice(offsets[0], offsets[1]), {
+            validate: false,
+        }).validate();
+        new Script(this.view.buffer.slice(offsets[1], offsets[2]), {
+            validate: false,
+        }).validate();
+        new ScriptOpt(this.view.buffer.slice(offsets[2], offsets[3]), {
+            validate: false,
+        }).validate();
+    }
+    getCapacity() {
+        const start = 4;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new Uint64(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getLock() {
+        const start = 8;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new Script(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getType() {
+        const start = 12;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.byteLength;
+        return new ScriptOpt(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.CellOutput = CellOutput;
 function SerializeCellOutput(value) {
-  const buffers = [];
-  buffers.push(SerializeUint64(value.capacity));
-  buffers.push(SerializeScript(value.lock));
-  buffers.push(SerializeScriptOpt(value.type));
-  return serializeTable(buffers);
+    const buffers = [];
+    buffers.push(SerializeUint64(value.capacity));
+    buffers.push(SerializeScript(value.lock));
+    buffers.push(SerializeScriptOpt(value.type));
+    return serializeTable(buffers);
 }
 exports.SerializeCellOutput = SerializeCellOutput;
 class CellDep {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  getOutPoint() {
-    return new OutPoint(this.view.buffer.slice(0, 0 + OutPoint.size()), {
-      validate: false,
-    });
-  }
-  getDepType() {
-    return this.view.getUint8(0 + OutPoint.size());
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, CellDep.size());
-    this.getOutPoint().validate(compatible);
-  }
-  static size() {
-    return 0 + OutPoint.size() + 1;
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    getOutPoint() {
+        return new OutPoint(this.view.buffer.slice(0, 0 + OutPoint.size()), {
+            validate: false,
+        });
+    }
+    getDepType() {
+        return this.view.getUint8(0 + OutPoint.size());
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, CellDep.size());
+        this.getOutPoint().validate(compatible);
+    }
+    static size() {
+        return 0 + OutPoint.size() + 1;
+    }
 }
 exports.CellDep = CellDep;
 function SerializeCellDep(value) {
-  const array = new Uint8Array(0 + OutPoint.size() + 1);
-  const view = new DataView(array.buffer);
-  array.set(new Uint8Array(SerializeOutPoint(value.outPoint)), 0);
-  view.setUint8(0 + OutPoint.size(), value.depType);
-  return array.buffer;
+    const array = new Uint8Array(0 + OutPoint.size() + 1);
+    const view = new DataView(array.buffer);
+    array.set(new Uint8Array(SerializeOutPoint(value.outPoint)), 0);
+    view.setUint8(0 + OutPoint.size(), value.depType);
+    return array.buffer;
 }
 exports.SerializeCellDep = SerializeCellDep;
 class RawTransaction {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    new Uint32(this.view.buffer.slice(offsets[0], offsets[1]), {
-      validate: false,
-    }).validate();
-    new CellDepVec(this.view.buffer.slice(offsets[1], offsets[2]), {
-      validate: false,
-    }).validate();
-    new Byte32Vec(this.view.buffer.slice(offsets[2], offsets[3]), {
-      validate: false,
-    }).validate();
-    new CellInputVec(this.view.buffer.slice(offsets[3], offsets[4]), {
-      validate: false,
-    }).validate();
-    new CellOutputVec(this.view.buffer.slice(offsets[4], offsets[5]), {
-      validate: false,
-    }).validate();
-    new BytesVec(this.view.buffer.slice(offsets[5], offsets[6]), {
-      validate: false,
-    }).validate();
-  }
-  getVersion() {
-    const start = 4;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new Uint32(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getCellDeps() {
-    const start = 8;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new CellDepVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getHeaderDeps() {
-    const start = 12;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new Byte32Vec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getInputs() {
-    const start = 16;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new CellInputVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getOutputs() {
-    const start = 20;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new CellOutputVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getOutputsData() {
-    const start = 24;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.byteLength;
-    return new BytesVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        new Uint32(this.view.buffer.slice(offsets[0], offsets[1]), {
+            validate: false,
+        }).validate();
+        new CellDepVec(this.view.buffer.slice(offsets[1], offsets[2]), {
+            validate: false,
+        }).validate();
+        new Byte32Vec(this.view.buffer.slice(offsets[2], offsets[3]), {
+            validate: false,
+        }).validate();
+        new CellInputVec(this.view.buffer.slice(offsets[3], offsets[4]), {
+            validate: false,
+        }).validate();
+        new CellOutputVec(this.view.buffer.slice(offsets[4], offsets[5]), {
+            validate: false,
+        }).validate();
+        new BytesVec(this.view.buffer.slice(offsets[5], offsets[6]), {
+            validate: false,
+        }).validate();
+    }
+    getVersion() {
+        const start = 4;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new Uint32(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getCellDeps() {
+        const start = 8;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new CellDepVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getHeaderDeps() {
+        const start = 12;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new Byte32Vec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getInputs() {
+        const start = 16;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new CellInputVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getOutputs() {
+        const start = 20;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new CellOutputVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getOutputsData() {
+        const start = 24;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.byteLength;
+        return new BytesVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.RawTransaction = RawTransaction;
 function SerializeRawTransaction(value) {
-  const buffers = [];
-  buffers.push(SerializeUint32(value.version));
-  buffers.push(SerializeCellDepVec(value.cellDeps));
-  buffers.push(SerializeByte32Vec(value.headerDeps));
-  buffers.push(SerializeCellInputVec(value.inputs));
-  buffers.push(SerializeCellOutputVec(value.outputs));
-  buffers.push(SerializeBytesVec(value.outputsData));
-  return serializeTable(buffers);
+    const buffers = [];
+    buffers.push(SerializeUint32(value.version));
+    buffers.push(SerializeCellDepVec(value.cellDeps));
+    buffers.push(SerializeByte32Vec(value.headerDeps));
+    buffers.push(SerializeCellInputVec(value.inputs));
+    buffers.push(SerializeCellOutputVec(value.outputs));
+    buffers.push(SerializeBytesVec(value.outputsData));
+    return serializeTable(buffers);
 }
 exports.SerializeRawTransaction = SerializeRawTransaction;
 class Transaction {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    new RawTransaction(this.view.buffer.slice(offsets[0], offsets[1]), {
-      validate: false,
-    }).validate();
-    new BytesVec(this.view.buffer.slice(offsets[1], offsets[2]), {
-      validate: false,
-    }).validate();
-  }
-  getRaw() {
-    const start = 4;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new RawTransaction(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getWitnesses() {
-    const start = 8;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.byteLength;
-    return new BytesVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        new RawTransaction(this.view.buffer.slice(offsets[0], offsets[1]), {
+            validate: false,
+        }).validate();
+        new BytesVec(this.view.buffer.slice(offsets[1], offsets[2]), {
+            validate: false,
+        }).validate();
+    }
+    getRaw() {
+        const start = 4;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new RawTransaction(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getWitnesses() {
+        const start = 8;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.byteLength;
+        return new BytesVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.Transaction = Transaction;
 function SerializeTransaction(value) {
-  const buffers = [];
-  buffers.push(SerializeRawTransaction(value.raw));
-  buffers.push(SerializeBytesVec(value.witnesses));
-  return serializeTable(buffers);
+    const buffers = [];
+    buffers.push(SerializeRawTransaction(value.raw));
+    buffers.push(SerializeBytesVec(value.witnesses));
+    return serializeTable(buffers);
 }
 exports.SerializeTransaction = SerializeTransaction;
 class RawHeader {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  getVersion() {
-    return new Uint32(this.view.buffer.slice(0, 0 + Uint32.size()), {
-      validate: false,
-    });
-  }
-  getCompactTarget() {
-    return new Uint32(
-      this.view.buffer.slice(
-        0 + Uint32.size(),
-        0 + Uint32.size() + Uint32.size(),
-      ),
-      { validate: false },
-    );
-  }
-  getTimestamp() {
-    return new Uint64(
-      this.view.buffer.slice(
-        0 + Uint32.size() + Uint32.size(),
-        0 + Uint32.size() + Uint32.size() + Uint64.size(),
-      ),
-      { validate: false },
-    );
-  }
-  getNumber() {
-    return new Uint64(
-      this.view.buffer.slice(
-        0 + Uint32.size() + Uint32.size() + Uint64.size(),
-        0 + Uint32.size() + Uint32.size() + Uint64.size() + Uint64.size(),
-      ),
-      { validate: false },
-    );
-  }
-  getEpoch() {
-    return new Uint64(
-      this.view.buffer.slice(
-        0 + Uint32.size() + Uint32.size() + Uint64.size() + Uint64.size(),
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size(),
-      ),
-      { validate: false },
-    );
-  }
-  getParentHash() {
-    return new Byte32(
-      this.view.buffer.slice(
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size(),
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Byte32.size(),
-      ),
-      { validate: false },
-    );
-  }
-  getTransactionsRoot() {
-    return new Byte32(
-      this.view.buffer.slice(
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Byte32.size(),
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Byte32.size() +
-          Byte32.size(),
-      ),
-      { validate: false },
-    );
-  }
-  getProposalsHash() {
-    return new Byte32(
-      this.view.buffer.slice(
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Byte32.size() +
-          Byte32.size(),
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Byte32.size() +
-          Byte32.size() +
-          Byte32.size(),
-      ),
-      { validate: false },
-    );
-  }
-  getExtraHash() {
-    return new Byte32(
-      this.view.buffer.slice(
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Byte32.size() +
-          Byte32.size() +
-          Byte32.size(),
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Byte32.size() +
-          Byte32.size() +
-          Byte32.size() +
-          Byte32.size(),
-      ),
-      { validate: false },
-    );
-  }
-  getDao() {
-    return new Byte32(
-      this.view.buffer.slice(
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Byte32.size() +
-          Byte32.size() +
-          Byte32.size() +
-          Byte32.size(),
-        0 +
-          Uint32.size() +
-          Uint32.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Uint64.size() +
-          Byte32.size() +
-          Byte32.size() +
-          Byte32.size() +
-          Byte32.size() +
-          Byte32.size(),
-      ),
-      { validate: false },
-    );
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, RawHeader.size());
-    this.getVersion().validate(compatible);
-    this.getCompactTarget().validate(compatible);
-    this.getTimestamp().validate(compatible);
-    this.getNumber().validate(compatible);
-    this.getEpoch().validate(compatible);
-    this.getParentHash().validate(compatible);
-    this.getTransactionsRoot().validate(compatible);
-    this.getProposalsHash().validate(compatible);
-    this.getExtraHash().validate(compatible);
-    this.getDao().validate(compatible);
-  }
-  static size() {
-    return (
-      0 +
-      Uint32.size() +
-      Uint32.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Byte32.size() +
-      Byte32.size() +
-      Byte32.size() +
-      Byte32.size() +
-      Byte32.size()
-    );
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    getVersion() {
+        return new Uint32(this.view.buffer.slice(0, 0 + Uint32.size()), {
+            validate: false,
+        });
+    }
+    getCompactTarget() {
+        return new Uint32(this.view.buffer.slice(0 + Uint32.size(), 0 + Uint32.size() + Uint32.size()), { validate: false });
+    }
+    getTimestamp() {
+        return new Uint64(this.view.buffer.slice(0 + Uint32.size() + Uint32.size(), 0 + Uint32.size() + Uint32.size() + Uint64.size()), { validate: false });
+    }
+    getNumber() {
+        return new Uint64(this.view.buffer.slice(0 + Uint32.size() + Uint32.size() + Uint64.size(), 0 + Uint32.size() + Uint32.size() + Uint64.size() + Uint64.size()), { validate: false });
+    }
+    getEpoch() {
+        return new Uint64(this.view.buffer.slice(0 + Uint32.size() + Uint32.size() + Uint64.size() + Uint64.size(), 0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size()), { validate: false });
+    }
+    getParentHash() {
+        return new Byte32(this.view.buffer.slice(0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size(), 0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Byte32.size()), { validate: false });
+    }
+    getTransactionsRoot() {
+        return new Byte32(this.view.buffer.slice(0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Byte32.size(), 0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Byte32.size() +
+            Byte32.size()), { validate: false });
+    }
+    getProposalsHash() {
+        return new Byte32(this.view.buffer.slice(0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Byte32.size() +
+            Byte32.size(), 0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size()), { validate: false });
+    }
+    getExtraHash() {
+        return new Byte32(this.view.buffer.slice(0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size(), 0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size()), { validate: false });
+    }
+    getDao() {
+        return new Byte32(this.view.buffer.slice(0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size(), 0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size()), { validate: false });
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, RawHeader.size());
+        this.getVersion().validate(compatible);
+        this.getCompactTarget().validate(compatible);
+        this.getTimestamp().validate(compatible);
+        this.getNumber().validate(compatible);
+        this.getEpoch().validate(compatible);
+        this.getParentHash().validate(compatible);
+        this.getTransactionsRoot().validate(compatible);
+        this.getProposalsHash().validate(compatible);
+        this.getExtraHash().validate(compatible);
+        this.getDao().validate(compatible);
+    }
+    static size() {
+        return (0 +
+            Uint32.size() +
+            Uint32.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Uint64.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size() +
+            Byte32.size());
+    }
 }
 exports.RawHeader = RawHeader;
 function SerializeRawHeader(value) {
-  const array = new Uint8Array(
-    0 +
-      Uint32.size() +
-      Uint32.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Byte32.size() +
-      Byte32.size() +
-      Byte32.size() +
-      Byte32.size() +
-      Byte32.size(),
-  );
-  const view = new DataView(array.buffer);
-  array.set(new Uint8Array(SerializeUint32(value.version)), 0);
-  array.set(
-    new Uint8Array(SerializeUint32(value.compactTarget)),
-    0 + Uint32.size(),
-  );
-  array.set(
-    new Uint8Array(SerializeUint64(value.timestamp)),
-    0 + Uint32.size() + Uint32.size(),
-  );
-  array.set(
-    new Uint8Array(SerializeUint64(value.number)),
-    0 + Uint32.size() + Uint32.size() + Uint64.size(),
-  );
-  array.set(
-    new Uint8Array(SerializeUint64(value.epoch)),
-    0 + Uint32.size() + Uint32.size() + Uint64.size() + Uint64.size(),
-  );
-  array.set(
-    new Uint8Array(SerializeByte32(value.parentHash)),
-    0 +
-      Uint32.size() +
-      Uint32.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Uint64.size(),
-  );
-  array.set(
-    new Uint8Array(SerializeByte32(value.transactionsRoot)),
-    0 +
-      Uint32.size() +
-      Uint32.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Byte32.size(),
-  );
-  array.set(
-    new Uint8Array(SerializeByte32(value.proposalsHash)),
-    0 +
-      Uint32.size() +
-      Uint32.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Byte32.size() +
-      Byte32.size(),
-  );
-  array.set(
-    new Uint8Array(SerializeByte32(value.extraHash)),
-    0 +
-      Uint32.size() +
-      Uint32.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Byte32.size() +
-      Byte32.size() +
-      Byte32.size(),
-  );
-  array.set(
-    new Uint8Array(SerializeByte32(value.dao)),
-    0 +
-      Uint32.size() +
-      Uint32.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Uint64.size() +
-      Byte32.size() +
-      Byte32.size() +
-      Byte32.size() +
-      Byte32.size(),
-  );
-  return array.buffer;
+    const array = new Uint8Array(0 +
+        Uint32.size() +
+        Uint32.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Byte32.size() +
+        Byte32.size() +
+        Byte32.size() +
+        Byte32.size() +
+        Byte32.size());
+    const view = new DataView(array.buffer);
+    array.set(new Uint8Array(SerializeUint32(value.version)), 0);
+    array.set(new Uint8Array(SerializeUint32(value.compactTarget)), 0 + Uint32.size());
+    array.set(new Uint8Array(SerializeUint64(value.timestamp)), 0 + Uint32.size() + Uint32.size());
+    array.set(new Uint8Array(SerializeUint64(value.number)), 0 + Uint32.size() + Uint32.size() + Uint64.size());
+    array.set(new Uint8Array(SerializeUint64(value.epoch)), 0 + Uint32.size() + Uint32.size() + Uint64.size() + Uint64.size());
+    array.set(new Uint8Array(SerializeByte32(value.parentHash)), 0 +
+        Uint32.size() +
+        Uint32.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Uint64.size());
+    array.set(new Uint8Array(SerializeByte32(value.transactionsRoot)), 0 +
+        Uint32.size() +
+        Uint32.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Byte32.size());
+    array.set(new Uint8Array(SerializeByte32(value.proposalsHash)), 0 +
+        Uint32.size() +
+        Uint32.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Byte32.size() +
+        Byte32.size());
+    array.set(new Uint8Array(SerializeByte32(value.extraHash)), 0 +
+        Uint32.size() +
+        Uint32.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Byte32.size() +
+        Byte32.size() +
+        Byte32.size());
+    array.set(new Uint8Array(SerializeByte32(value.dao)), 0 +
+        Uint32.size() +
+        Uint32.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Uint64.size() +
+        Byte32.size() +
+        Byte32.size() +
+        Byte32.size() +
+        Byte32.size());
+    return array.buffer;
 }
 exports.SerializeRawHeader = SerializeRawHeader;
 class Header {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  getRaw() {
-    return new RawHeader(this.view.buffer.slice(0, 0 + RawHeader.size()), {
-      validate: false,
-    });
-  }
-  getNonce() {
-    return new Uint128(
-      this.view.buffer.slice(
-        0 + RawHeader.size(),
-        0 + RawHeader.size() + Uint128.size(),
-      ),
-      { validate: false },
-    );
-  }
-  validate(compatible = false) {
-    assertDataLength(this.view.byteLength, Header.size());
-    this.getRaw().validate(compatible);
-    this.getNonce().validate(compatible);
-  }
-  static size() {
-    return 0 + RawHeader.size() + Uint128.size();
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    getRaw() {
+        return new RawHeader(this.view.buffer.slice(0, 0 + RawHeader.size()), {
+            validate: false,
+        });
+    }
+    getNonce() {
+        return new Uint128(this.view.buffer.slice(0 + RawHeader.size(), 0 + RawHeader.size() + Uint128.size()), { validate: false });
+    }
+    validate(compatible = false) {
+        assertDataLength(this.view.byteLength, Header.size());
+        this.getRaw().validate(compatible);
+        this.getNonce().validate(compatible);
+    }
+    static size() {
+        return 0 + RawHeader.size() + Uint128.size();
+    }
 }
 exports.Header = Header;
 function SerializeHeader(value) {
-  const array = new Uint8Array(0 + RawHeader.size() + Uint128.size());
-  const view = new DataView(array.buffer);
-  array.set(new Uint8Array(SerializeRawHeader(value.raw)), 0);
-  array.set(
-    new Uint8Array(SerializeUint128(value.nonce)),
-    0 + RawHeader.size(),
-  );
-  return array.buffer;
+    const array = new Uint8Array(0 + RawHeader.size() + Uint128.size());
+    const view = new DataView(array.buffer);
+    array.set(new Uint8Array(SerializeRawHeader(value.raw)), 0);
+    array.set(new Uint8Array(SerializeUint128(value.nonce)), 0 + RawHeader.size());
+    return array.buffer;
 }
 exports.SerializeHeader = SerializeHeader;
 class UncleBlock {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    new Header(this.view.buffer.slice(offsets[0], offsets[1]), {
-      validate: false,
-    }).validate();
-    new ProposalShortIdVec(this.view.buffer.slice(offsets[1], offsets[2]), {
-      validate: false,
-    }).validate();
-  }
-  getHeader() {
-    const start = 4;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new Header(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getProposals() {
-    const start = 8;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.byteLength;
-    return new ProposalShortIdVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        new Header(this.view.buffer.slice(offsets[0], offsets[1]), {
+            validate: false,
+        }).validate();
+        new ProposalShortIdVec(this.view.buffer.slice(offsets[1], offsets[2]), {
+            validate: false,
+        }).validate();
+    }
+    getHeader() {
+        const start = 4;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new Header(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getProposals() {
+        const start = 8;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.byteLength;
+        return new ProposalShortIdVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.UncleBlock = UncleBlock;
 function SerializeUncleBlock(value) {
-  const buffers = [];
-  buffers.push(SerializeHeader(value.header));
-  buffers.push(SerializeProposalShortIdVec(value.proposals));
-  return serializeTable(buffers);
+    const buffers = [];
+    buffers.push(SerializeHeader(value.header));
+    buffers.push(SerializeProposalShortIdVec(value.proposals));
+    return serializeTable(buffers);
 }
 exports.SerializeUncleBlock = SerializeUncleBlock;
 class Block {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    new Header(this.view.buffer.slice(offsets[0], offsets[1]), {
-      validate: false,
-    }).validate();
-    new UncleBlockVec(this.view.buffer.slice(offsets[1], offsets[2]), {
-      validate: false,
-    }).validate();
-    new TransactionVec(this.view.buffer.slice(offsets[2], offsets[3]), {
-      validate: false,
-    }).validate();
-    new ProposalShortIdVec(this.view.buffer.slice(offsets[3], offsets[4]), {
-      validate: false,
-    }).validate();
-  }
-  getHeader() {
-    const start = 4;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new Header(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getUncles() {
-    const start = 8;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new UncleBlockVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getTransactions() {
-    const start = 12;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new TransactionVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getProposals() {
-    const start = 16;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.byteLength;
-    return new ProposalShortIdVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        new Header(this.view.buffer.slice(offsets[0], offsets[1]), {
+            validate: false,
+        }).validate();
+        new UncleBlockVec(this.view.buffer.slice(offsets[1], offsets[2]), {
+            validate: false,
+        }).validate();
+        new TransactionVec(this.view.buffer.slice(offsets[2], offsets[3]), {
+            validate: false,
+        }).validate();
+        new ProposalShortIdVec(this.view.buffer.slice(offsets[3], offsets[4]), {
+            validate: false,
+        }).validate();
+    }
+    getHeader() {
+        const start = 4;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new Header(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getUncles() {
+        const start = 8;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new UncleBlockVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getTransactions() {
+        const start = 12;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new TransactionVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getProposals() {
+        const start = 16;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.byteLength;
+        return new ProposalShortIdVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.Block = Block;
 function SerializeBlock(value) {
-  const buffers = [];
-  buffers.push(SerializeHeader(value.header));
-  buffers.push(SerializeUncleBlockVec(value.uncles));
-  buffers.push(SerializeTransactionVec(value.transactions));
-  buffers.push(SerializeProposalShortIdVec(value.proposals));
-  return serializeTable(buffers);
+    const buffers = [];
+    buffers.push(SerializeHeader(value.header));
+    buffers.push(SerializeUncleBlockVec(value.uncles));
+    buffers.push(SerializeTransactionVec(value.transactions));
+    buffers.push(SerializeProposalShortIdVec(value.proposals));
+    return serializeTable(buffers);
 }
 exports.SerializeBlock = SerializeBlock;
 class BlockV1 {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    new Header(this.view.buffer.slice(offsets[0], offsets[1]), {
-      validate: false,
-    }).validate();
-    new UncleBlockVec(this.view.buffer.slice(offsets[1], offsets[2]), {
-      validate: false,
-    }).validate();
-    new TransactionVec(this.view.buffer.slice(offsets[2], offsets[3]), {
-      validate: false,
-    }).validate();
-    new ProposalShortIdVec(this.view.buffer.slice(offsets[3], offsets[4]), {
-      validate: false,
-    }).validate();
-    new Bytes(this.view.buffer.slice(offsets[4], offsets[5]), {
-      validate: false,
-    }).validate();
-  }
-  getHeader() {
-    const start = 4;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new Header(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getUncles() {
-    const start = 8;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new UncleBlockVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getTransactions() {
-    const start = 12;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new TransactionVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getProposals() {
-    const start = 16;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new ProposalShortIdVec(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getExtension() {
-    const start = 20;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.byteLength;
-    return new Bytes(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        new Header(this.view.buffer.slice(offsets[0], offsets[1]), {
+            validate: false,
+        }).validate();
+        new UncleBlockVec(this.view.buffer.slice(offsets[1], offsets[2]), {
+            validate: false,
+        }).validate();
+        new TransactionVec(this.view.buffer.slice(offsets[2], offsets[3]), {
+            validate: false,
+        }).validate();
+        new ProposalShortIdVec(this.view.buffer.slice(offsets[3], offsets[4]), {
+            validate: false,
+        }).validate();
+        new Bytes(this.view.buffer.slice(offsets[4], offsets[5]), {
+            validate: false,
+        }).validate();
+    }
+    getHeader() {
+        const start = 4;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new Header(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getUncles() {
+        const start = 8;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new UncleBlockVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getTransactions() {
+        const start = 12;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new TransactionVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getProposals() {
+        const start = 16;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new ProposalShortIdVec(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getExtension() {
+        const start = 20;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.byteLength;
+        return new Bytes(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.BlockV1 = BlockV1;
 function SerializeBlockV1(value) {
-  const buffers = [];
-  buffers.push(SerializeHeader(value.header));
-  buffers.push(SerializeUncleBlockVec(value.uncles));
-  buffers.push(SerializeTransactionVec(value.transactions));
-  buffers.push(SerializeProposalShortIdVec(value.proposals));
-  buffers.push(SerializeBytes(value.extension));
-  return serializeTable(buffers);
+    const buffers = [];
+    buffers.push(SerializeHeader(value.header));
+    buffers.push(SerializeUncleBlockVec(value.uncles));
+    buffers.push(SerializeTransactionVec(value.transactions));
+    buffers.push(SerializeProposalShortIdVec(value.proposals));
+    buffers.push(SerializeBytes(value.extension));
+    return serializeTable(buffers);
 }
 exports.SerializeBlockV1 = SerializeBlockV1;
 class CellbaseWitness {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    new Script(this.view.buffer.slice(offsets[0], offsets[1]), {
-      validate: false,
-    }).validate();
-    new Bytes(this.view.buffer.slice(offsets[1], offsets[2]), {
-      validate: false,
-    }).validate();
-  }
-  getLock() {
-    const start = 4;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new Script(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getMessage() {
-    const start = 8;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.byteLength;
-    return new Bytes(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        new Script(this.view.buffer.slice(offsets[0], offsets[1]), {
+            validate: false,
+        }).validate();
+        new Bytes(this.view.buffer.slice(offsets[1], offsets[2]), {
+            validate: false,
+        }).validate();
+    }
+    getLock() {
+        const start = 4;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new Script(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getMessage() {
+        const start = 8;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.byteLength;
+        return new Bytes(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.CellbaseWitness = CellbaseWitness;
 function SerializeCellbaseWitness(value) {
-  const buffers = [];
-  buffers.push(SerializeScript(value.lock));
-  buffers.push(SerializeBytes(value.message));
-  return serializeTable(buffers);
+    const buffers = [];
+    buffers.push(SerializeScript(value.lock));
+    buffers.push(SerializeBytes(value.message));
+    return serializeTable(buffers);
 }
 exports.SerializeCellbaseWitness = SerializeCellbaseWitness;
 class WitnessArgs {
-  constructor(reader, { validate = true } = {}) {
-    this.view = new DataView(assertArrayBuffer(reader));
-    if (validate) {
-      this.validate();
-    }
-  }
-  validate(compatible = false) {
-    const offsets = verifyAndExtractOffsets(this.view, 0, true);
-    new BytesOpt(this.view.buffer.slice(offsets[0], offsets[1]), {
-      validate: false,
-    }).validate();
-    new BytesOpt(this.view.buffer.slice(offsets[1], offsets[2]), {
-      validate: false,
-    }).validate();
-    new BytesOpt(this.view.buffer.slice(offsets[2], offsets[3]), {
-      validate: false,
-    }).validate();
-  }
-  getLock() {
-    const start = 4;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new BytesOpt(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getInputType() {
-    const start = 8;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.getUint32(start + 4, true);
-    return new BytesOpt(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
-  getOutputType() {
-    const start = 12;
-    const offset = this.view.getUint32(start, true);
-    const offset_end = this.view.byteLength;
-    return new BytesOpt(this.view.buffer.slice(offset, offset_end), {
-      validate: false,
-    });
-  }
+    constructor(reader, { validate = true } = {}) {
+        this.view = new DataView(assertArrayBuffer(reader));
+        if (validate) {
+            this.validate();
+        }
+    }
+    validate(compatible = false) {
+        const offsets = verifyAndExtractOffsets(this.view, 0, true);
+        new BytesOpt(this.view.buffer.slice(offsets[0], offsets[1]), {
+            validate: false,
+        }).validate();
+        new BytesOpt(this.view.buffer.slice(offsets[1], offsets[2]), {
+            validate: false,
+        }).validate();
+        new BytesOpt(this.view.buffer.slice(offsets[2], offsets[3]), {
+            validate: false,
+        }).validate();
+    }
+    getLock() {
+        const start = 4;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new BytesOpt(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getInputType() {
+        const start = 8;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.getUint32(start + 4, true);
+        return new BytesOpt(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
+    getOutputType() {
+        const start = 12;
+        const offset = this.view.getUint32(start, true);
+        const offset_end = this.view.byteLength;
+        return new BytesOpt(this.view.buffer.slice(offset, offset_end), {
+            validate: false,
+        });
+    }
 }
 exports.WitnessArgs = WitnessArgs;
 function SerializeWitnessArgs(value) {
-  const buffers = [];
-  buffers.push(SerializeBytesOpt(value.lock));
-  buffers.push(SerializeBytesOpt(value.inputType));
-  buffers.push(SerializeBytesOpt(value.outputType));
-  return serializeTable(buffers);
+    const buffers = [];
+    buffers.push(SerializeBytesOpt(value.lock));
+    buffers.push(SerializeBytesOpt(value.inputType));
+    buffers.push(SerializeBytesOpt(value.outputType));
+    return serializeTable(buffers);
 }
 exports.SerializeWitnessArgs = SerializeWitnessArgs;