@ckb-ccc/core 0.0.2-alpha.0 → 0.0.2-alpha.1

package/src/barrel.ts

@@ -1,7 +1,8 @@
 export * from "./address";
+export * from "./bytes";
 export * from "./ckb";
 export * from "./client";
-export * from "./codec";
-export * from "./types";
+export * from "./fixedPoint";
+export * from "./primitive";
 export * from "./signer";
 export * from "./viewer";

package/src/bytes.ts

@@ -0,0 +1,127 @@
+import { BytesLike, Hex, HexLike, NumberLike } from "./primitive";
+import { Buffer } from "buffer/";
+
+export function concatBytes(...args: BytesLike[]): Uint8Array {
+  return new Uint8Array(
+    args.reduce((acc: number[], v) => {
+      acc.push(...toBytes(v));
+      return acc;
+    }, []),
+  );
+}
+
+export function encodeUtf8(val: string): Uint8Array {
+  return Buffer.from(val, "utf-8");
+}
+
+export function decodeUtf8(val: BytesLike): string {
+  return Buffer.from(toBytes(val)).toString("utf-8");
+}
+
+export function toBytes(bytes: BytesLike): Uint8Array {
+  if (bytes instanceof Uint8Array) {
+    return bytes;
+  }
+
+  if (bytes instanceof ArrayBuffer) {
+    return new Uint8Array(bytes);
+  }
+
+  if (Array.isArray(bytes)) {
+    if (bytes.some((v) => v < 0 || 0xff < v)) {
+      throw new Error(`Invalid bytes ${JSON.stringify(bytes)}`);
+    }
+    return new Uint8Array(bytes);
+  }
+
+  const str = bytes.length % 2 === 0 ? bytes.slice(2) : `0${bytes.slice(2)}`;
+  const data = Buffer.from(str, "hex");
+  if (data.length * 2 !== str.length) {
+    throw new Error(`Invalid bytes ${bytes}`);
+  }
+  return data;
+}
+
+export function toHexFromHex(bytes: HexLike): Hex {
+  if (typeof bytes === "string" && !bytes.startsWith("0x")) {
+    return `0x${bytes}`;
+  }
+
+  return toHex(bytes);
+}
+
+export function toHex(bytes: HexLike): Hex {
+  if (typeof bytes === "number") {
+    return `0x${bytes.toString(16)}`;
+  }
+
+  if (typeof bytes === "string" && !bytes.startsWith("0x")) {
+    return `0x${BigInt(bytes).toString(16)}`;
+  }
+
+  return `0x${Buffer.from(toBytes(bytes as BytesLike)).toString("hex")}`;
+}
+
+export function toNumber(val: NumberLike): string {
+  return BigInt(val).toString();
+}
+
+export function toBytesFromNumber(val: NumberLike, bytes?: number): Uint8Array {
+  return toBytesFromLENumber(val, bytes);
+}
+
+export function toBytesFromLENumber(
+  val: NumberLike,
+  bytes?: number,
+): Uint8Array {
+  return toBytesFromBENumber(val, bytes).reverse();
+}
+
+export function toBytesFromBENumber(
+  val: NumberLike,
+  bytes?: number,
+): Uint8Array {
+  let valStr = val;
+  if (typeof valStr === "number" || typeof valStr === "bigint") {
+    valStr = valStr.toString(16);
+  } else if (typeof valStr === "string") {
+    if (valStr.startsWith("0x")) {
+      valStr = valStr.slice(2);
+    } else {
+      valStr = BigInt(valStr).toString(16);
+    }
+  }
+
+  if (valStr.length % 2 !== 0) {
+    valStr = `0${valStr}`;
+  }
+
+  const res = toBytes(`0x${valStr}`);
+  if (bytes == null) {
+    return res;
+  }
+  if (res.length > bytes) {
+    return res.slice(res.length - bytes);
+  }
+  return new Uint8Array([
+    ...Array.from(Array(bytes - res.length), () => 0),
+    ...res,
+  ]);
+}
+
+export function toNumberFromBytes(val: BytesLike): string {
+  return toLENumberFromBytes(val);
+}
+
+export function toLENumberFromBytes(val: BytesLike): string {
+  return toBENumberFromBytes(toBytes(val).reverse());
+}
+
+export function toBENumberFromBytes(val: BytesLike): string {
+  const str = toHex(val).replace(/0x0*/, "0x");
+  if (str.length === 2) {
+    return "0";
+  }
+
+  return BigInt(str).toString();
+}

package/src/ckb/advanced.ts

@@ -0,0 +1,2 @@
+export * from "./hasher.advanced";
+export * from "./types/advanced";

package/src/ckb/hasher.advanced.ts

@@ -0,0 +1 @@
+export const CKB_BLAKE2B_PERSONAL = "ckb-default-hash";

package/src/ckb/hasher.ts

@@ -0,0 +1,30 @@
+import blake2b, { Blake2b } from "blake2b";
+import { BytesLike, Hex } from "../primitive";
+import { encodeUtf8, toBytes } from "../bytes";
+import { CKB_BLAKE2B_PERSONAL } from "./hasher.advanced";
+
+export class Hasher {
+  hasher: Blake2b;
+
+  constructor(outLength = 32, personal = CKB_BLAKE2B_PERSONAL) {
+    this.hasher = blake2b(
+      outLength,
+      undefined,
+      undefined,
+      encodeUtf8(personal),
+    );
+  }
+
+  update(data: BytesLike): Hasher {
+    this.hasher.update(toBytes(data));
+    return this;
+  }
+
+  digest(): Hex {
+    return `0x${this.hasher.digest("hex")}`;
+  }
+}
+
+export function ckbHash(data: BytesLike): Hex {
+  return new Hasher().update(data).digest();
+}

package/src/ckb/index.ts

@@ -1 +1,3 @@
-export * from "./viewerCkbAddress";
+export * from "./hasher";
+export * from "./types";
+export * from "./viewerCkbScript";

package/src/ckb/types/advanced.ts

@@ -0,0 +1,3 @@
+export * from "./script.advanced";
+export * from "./transaction.advanced";
+export * as moleculeCodecCkb from "./molecule.advanced";

package/src/ckb/types/index.ts

@@ -0,0 +1,2 @@
+export * from "./script";
+export * from "./transaction";

package/src/ckb/types/molecule.advanced/blockchain.mol

@@ -0,0 +1,118 @@
+/* Basic Types */
+
+// The `UintN` is used to store a `N` bits unsigned integer
+// as a byte array in little endian.
+array Uint32 [byte; 4];
+array Uint64 [byte; 8];
+array Uint128 [byte; 16];
+array Byte32 [byte; 32];
+array Uint256 [byte; 32];
+
+vector Bytes <byte>;
+option BytesOpt (Bytes);
+vector BytesOptVec <BytesOpt>;
+vector BytesVec <Bytes>;
+vector Byte32Vec <Byte32>;
+
+/* Types for Chain */
+
+option ScriptOpt (Script);
+
+array ProposalShortId [byte; 10];
+
+vector UncleBlockVec <UncleBlock>;
+vector TransactionVec <Transaction>;
+vector ProposalShortIdVec <ProposalShortId>;
+vector CellDepVec <CellDep>;
+vector CellInputVec <CellInput>;
+vector CellOutputVec <CellOutput>;
+
+table Script {
+    codeHash:      Byte32,
+    hashType:      byte,
+    args:           Bytes,
+}
+
+struct OutPoint {
+    txHash:        Byte32,
+    index:          Uint32,
+}
+
+struct CellInput {
+    since:           Uint64,
+    previousOutput: OutPoint,
+}
+
+table CellOutput {
+    capacity:       Uint64,
+    lock:           Script,
+    type:          ScriptOpt,
+}
+
+struct CellDep {
+    outPoint:      OutPoint,
+    depType:       byte,
+}
+
+table RawTransaction {
+    version:        Uint32,
+    cellDeps:      CellDepVec,
+    headerDeps:    Byte32Vec,
+    inputs:         CellInputVec,
+    outputs:        CellOutputVec,
+    outputsData:   BytesVec,
+}
+
+table Transaction {
+    raw:            RawTransaction,
+    witnesses:      BytesVec,
+}
+
+struct RawHeader {
+    version:                Uint32,
+    compactTarget:         Uint32,
+    timestamp:              Uint64,
+    number:                 Uint64,
+    epoch:                  Uint64,
+    parentHash:            Byte32,
+    transactionsRoot:      Byte32,
+    proposalsHash:         Byte32,
+    extraHash:             Byte32,
+    dao:                    Byte32,
+}
+
+struct Header {
+    raw:                    RawHeader,
+    nonce:                  Uint128,
+}
+
+table UncleBlock {
+    header:                 Header,
+    proposals:              ProposalShortIdVec,
+}
+
+table Block {
+    header:                 Header,
+    uncles:                 UncleBlockVec,
+    transactions:           TransactionVec,
+    proposals:              ProposalShortIdVec,
+}
+
+table BlockV1 {
+    header:                 Header,
+    uncles:                 UncleBlockVec,
+    transactions:           TransactionVec,
+    proposals:              ProposalShortIdVec,
+    extension:              Bytes,
+}
+
+table CellbaseWitness {
+    lock:    Script,
+    message: Bytes,
+}
+
+table WitnessArgs {
+    lock:                   BytesOpt,          // Lock args
+    inputType:             BytesOpt,          // Type args for input
+    outputType:            BytesOpt,          // Type args for output
+}