@ckb-ccc/core 0.0.2-alpha.0

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@ckb-ccc/core",
+  "version": "0.0.2-alpha.0",
+  "description": "Common Chains Connector Core",
+  "author": "Hanssen0 <hanssen0@hanssen0.com>",
+  "license": "MIT",
+  "private": false,
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./barrel": "./dist/barrel.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint ."
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.1.1",
+    "eslint": "^9.1.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "prettier": "^3.2.5",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.7.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "bech32": "^2.0.0",
+    "buffer": "^6.0.3",
+    "immutable": "5.0.0-beta.5"
+  },
+  "gitHead": "c0cf1de7309204ba3121121bae68e2ef002f001f"
+}

package/src/address/address.ts

@@ -0,0 +1,9 @@
+import { Client } from "../client";
+import { Script } from "../types";
+
+export abstract class Address {
+  abstract getClient(): Promise<Client>;
+
+  abstract getAddress(): Promise<string>;
+  abstract getScript(): Promise<Script>;
+}

package/src/address/addressKnownScript.ts

@@ -0,0 +1,31 @@
+import { Client, KnownScript } from "../client";
+import { Script } from "../types";
+import { Address } from "./address";
+import { encodeScriptToAddress } from "./converter";
+
+export class AddressKnownScript extends Address {
+  constructor(
+    private readonly script: KnownScript,
+    private readonly args: Script["args"],
+    private readonly client: Client,
+  ) {
+    super();
+  }
+
+  async getClient(): Promise<Client> {
+    return this.client;
+  }
+
+  async getAddress(): Promise<string> {
+    const prefix = await (await this.getClient()).getAddressPrefix();
+
+    return encodeScriptToAddress(prefix, await this.getScript());
+  }
+
+  async getScript(): Promise<Script> {
+    return {
+      ...(await this.client.getKnownScript(this.script)),
+      args: this.args,
+    };
+  }
+}

package/src/address/addressPlain.ts

@@ -0,0 +1,27 @@
+import { Client } from "../client";
+import { Script } from "../types";
+import { Address } from "./address";
+import { encodeScriptToAddress } from "./converter";
+
+export class AddressPlain extends Address {
+  constructor(
+    private readonly script: Script,
+    private readonly client: Client,
+  ) {
+    super();
+  }
+
+  async getClient(): Promise<Client> {
+    return this.client;
+  }
+
+  async getAddress(): Promise<string> {
+    const prefix = await (await this.getClient()).getAddressPrefix();
+
+    return encodeScriptToAddress(prefix, this.script);
+  }
+
+  async getScript(): Promise<Script> {
+    return this.script;
+  }
+}

package/src/address/advanced.ts

@@ -0,0 +1,74 @@
+import { bech32, bech32m } from "bech32";
+import { Script } from "../types";
+import { Client } from "../client";
+import { ClientPublicTestnet, ClientPublicMainnet } from "../client";
+import { encodeScript } from "../codec";
+
+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): {
+  prefix: string;
+  format: AddressFormat;
+  body: number[];
+} {
+  // Try parse full format address
+  {
+    const { words, prefix } = bech32m.decode(address, BECH32_LIMIT);
+    const [formatType, ...body] = bech32m.fromWords(words);
+
+    if (formatType === AddressFormat.Full) {
+      return { prefix, format: AddressFormat.Full, body };
+    }
+  }
+
+  // Try parse legacy 2019 format address
+  {
+    const { prefix, words } = bech32.decode(address, BECH32_LIMIT);
+    const [formatType, ...body] = bech32.fromWords(words);
+    if (
+      [
+        AddressFormat.FullData,
+        AddressFormat.FullType,
+        AddressFormat.Short,
+      ].includes(formatType)
+    ) {
+      return { prefix, format: formatType, body };
+    }
+  }
+
+  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();
+  }
+}

package/src/address/converter.ts

@@ -0,0 +1,93 @@
+import { Client, KnownScript } from "../client";
+import { Script } from "../types";
+import { toHex, decodeScript, encodeScript } from "../codec";
+import { AddressPlain } from "./addressPlain";
+import {
+  AddressFormat,
+  BECH32_LIMIT,
+  getClientFromAddressPrefix,
+  parseAddress,
+} from "./advanced";
+import { AddressKnownScript } from "./addressKnownScript";
+import { Address } from "./address";
+import { bech32m } from "bech32";
+
+export function decodeAddressFromString(
+  address: string,
+  getClient?: (prefix: string) => Client | undefined,
+): Address {
+  const { prefix, format, body } = parseAddress(address);
+
+  const client = getClient?.(prefix) ?? getClientFromAddressPrefix(prefix);
+  if (!client) {
+    throw new Error(`Unknown address prefix ${prefix}`);
+  }
+
+  if (format === AddressFormat.Full) {
+    if (body.length < 32 + 1) {
+      throw new Error(`Invalid address without enough payload ${address}`);
+    }
+
+    return new AddressPlain(decodeScript(body), client);
+  }
+
+  if (format === AddressFormat.FullData) {
+    if (body.length < 32) {
+      throw new Error(`Invalid address without enough payload ${address}`);
+    }
+
+    return new AddressPlain(
+      {
+        codeHash: toHex(body.slice(0, 32)),
+        hashType: "data",
+        args: toHex(body.slice(32)),
+      },
+      client,
+    );
+  }
+
+  if (format === AddressFormat.FullType) {
+    if (body.length < 32) {
+      throw new Error(`Invalid address without enough payload ${address}`);
+    }
+
+    return new AddressPlain(
+      {
+        codeHash: toHex(body.slice(0, 32)),
+        hashType: "type",
+        args: toHex(body.slice(32)),
+      },
+      client,
+    );
+  }
+
+  // format === AddressFormat.Short
+  if (body.length !== 21) {
+    throw new Error(`Invalid address without enough payload ${address}`);
+  }
+  const script = [
+    KnownScript.Secp256k1Blake160,
+    KnownScript.Secp256k1Multisig,
+    KnownScript.AnyoneCanPay,
+  ][body[0]];
+  if (script === undefined) {
+    throw new Error(
+      `Invalid short format address with unknown script ${address}`,
+    );
+  }
+
+  return new AddressKnownScript(script, toHex(body.slice(1)), client);
+}
+
+export function decodeAddressFromScript(
+  script: Script,
+  client: Client,
+): AddressPlain {
+  return new AddressPlain(script, client);
+}
+
+export function encodeScriptToAddress(prefix: string, script: Script) {
+  const data = [AddressFormat.Full, ...encodeScript(script)];
+
+  return bech32m.encode(prefix, bech32m.toWords(data), BECH32_LIMIT);
+}

package/src/address/index.ts

@@ -0,0 +1,5 @@
+export * from "./address";
+export * from "./addressPlain";
+export * from "./addressKnownScript";
+export * as AdvancedAddress from "./advanced";
+export * from "./converter";

package/src/barrel.ts

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

package/src/ckb/index.ts

@@ -0,0 +1 @@
+export * from "./viewerCkbAddress";

package/src/ckb/viewerCkbAddress.ts

@@ -0,0 +1,34 @@
+import { encodeScriptToAddress } from "../address";
+import { Client } from "../client";
+import { Script } from "../types";
+import { Viewer } from "../viewer";
+import { TransactionSkeletonType } from "../types/lumos";
+
+export class ViewerCkbAddress extends Viewer {
+  constructor(
+    private readonly script: Script,
+    private readonly client: Client,
+  ) {
+    super();
+  }
+
+  async getClient(): Promise<Client> {
+    return this.client;
+  }
+
+  async getRecommendedAddress(): Promise<string> {
+    return (await this.getAddresses())[0];
+  }
+  async getAddresses(): Promise<string[]> {
+    return [
+      encodeScriptToAddress(await this.client.getAddressPrefix(), this.script),
+    ];
+  }
+
+  // Will be deprecated in the future
+  async completeLumosTransaction(
+    tx: TransactionSkeletonType,
+  ): Promise<TransactionSkeletonType> {
+    return tx;
+  }
+}

package/src/client/client.ts

@@ -0,0 +1,14 @@
+import { Script } from "../types";
+
+export enum KnownScript {
+  Secp256k1Blake160,
+  Secp256k1Multisig,
+  AnyoneCanPay,
+  JoyId,
+  OmniLock,
+}
+
+export abstract class Client {
+  abstract getAddressPrefix(): Promise<string>;
+  abstract getKnownScript(script: KnownScript): Promise<Omit<Script, "args">>;
+}

package/src/client/clientPublicMainnet.advanced.ts

@@ -0,0 +1,30 @@
+import { Script } from "../types";
+import { KnownScript } from "./client";
+
+export const MAINNET_SCRIPTS: Record<KnownScript, Omit<Script, "args">> = {
+  [KnownScript.Secp256k1Blake160]: {
+    codeHash:
+      "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
+    hashType: "type",
+  },
+  [KnownScript.Secp256k1Multisig]: {
+    codeHash:
+      "0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8",
+    hashType: "type",
+  },
+  [KnownScript.AnyoneCanPay]: {
+    codeHash:
+      "0xd369597ff47f29fbc0d47d2e3775370d1250b85140c670e4718af712983a2354",
+    hashType: "type",
+  },
+  [KnownScript.JoyId]: {
+    codeHash:
+      "0xd00c84f0ec8fd441c38bc3f87a371f547190f2fcff88e642bc5bf54b9e318323",
+    hashType: "type",
+  },
+  [KnownScript.OmniLock]: {
+    codeHash:
+      "0x9b819793a64463aed77c615d6cb226eea5487ccfc0783043a587254cda2b6f26",
+    hashType: "type",
+  },
+};

package/src/client/clientPublicMainnet.ts

@@ -0,0 +1,13 @@
+import { Script } from "../types";
+import { Client, KnownScript } from "./client";
+import { MAINNET_SCRIPTS } from "./clientPublicMainnet.advanced";
+
+export class ClientPublicMainnet extends Client {
+  async getAddressPrefix(): Promise<string> {
+    return "ckb";
+  }
+
+  async getKnownScript(script: KnownScript): Promise<Omit<Script, "args">> {
+    return MAINNET_SCRIPTS[script];
+  }
+}

package/src/client/clientPublicTestnet.advanced.ts

@@ -0,0 +1,30 @@
+import { Script } from "../types";
+import { KnownScript } from "./client";
+
+export const TESTNET_SCRIPTS: Record<KnownScript, Omit<Script, "args">> = {
+  [KnownScript.Secp256k1Blake160]: {
+    codeHash:
+      "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
+    hashType: "type",
+  },
+  [KnownScript.Secp256k1Multisig]: {
+    codeHash:
+      "0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8",
+    hashType: "type",
+  },
+  [KnownScript.AnyoneCanPay]: {
+    codeHash:
+      "0x3419a1c09eb2567f6552ee7a8ecffd64155cffe0f1796e6e61ec088d740c1356",
+    hashType: "type",
+  },
+  [KnownScript.JoyId]: {
+    codeHash:
+      "0xd23761b364210735c19c60561d213fb3beae2fd6172743719eff6920e020baac",
+    hashType: "type",
+  },
+  [KnownScript.OmniLock]: {
+    codeHash:
+      "0xf329effd1c475a2978453c8600e1eaf0bc2087ee093c3ee64cc96ec6847752cb",
+    hashType: "type",
+  },
+};

package/src/client/clientPublicTestnet.ts

@@ -0,0 +1,13 @@
+import { Script } from "../types";
+import { Client, KnownScript } from "./client";
+import { TESTNET_SCRIPTS } from "./clientPublicTestnet.advanced";
+
+export class ClientPublicTestnet extends Client {
+  async getAddressPrefix(): Promise<string> {
+    return "ckt";
+  }
+
+  async getKnownScript(script: KnownScript): Promise<Omit<Script, "args">> {
+    return TESTNET_SCRIPTS[script];
+  }
+}

package/src/client/index.ts

@@ -0,0 +1,10 @@
+export * from "./client";
+import * as clientPublicMainnetAdvanced from "./clientPublicMainnet.advanced";
+export * from "./clientPublicMainnet";
+import * as clientPublicTestnetAdvanced from "./clientPublicTestnet.advanced";
+export * from "./clientPublicTestnet";
+
+export const AdvancedClient = {
+  ...clientPublicMainnetAdvanced,
+  ...clientPublicTestnetAdvanced,
+};

package/src/codec/bytes.ts

@@ -0,0 +1,30 @@
+import { BytesLike, HexString } from "../types";
+import { Buffer } from "buffer";
+
+export function toBytes(bytes: BytesLike | string): Uint8Array {
+  if (bytes instanceof Uint8Array) {
+    return bytes;
+  }
+
+  if (Array.isArray(bytes)) {
+    if (bytes.some((v) => v < 0 || 0xff < v)) {
+      throw new Error(`Invalid bytes ${bytes}`);
+    }
+    return new Uint8Array(bytes);
+  }
+
+  if (bytes.length % 2 !== 0) {
+    throw new Error(`Invalid bytes with odd length ${bytes}`);
+  }
+
+  const strData = bytes.startsWith("0x") ? bytes.slice(2) : bytes;
+  const data = Buffer.from(strData, "hex");
+  if (data.length * 2 !== strData.length) {
+    throw new Error(`Invalid bytes ${bytes}`);
+  }
+  return data;
+}
+
+export function toHex(bytes: BytesLike | string): HexString {
+  return `0x${new Buffer(toBytes(bytes)).toString("hex")}`;
+}

package/src/codec/hashType.ts

@@ -0,0 +1,10 @@
+import { BytesLike, HashType, formatHashType, parseHashType } from "../types";
+import { toBytes } from "./bytes";
+
+export function encodeHashType(hashType: HashType): Uint8Array {
+  return toBytes([parseHashType(hashType)]);
+}
+
+export function decodeHashType(bytes: BytesLike): HashType {
+  return formatHashType(toBytes(bytes)[0]);
+}

package/src/codec/index.ts

@@ -0,0 +1,3 @@
+export * from "./bytes";
+export * from "./hashType";
+export * from "./script";

package/src/codec/script.ts

@@ -0,0 +1,21 @@
+import { BytesLike, Script } from "../types";
+import { toBytes, toHex } from "./bytes";
+import { decodeHashType, encodeHashType } from "./hashType";
+
+export function encodeScript(script: Script): Uint8Array {
+  return toBytes([
+    ...toBytes(script.codeHash),
+    ...encodeHashType(script.hashType),
+    ...toBytes(script.args),
+  ]);
+}
+
+export function decodeScript(bytes: BytesLike): Script {
+  const formattedBytes = toBytes(bytes);
+
+  return {
+    codeHash: toHex(formattedBytes.slice(0, 32)),
+    hashType: decodeHashType(formattedBytes.slice(32, 33)),
+    args: toHex(formattedBytes.slice(33)),
+  };
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./barrel";
+export * as ccc from "./barrel";

package/src/signer.ts

@@ -0,0 +1,20 @@
+import { TransactionSkeletonType } from "./types/lumos";
+import { Viewer } from "./viewer";
+import { BytesLike, HexString } from "./types";
+
+export abstract class Signer extends Viewer {
+  abstract signMessage(message: string | BytesLike): Promise<HexString>;
+
+  // Will be deprecated in the future
+  signLumosTransaction(
+    tx: TransactionSkeletonType,
+  ): Promise<TransactionSkeletonType> {
+    const completedTx = this.completeLumosTransaction(tx);
+    return this.signOnlyLumosTransaction(tx);
+  }
+
+  // Will be deprecated in the future
+  abstract signOnlyLumosTransaction(
+    tx: TransactionSkeletonType,
+  ): Promise<TransactionSkeletonType>;
+}

package/src/types/cell.ts

@@ -0,0 +1,5 @@
+export class Cell {
+  constructor() {}
+
+  static from() {}
+}

package/src/types/ckb.advanced.ts

@@ -0,0 +1,14 @@
+import { HashType } from "./ckb";
+
+export const HASHTYPE_TO_NUM: Record<HashType, number> = {
+  type: 0x01,
+  data: 0x00,
+  data1: 0x02,
+  data2: 0x04,
+};
+export const NUM_TO_HASHTYPE: Record<number, HashType> = {
+  0x01: "type",
+  0x00: "data",
+  0x02: "data1",
+  0x04: "data2",
+};

package/src/types/ckb.ts

@@ -0,0 +1,47 @@
+import { toHex } from "../codec";
+import { HASHTYPE_TO_NUM, NUM_TO_HASHTYPE } from "./ckb.advanced";
+import { BytesLike, HexString } from "./primitive";
+
+export type HashType = "type" | "data" | "data1" | "data2";
+export function parseHashType(hashType: HashType) {
+  const val = HASHTYPE_TO_NUM[hashType];
+
+  if (val === undefined) {
+    throw new Error(`Invalid hash type ${hashType}`);
+  }
+
+  return val;
+}
+export function formatHashType(hashType: number): HashType {
+  const val = NUM_TO_HASHTYPE[hashType];
+
+  if (val === undefined) {
+    throw new Error(`Invalid hash type ${hashType}`);
+  }
+
+  return val;
+}
+
+export class Script {
+  constructor(
+    public readonly codeHash: HexString,
+    public readonly hashType: HashType,
+    public readonly args: HexString,
+  ) {}
+
+  static from({
+    codeHash,
+    hashType,
+    args,
+  }: {
+    codeHash: BytesLike;
+    hashType: string;
+    args: BytesLike;
+  }): Script {
+    return {
+      codeHash: toHex(codeHash),
+      hashType: hashType as HashType,
+      args: toHex(args),
+    };
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,9 @@
+export * from "./cell";
+import * as ckbAdvanced from "./ckb.advanced";
+export * from "./ckb";
+export * as lumos from "./lumos";
+export * from "./primitive";
+
+export const AdvancedType = {
+  ...ckbAdvanced,
+}