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

package/dist/viewer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"viewer.d.ts","sourceRoot":"","sources":["../src/viewer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,8BAAsB,MAAM;IAC1B,QAAQ,CAAC,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAErC,QAAQ,CAAC,qBAAqB,CAAC,UAAU,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IACrE,QAAQ,CAAC,YAAY,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAG1C,QAAQ,CAAC,wBAAwB,CAC/B,EAAE,EAAE,uBAAuB,GAC1B,OAAO,CAAC,uBAAuB,CAAC;CACpC"}
+{"version":3,"file":"viewer.d.ts","sourceRoot":"","sources":["../src/viewer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,8BAAsB,MAAM;aACE,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM;IAE1C,QAAQ,CAAC,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC;IAE9C,QAAQ,CAAC,cAAc,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IACvC,wBAAwB,CAAC,WAAW,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAIjE,qBAAqB,CAAC,UAAU,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAG5D,YAAY,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;CAKxC"}

package/dist/viewer.js

@@ -1,6 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Viewer = void 0;
+const address_1 = require("./address");
 class Viewer {
+    constructor(client) {
+        this.client = client;
+    }
+    async getRecommendedAddressObj(_preference) {
+        return (await this.getAddressObjs())[0];
+    }
+    async getRecommendedAddress(preference) {
+        return address_1.Address.toString(await this.getRecommendedAddressObj(preference));
+    }
+    async getAddresses() {
+        return this.getAddressObjs().then((addresses) => addresses.map((address) => address_1.Address.toString(address)));
+    }
 }
 exports.Viewer = Viewer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckb-ccc/core",
-  "version": "0.0.2-alpha.0",
+  "version": "0.0.2-alpha.2",
   "description": "Common Chains Connector Core",
   "author": "Hanssen0 <hanssen0@hanssen0.com>",
   "license": "MIT",
@@ -8,18 +8,24 @@
   "main": "dist/index.js",
   "exports": {
     ".": "./dist/index.js",
-    "./barrel": "./dist/barrel.js"
+    "./barrel": "./dist/barrel.js",
+    "./advancedBarrel": "./dist/advancedBarrel.js",
+    "./advanced": "./dist/advanced.js"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "rimraf ./dist && tsc",
     "lint": "eslint ."
   },
   "devDependencies": {
+    "@ckb-lumos/helpers": "^0.22.2",
     "@eslint/js": "^9.1.1",
+    "@types/blake2b": "^2.1.3",
     "eslint": "^9.1.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.1.3",
     "prettier": "^3.2.5",
+    "rimraf": "^5.0.5",
+    "ts-essentials": "^9.4.2",
     "typescript": "^5.4.5",
     "typescript-eslint": "^7.7.0"
   },
@@ -27,9 +33,11 @@
     "access": "public"
   },
   "dependencies": {
+    "abort-controller": "^3.0.0",
     "bech32": "^2.0.0",
+    "blake2b": "^2.1.4",
     "buffer": "^6.0.3",
-    "immutable": "5.0.0-beta.5"
+    "cross-fetch": "^4.0.0"
   },
-  "gitHead": "c0cf1de7309204ba3121121bae68e2ef002f001f"
+  "gitHead": "dae8f0bcf3554125cebee4b9497c0045d7195a63"
 }

package/src/address/address.advanced.ts

@@ -0,0 +1,88 @@
+import { Client, KnownScript } from "../client";
+import { toHex } from "../bytes";
+import { AddressFormat } from "./advanced";
+import { type Address as AddressType } from "./index";
+import { decodeHashType } from "../ckb";
+
+export async function fromAddressPayload(
+  prefix: string,
+  format: AddressFormat,
+  payload: number[],
+  client: Client,
+): Promise<AddressType> {
+  if (format === AddressFormat.Full) {
+    if (payload.length < 32 + 1) {
+      throw new Error(
+        `Invalid full address without enough payload ${toHex(payload)}`,
+      );
+    }
+
+    return {
+      script: {
+        codeHash: toHex(payload.slice(0, 32)),
+        hashType: decodeHashType(payload.slice(32, 33)),
+        args: toHex(payload.slice(33)),
+      },
+      prefix,
+    };
+  }
+
+  if (format === AddressFormat.FullData) {
+    if (payload.length < 32) {
+      throw new Error(
+        `Invalid full data address without enough payload ${toHex(payload)}`,
+      );
+    }
+
+    return {
+      script: {
+        codeHash: toHex(payload.slice(0, 32)),
+        hashType: "data",
+        args: toHex(payload.slice(32)),
+      },
+      prefix,
+    };
+  }
+
+  if (format === AddressFormat.FullType) {
+    if (payload.length < 32) {
+      throw new Error(
+        `Invalid full type address without enough payload ${toHex(payload)}`,
+      );
+    }
+
+    return {
+      script: {
+        codeHash: toHex(payload.slice(0, 32)),
+        hashType: "type",
+        args: toHex(payload.slice(32)),
+      },
+      prefix,
+    };
+  }
+
+  // format === AddressFormat.Short
+  if (payload.length !== 21) {
+    throw new Error(
+      `Invalid short address without enough payload ${toHex(payload)}`,
+    );
+  }
+  const script = [
+    KnownScript.Secp256k1Blake160,
+    KnownScript.Secp256k1Multisig,
+    KnownScript.AnyoneCanPay,
+  ][payload[0]];
+  if (script === undefined) {
+    throw new Error(
+      `Invalid short address with unknown script ${toHex(payload)}`,
+    );
+  }
+
+  return {
+    script: {
+      ...(await client.getKnownScript(script)),
+      args: toHex(payload.slice(1)),
+    },
+    prefix,
+  };
+}

package/src/address/advanced.ts

@@ -1,52 +1,25 @@
 import { bech32, bech32m } from "bech32";
-import { Script } from "../types";
-import { Client } from "../client";
-import { ClientPublicTestnet, ClientPublicMainnet } from "../client";
-import { encodeScript } from "../codec";
+export * as Address from "./address.advanced";
 
-export const BECH32_LIMIT = 1023;
-
-export enum AddressFormat {
-  /**
-   * full version identifies the hashType
-   */
-  Full = 0x00,
-  /**
-   * @deprecated
-   * short version for locks with Known codeHash, deprecated
-   */
-  Short = 0x01,
-  /**
-   * @deprecated
-   * full version with hashType = "Data", deprecated
-   */
-  FullData = 0x02,
-  /**
-   * @deprecated
-   * full version with hashType = "Type", deprecated
-   */
-  FullType = 0x04,
-}
-
-export function parseAddress(address: string): {
+export function parseAddressToPayload(address: string): {
   prefix: string;
   format: AddressFormat;
-  body: number[];
+  payload: number[];
 } {
   // Try parse full format address
   {
     const { words, prefix } = bech32m.decode(address, BECH32_LIMIT);
-    const [formatType, ...body] = bech32m.fromWords(words);
+    const [formatType, ...payload] = bech32m.fromWords(words);
 
-    if (formatType === AddressFormat.Full) {
-      return { prefix, format: AddressFormat.Full, body };
+    if (formatType === (AddressFormat.Full as number)) {
+      return { prefix, format: AddressFormat.Full, payload };
     }
   }
 
   // Try parse legacy 2019 format address
   {
     const { prefix, words } = bech32.decode(address, BECH32_LIMIT);
-    const [formatType, ...body] = bech32.fromWords(words);
+    const [formatType, ...payload] = bech32.fromWords(words);
     if (
       [
         AddressFormat.FullData,
@@ -54,21 +27,33 @@ export function parseAddress(address: string): {
         AddressFormat.Short,
       ].includes(formatType)
     ) {
-      return { prefix, format: formatType, body };
+      return { prefix, format: formatType, payload };
     }
   }
 
   throw Error(`Unknown address format ${address}`);
 }
 
-export function decodeAddressInfo(format: AddressFormat, body: number[]) {}
-
-export function getClientFromAddressPrefix(prefix: string): Client | undefined {
-  if (prefix === "ckb") {
-    return new ClientPublicMainnet();
-  }
-
-  if (prefix === "ckt") {
-    return new ClientPublicTestnet();
-  }
+export enum AddressFormat {
+  /**
+   * full version identifies the hashType
+   */
+  Full = 0x00,
+  /**
+   * @deprecated
+   * short version for locks with Known codeHash, deprecated
+   */
+  Short = 0x01,
+  /**
+   * @deprecated
+   * full version with hashType = "Data", deprecated
+   */
+  FullData = 0x02,
+  /**
+   * @deprecated
+   * full version with hashType = "Type", deprecated
+   */
+  FullType = 0x04,
 }
+
+export const BECH32_LIMIT = 1023;

package/src/address/index.ts

@@ -1,5 +1,70 @@
-export * from "./address";
-export * from "./addressPlain";
-export * from "./addressKnownScript";
-export * as AdvancedAddress from "./advanced";
-export * from "./converter";
+import { DeepReadonly } from "ts-essentials";
+import { Client, KnownScript } from "../client";
+import { Script, encodeHashType } from "../ckb";
+import {
+  AddressFormat,
+  BECH32_LIMIT,
+  Address as AdvancedAddress,
+  parseAddressToPayload,
+} from "./advanced";
+import { bech32m } from "bech32";
+import { Hex } from "../primitive";
+import { concatBytes, toBytes } from "../bytes";
+
+export class Address {
+  constructor(
+    public script: Script,
+    public prefix: string,
+  ) {}
+
+  static async fromString(
+    address: string,
+    clients: Client | Record<string, Client>,
+  ): Promise<Address> {
+    const { prefix, format, payload } = parseAddressToPayload(address);
+
+    const client = (clients as Record<string, Client>)[prefix] ?? clients;
+    if (!client) {
+      throw new Error(`Unknown address prefix ${prefix}`);
+    }
+    const expectedPrefix = await client.getAddressPrefix();
+    if (expectedPrefix !== prefix) {
+      throw new Error(
+        `Unknown address prefix ${prefix}, expected ${expectedPrefix}`,
+      );
+    }
+
+    return AdvancedAddress.fromAddressPayload(prefix, format, payload, client);
+  }
+
+  static async fromScript(
+    script: DeepReadonly<Script>,
+    client: Client,
+  ): Promise<Address> {
+    return {
+      script: { ...script },
+      prefix: await client.getAddressPrefix(),
+    };
+  }
+
+  static async fromKnownScript(script: KnownScript, args: Hex, client: Client) {
+    return {
+      script: {
+        ...(await client.getKnownScript(script)),
+        args,
+      },
+      prefix: await client.getAddressPrefix(),
+    };
+  }
+
+  static toString(address: DeepReadonly<Address>): string {
+    const data = concatBytes(
+      [AddressFormat.Full],
+      toBytes(address.script.codeHash),
+      encodeHashType(address.script.hashType),
+      toBytes(address.script.args),
+    );
+
+    return bech32m.encode(address.prefix, bech32m.toWords(data), BECH32_LIMIT);
+  }
+}

package/src/advanced.ts

@@ -0,0 +1,2 @@
+export * from "./advancedBarrel";
+export * as cccA from "./advancedBarrel";

package/src/advancedBarrel.ts

@@ -0,0 +1,3 @@
+export * from "./address/advanced";
+export * from "./ckb/advanced";
+export * from "./client/advanced";

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
+}