@ckb-ccc/core 0.1.0 → 0.1.2

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

@@ -1,3 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WitnessArgs = exports.CellbaseWitness = exports.BlockV1 = exports.Block = exports.UncleBlock = exports.Header = exports.RawHeader = exports.Transaction = exports.RawTransaction = exports.CellDep = exports.CellOutput = exports.CellInput = exports.OutPoint = exports.Script = exports.CellOutputVec = exports.CellInputVec = exports.CellDepVec = exports.ProposalShortIdVec = exports.TransactionVec = exports.UncleBlockVec = exports.ProposalShortId = exports.ScriptOpt = exports.Byte32Vec = exports.BytesVec = exports.BytesOptVec = exports.BytesOpt = exports.Bytes = exports.Uint256 = exports.Byte32 = exports.Uint128 = exports.Uint64 = exports.Uint32 = void 0;
+exports.SerializeUint32 = SerializeUint32;
+exports.SerializeUint64 = SerializeUint64;
+exports.SerializeUint128 = SerializeUint128;
+exports.SerializeByte32 = SerializeByte32;
+exports.SerializeUint256 = SerializeUint256;
+exports.SerializeBytes = SerializeBytes;
+exports.SerializeBytesOpt = SerializeBytesOpt;
+exports.SerializeBytesOptVec = SerializeBytesOptVec;
+exports.SerializeBytesVec = SerializeBytesVec;
+exports.SerializeByte32Vec = SerializeByte32Vec;
+exports.SerializeScriptOpt = SerializeScriptOpt;
+exports.SerializeProposalShortId = SerializeProposalShortId;
+exports.SerializeUncleBlockVec = SerializeUncleBlockVec;
+exports.SerializeTransactionVec = SerializeTransactionVec;
+exports.SerializeProposalShortIdVec = SerializeProposalShortIdVec;
+exports.SerializeCellDepVec = SerializeCellDepVec;
+exports.SerializeCellInputVec = SerializeCellInputVec;
+exports.SerializeCellOutputVec = SerializeCellOutputVec;
+exports.SerializeScript = SerializeScript;
+exports.SerializeOutPoint = SerializeOutPoint;
+exports.SerializeCellInput = SerializeCellInput;
+exports.SerializeCellOutput = SerializeCellOutput;
+exports.SerializeCellDep = SerializeCellDep;
+exports.SerializeRawTransaction = SerializeRawTransaction;
+exports.SerializeTransaction = SerializeTransaction;
+exports.SerializeRawHeader = SerializeRawHeader;
+exports.SerializeHeader = SerializeHeader;
+exports.SerializeUncleBlock = SerializeUncleBlock;
+exports.SerializeBlock = SerializeBlock;
+exports.SerializeBlockV1 = SerializeBlockV1;
+exports.SerializeCellbaseWitness = SerializeCellbaseWitness;
+exports.SerializeWitnessArgs = SerializeWitnessArgs;
 function dataLengthError(actual, required) {
     throw new Error(`Invalid data length! Required: ${required}, actual: ${actual}`);
 }
@@ -75,7 +110,7 @@ function serializeTable(buffers) {
     }
     return buffer;
 }
-export class Uint32 {
+class Uint32 {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -101,12 +136,13 @@ export class Uint32 {
         return 4;
     }
 }
-export function SerializeUint32(value) {
+exports.Uint32 = Uint32;
+function SerializeUint32(value) {
     const buffer = assertArrayBuffer(value);
     assertDataLength(buffer.byteLength, 4);
     return buffer;
 }
-export class Uint64 {
+class Uint64 {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -126,12 +162,13 @@ export class Uint64 {
         return 8;
     }
 }
-export function SerializeUint64(value) {
+exports.Uint64 = Uint64;
+function SerializeUint64(value) {
     const buffer = assertArrayBuffer(value);
     assertDataLength(buffer.byteLength, 8);
     return buffer;
 }
-export class Uint128 {
+class Uint128 {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -151,12 +188,13 @@ export class Uint128 {
         return 16;
     }
 }
-export function SerializeUint128(value) {
+exports.Uint128 = Uint128;
+function SerializeUint128(value) {
     const buffer = assertArrayBuffer(value);
     assertDataLength(buffer.byteLength, 16);
     return buffer;
 }
-export class Byte32 {
+class Byte32 {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -176,12 +214,13 @@ export class Byte32 {
         return 32;
     }
 }
-export function SerializeByte32(value) {
+exports.Byte32 = Byte32;
+function SerializeByte32(value) {
     const buffer = assertArrayBuffer(value);
     assertDataLength(buffer.byteLength, 32);
     return buffer;
 }
-export class Uint256 {
+class Uint256 {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -201,12 +240,13 @@ export class Uint256 {
         return 32;
     }
 }
-export function SerializeUint256(value) {
+exports.Uint256 = Uint256;
+function SerializeUint256(value) {
     const buffer = assertArrayBuffer(value);
     assertDataLength(buffer.byteLength, 32);
     return buffer;
 }
-export class Bytes {
+class Bytes {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -230,14 +270,15 @@ export class Bytes {
         return this.view.getUint32(0, true);
     }
 }
-export function SerializeBytes(value) {
+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;
 }
-export class BytesOpt {
+class BytesOpt {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -256,7 +297,8 @@ export class BytesOpt {
         return this.view.byteLength > 0;
     }
 }
-export function SerializeBytesOpt(value) {
+exports.BytesOpt = BytesOpt;
+function SerializeBytesOpt(value) {
     if (value) {
         return SerializeBytes(value);
     }
@@ -264,7 +306,7 @@ export function SerializeBytesOpt(value) {
         return new ArrayBuffer(0);
     }
 }
-export class BytesOptVec {
+class BytesOptVec {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -299,10 +341,11 @@ export class BytesOptVec {
         });
     }
 }
-export function SerializeBytesOptVec(value) {
+exports.BytesOptVec = BytesOptVec;
+function SerializeBytesOptVec(value) {
     return serializeTable(value.map((item) => SerializeBytesOpt(item)));
 }
-export class BytesVec {
+class BytesVec {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -337,10 +380,11 @@ export class BytesVec {
         });
     }
 }
-export function SerializeBytesVec(value) {
+exports.BytesVec = BytesVec;
+function SerializeBytesVec(value) {
     return serializeTable(value.map((item) => SerializeBytes(item)));
 }
-export class Byte32Vec {
+class Byte32Vec {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -365,7 +409,8 @@ export class Byte32Vec {
         return this.view.getUint32(0, true);
     }
 }
-export function SerializeByte32Vec(value) {
+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++) {
@@ -374,7 +419,7 @@ export function SerializeByte32Vec(value) {
     }
     return array.buffer;
 }
-export class ScriptOpt {
+class ScriptOpt {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -393,7 +438,8 @@ export class ScriptOpt {
         return this.view.byteLength > 0;
     }
 }
-export function SerializeScriptOpt(value) {
+exports.ScriptOpt = ScriptOpt;
+function SerializeScriptOpt(value) {
     if (value) {
         return SerializeScript(value);
     }
@@ -401,7 +447,7 @@ export function SerializeScriptOpt(value) {
         return new ArrayBuffer(0);
     }
 }
-export class ProposalShortId {
+class ProposalShortId {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -421,12 +467,13 @@ export class ProposalShortId {
         return 10;
     }
 }
-export function SerializeProposalShortId(value) {
+exports.ProposalShortId = ProposalShortId;
+function SerializeProposalShortId(value) {
     const buffer = assertArrayBuffer(value);
     assertDataLength(buffer.byteLength, 10);
     return buffer;
 }
-export class UncleBlockVec {
+class UncleBlockVec {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -461,10 +508,11 @@ export class UncleBlockVec {
         });
     }
 }
-export function SerializeUncleBlockVec(value) {
+exports.UncleBlockVec = UncleBlockVec;
+function SerializeUncleBlockVec(value) {
     return serializeTable(value.map((item) => SerializeUncleBlock(item)));
 }
-export class TransactionVec {
+class TransactionVec {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -499,10 +547,11 @@ export class TransactionVec {
         });
     }
 }
-export function SerializeTransactionVec(value) {
+exports.TransactionVec = TransactionVec;
+function SerializeTransactionVec(value) {
     return serializeTable(value.map((item) => SerializeTransaction(item)));
 }
-export class ProposalShortIdVec {
+class ProposalShortIdVec {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -527,7 +576,8 @@ export class ProposalShortIdVec {
         return this.view.getUint32(0, true);
     }
 }
-export function SerializeProposalShortIdVec(value) {
+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++) {
@@ -536,7 +586,7 @@ export function SerializeProposalShortIdVec(value) {
     }
     return array.buffer;
 }
-export class CellDepVec {
+class CellDepVec {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -561,7 +611,8 @@ export class CellDepVec {
         return this.view.getUint32(0, true);
     }
 }
-export function SerializeCellDepVec(value) {
+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++) {
@@ -570,7 +621,7 @@ export function SerializeCellDepVec(value) {
     }
     return array.buffer;
 }
-export class CellInputVec {
+class CellInputVec {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -595,7 +646,8 @@ export class CellInputVec {
         return this.view.getUint32(0, true);
     }
 }
-export function SerializeCellInputVec(value) {
+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++) {
@@ -604,7 +656,7 @@ export function SerializeCellInputVec(value) {
     }
     return array.buffer;
 }
-export class CellOutputVec {
+class CellOutputVec {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -639,10 +691,11 @@ export class CellOutputVec {
         });
     }
 }
-export function SerializeCellOutputVec(value) {
+exports.CellOutputVec = CellOutputVec;
+function SerializeCellOutputVec(value) {
     return serializeTable(value.map((item) => SerializeCellOutput(item)));
 }
-export class Script {
+class Script {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -684,7 +737,8 @@ export class Script {
         });
     }
 }
-export function SerializeScript(value) {
+exports.Script = Script;
+function SerializeScript(value) {
     const buffers = [];
     buffers.push(SerializeByte32(value.codeHash));
     const hashTypeView = new DataView(new ArrayBuffer(1));
@@ -693,7 +747,7 @@ export function SerializeScript(value) {
     buffers.push(SerializeBytes(value.args));
     return serializeTable(buffers);
 }
-export class OutPoint {
+class OutPoint {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -717,14 +771,15 @@ export class OutPoint {
         return 0 + Byte32.size() + Uint32.size();
     }
 }
-export function SerializeOutPoint(value) {
+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;
 }
-export class CellInput {
+class CellInput {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -748,14 +803,15 @@ export class CellInput {
         return 0 + Uint64.size() + OutPoint.size();
     }
 }
-export function SerializeCellInput(value) {
+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;
 }
-export class CellOutput {
+class CellOutput {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -799,14 +855,15 @@ export class CellOutput {
         });
     }
 }
-export function SerializeCellOutput(value) {
+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);
 }
-export class CellDep {
+class CellDep {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -829,14 +886,15 @@ export class CellDep {
         return 0 + OutPoint.size() + 1;
     }
 }
-export function SerializeCellDep(value) {
+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;
 }
-export class RawTransaction {
+class RawTransaction {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -913,7 +971,8 @@ export class RawTransaction {
         });
     }
 }
-export function SerializeRawTransaction(value) {
+exports.RawTransaction = RawTransaction;
+function SerializeRawTransaction(value) {
     const buffers = [];
     buffers.push(SerializeUint32(value.version));
     buffers.push(SerializeCellDepVec(value.cellDeps));
@@ -923,7 +982,7 @@ export function SerializeRawTransaction(value) {
     buffers.push(SerializeBytesVec(value.outputsData));
     return serializeTable(buffers);
 }
-export class Transaction {
+class Transaction {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -956,13 +1015,14 @@ export class Transaction {
         });
     }
 }
-export function SerializeTransaction(value) {
+exports.Transaction = Transaction;
+function SerializeTransaction(value) {
     const buffers = [];
     buffers.push(SerializeRawTransaction(value.raw));
     buffers.push(SerializeBytesVec(value.witnesses));
     return serializeTable(buffers);
 }
-export class RawHeader {
+class RawHeader {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -1108,7 +1168,8 @@ export class RawHeader {
             Byte32.size());
     }
 }
-export function SerializeRawHeader(value) {
+exports.RawHeader = RawHeader;
+function SerializeRawHeader(value) {
     const array = new Uint8Array(0 +
         Uint32.size() +
         Uint32.size() +
@@ -1168,7 +1229,7 @@ export function SerializeRawHeader(value) {
         Byte32.size());
     return array.buffer;
 }
-export class Header {
+class Header {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -1192,14 +1253,15 @@ export class Header {
         return 0 + RawHeader.size() + Uint128.size();
     }
 }
-export function SerializeHeader(value) {
+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;
 }
-export class UncleBlock {
+class UncleBlock {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -1232,13 +1294,14 @@ export class UncleBlock {
         });
     }
 }
-export function SerializeUncleBlock(value) {
+exports.UncleBlock = UncleBlock;
+function SerializeUncleBlock(value) {
     const buffers = [];
     buffers.push(SerializeHeader(value.header));
     buffers.push(SerializeProposalShortIdVec(value.proposals));
     return serializeTable(buffers);
 }
-export class Block {
+class Block {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -1293,7 +1356,8 @@ export class Block {
         });
     }
 }
-export function SerializeBlock(value) {
+exports.Block = Block;
+function SerializeBlock(value) {
     const buffers = [];
     buffers.push(SerializeHeader(value.header));
     buffers.push(SerializeUncleBlockVec(value.uncles));
@@ -1301,7 +1365,7 @@ export function SerializeBlock(value) {
     buffers.push(SerializeProposalShortIdVec(value.proposals));
     return serializeTable(buffers);
 }
-export class BlockV1 {
+class BlockV1 {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -1367,7 +1431,8 @@ export class BlockV1 {
         });
     }
 }
-export function SerializeBlockV1(value) {
+exports.BlockV1 = BlockV1;
+function SerializeBlockV1(value) {
     const buffers = [];
     buffers.push(SerializeHeader(value.header));
     buffers.push(SerializeUncleBlockVec(value.uncles));
@@ -1376,7 +1441,7 @@ export function SerializeBlockV1(value) {
     buffers.push(SerializeBytes(value.extension));
     return serializeTable(buffers);
 }
-export class CellbaseWitness {
+class CellbaseWitness {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -1409,13 +1474,14 @@ export class CellbaseWitness {
         });
     }
 }
-export function SerializeCellbaseWitness(value) {
+exports.CellbaseWitness = CellbaseWitness;
+function SerializeCellbaseWitness(value) {
     const buffers = [];
     buffers.push(SerializeScript(value.lock));
     buffers.push(SerializeBytes(value.message));
     return serializeTable(buffers);
 }
-export class WitnessArgs {
+class WitnessArgs {
     constructor(reader, { validate = true } = {}) {
         this.view = new DataView(assertArrayBuffer(reader));
         if (validate) {
@@ -1459,7 +1525,8 @@ export class WitnessArgs {
         });
     }
 }
-export function SerializeWitnessArgs(value) {
+exports.WitnessArgs = WitnessArgs;
+function SerializeWitnessArgs(value) {
     const buffers = [];
     buffers.push(SerializeBytesOpt(value.lock));
     buffers.push(SerializeBytesOpt(value.inputType));

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

@@ -1,5 +1,22 @@
-export * from "./generated.js";
-export function molOptional(mol) {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.molOptional = molOptional;
+__exportStar(require("./generated.js"), exports);
+function molOptional(mol) {
     if (mol.hasValue()) {
         return mol.value();
     }

package/dist.commonjs/ckb/script.advanced.js

@@ -1,13 +1,16 @@
-export const HASH_TYPE_TO_NUM = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HASH_TYPES = exports.NUM_TO_HASH_TYPE = exports.HASH_TYPE_TO_NUM = void 0;
+exports.HASH_TYPE_TO_NUM = {
     type: 0x01,
     data: 0x00,
     data1: 0x02,
     data2: 0x04,
 };
-export const NUM_TO_HASH_TYPE = {
+exports.NUM_TO_HASH_TYPE = {
     0x01: "type",
     0x00: "data",
     0x02: "data1",
     0x04: "data2",
 };
-export const HASH_TYPES = Object.keys(HASH_TYPE_TO_NUM);
+exports.HASH_TYPES = Object.keys(exports.HASH_TYPE_TO_NUM);