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

package/src/ckb/types/molecule.advanced/index.ts

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

package/src/ckb/types/script.advanced.ts

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

package/src/ckb/types/script.ts

@@ -0,0 +1,70 @@
+import { DeepReadonly } from "ts-essentials";
+import { toBytes, toHex } from "../../bytes";
+import { BytesLike, Hex } from "../../primitive";
+import { HASH_TYPE_TO_NUM, NUM_TO_HASH_TYPE } from "./script.advanced";
+import * as mol from "./molecule.advanced";
+
+export type HashType = "type" | "data" | "data1" | "data2";
+
+export function encodeHashType(hashType: HashType): Uint8Array {
+  return toBytes([HASH_TYPE_TO_NUM[hashType]]);
+}
+
+export function decodeHashType(bytes: BytesLike): HashType {
+  return NUM_TO_HASH_TYPE[toBytes(bytes)[0]];
+}
+
+export class Script {
+  constructor(
+    public codeHash: Hex,
+    public hashType: HashType,
+    public args: Hex,
+  ) {}
+
+  static from({
+    codeHash,
+    hashType,
+    args,
+  }: {
+    codeHash: BytesLike;
+    hashType: string;
+    args: BytesLike;
+  }): Script {
+    return {
+      codeHash: toHex(codeHash),
+      hashType: hashType as HashType,
+      args: toHex(args),
+    };
+  }
+
+  static _toMolData(script: DeepReadonly<Script>) {
+    return {
+      codeHash: toBytes(script.codeHash),
+      hashType: encodeHashType(script.hashType),
+      args: toBytes(script.args),
+    };
+  }
+
+  static encode(script: DeepReadonly<Script>): Uint8Array {
+    return toBytes(mol.SerializeScript(Script._toMolData(script)));
+  }
+
+  static decode(bytes: BytesLike | mol.Script): Script {
+    const view =
+      bytes instanceof mol.Script ? bytes : new mol.Script(toBytes(bytes));
+
+    return {
+      codeHash: toHex(view.getCodeHash().raw()),
+      hashType: decodeHashType([view.getHashType()]),
+      args: toHex(view.getArgs().raw()),
+    };
+  }
+
+  static eq(a: Script, b: Script): boolean {
+    return (
+      a.codeHash === b.codeHash &&
+      a.args === b.args &&
+      a.hashType === b.hashType
+    );
+  }
+}

package/src/ckb/types/transaction.advanced.ts

@@ -0,0 +1,10 @@
+import { type DepType } from "./transaction";
+
+export const DEP_TYPE_TO_NUM: Record<DepType, number> = {
+  code: 0x00,
+  depGroup: 0x01,
+};
+export const NUM_TO_DEP_TYPE: Record<number, DepType> = {
+  0x00: "code",
+  0x01: "depGroup",
+};

package/src/ckb/types/transaction.ts

@@ -0,0 +1,366 @@
+import { HashType, Script } from "./script";
+import {
+  toBytes,
+  toBytesFromNumber,
+  toHex,
+  toHexFromHex,
+  toNumber,
+  toNumberFromBytes,
+} from "../../bytes";
+import { BytesLike, Hex, NumberLike } from "../../primitive";
+import type { TransactionSkeletonType } from "@ckb-lumos/helpers";
+import { DeepReadonly } from "ts-essentials";
+import * as mol from "./molecule.advanced";
+import { DEP_TYPE_TO_NUM, NUM_TO_DEP_TYPE } from "./transaction.advanced";
+import { Hasher, ckbHash } from "../hasher";
+
+export type DepType = "depGroup" | "code";
+
+export function encodeDepType(depType: DepType): Uint8Array {
+  return toBytes([DEP_TYPE_TO_NUM[depType]]);
+}
+
+export function decodeDepType(bytes: BytesLike): DepType {
+  return NUM_TO_DEP_TYPE[toBytes(bytes)[0]];
+}
+
+export class OutPoint {
+  constructor(
+    public txHash: Hex,
+    public index: string,
+  ) {}
+
+  static from({
+    txHash,
+    index,
+  }: {
+    txHash: BytesLike;
+    index: NumberLike;
+  }): OutPoint {
+    return new OutPoint(toHex(txHash), toNumber(index));
+  }
+
+  static _toMolData(outPoint: DeepReadonly<OutPoint>) {
+    return {
+      txHash: toBytes(outPoint.txHash),
+      index: toBytesFromNumber(outPoint.index, 4),
+    };
+  }
+
+  static encode(outPoint: DeepReadonly<OutPoint>): Uint8Array {
+    return toBytes(mol.SerializeOutPoint(OutPoint._toMolData(outPoint)));
+  }
+
+  static decode(bytes: BytesLike | mol.OutPoint): OutPoint {
+    const view =
+      bytes instanceof mol.OutPoint ? bytes : new mol.OutPoint(toBytes(bytes));
+    return {
+      txHash: toHex(view.getTxHash().raw()),
+      index: toNumberFromBytes(view.getIndex().raw()),
+    };
+  }
+}
+
+export class CellOutput {
+  constructor(
+    public capacity: string,
+    public lock: Script,
+    public type?: Script,
+  ) {}
+
+  static from({
+    capacity,
+    lock,
+    type,
+  }: {
+    capacity: NumberLike;
+    lock: Parameters<typeof Script.from>[0];
+    type?: Parameters<typeof Script.from>[0];
+  }): CellOutput {
+    return new CellOutput(
+      toNumber(capacity),
+      Script.from(lock),
+      type ? Script.from(type) : undefined,
+    );
+  }
+
+  static _toMolData(cellOutput: DeepReadonly<CellOutput>) {
+    return {
+      capacity: toBytesFromNumber(cellOutput.capacity, 8),
+      lock: Script._toMolData(cellOutput.lock),
+      type: cellOutput.type ? Script._toMolData(cellOutput.type) : undefined,
+    };
+  }
+
+  static encode(cellOutput: DeepReadonly<CellOutput>): Uint8Array {
+    return toBytes(mol.SerializeCellOutput(CellOutput._toMolData(cellOutput)));
+  }
+
+  static decode(bytes: BytesLike | mol.CellOutput): CellOutput {
+    const view =
+      bytes instanceof mol.CellOutput
+        ? bytes
+        : new mol.CellOutput(toBytes(bytes));
+    const type = view.getType();
+    return {
+      capacity: toNumberFromBytes(view.getCapacity().raw()),
+      lock: Script.decode(view.getLock()),
+      type: type.hasValue() ? Script.decode(type.value()) : undefined,
+    };
+  }
+}
+
+export class CellInput {
+  constructor(
+    public previousOutput: OutPoint,
+    public since: string,
+    public cellOutput?: CellOutput,
+    public outputData?: Hex,
+  ) {}
+
+  static from({
+    previousOutput,
+    since,
+    cellOutput,
+    outputData,
+  }: {
+    previousOutput: Parameters<typeof OutPoint.from>[0];
+    since: NumberLike;
+    cellOutput?: Parameters<typeof CellOutput.from>[0];
+    outputData?: BytesLike;
+  }): CellInput {
+    return new CellInput(
+      OutPoint.from(previousOutput),
+      toNumber(since),
+      cellOutput ? CellOutput.from(cellOutput) : undefined,
+      outputData ? toHex(outputData) : undefined,
+    );
+  }
+
+  static _toMolData(cellInput: DeepReadonly<CellInput>) {
+    return {
+      previousOutput: OutPoint._toMolData(cellInput.previousOutput),
+      since: toBytesFromNumber(cellInput.since, 8),
+    };
+  }
+
+  static encode(cellInput: DeepReadonly<CellInput>): Uint8Array {
+    return toBytes(mol.SerializeCellInput(CellInput._toMolData(cellInput)));
+  }
+
+  static decode(bytes: BytesLike | mol.CellInput): CellInput {
+    const view =
+      bytes instanceof mol.CellInput
+        ? bytes
+        : new mol.CellInput(toBytes(bytes));
+    return {
+      previousOutput: OutPoint.decode(view.getPreviousOutput()),
+      since: toNumberFromBytes(view.getSince().raw()),
+    };
+  }
+}
+
+export class CellDep {
+  constructor(
+    public outPoint: OutPoint,
+    public depType: DepType,
+  ) {}
+
+  static from({
+    outPoint,
+    depType,
+  }: {
+    outPoint: Parameters<typeof OutPoint.from>[0];
+    depType: DepType;
+  }): CellDep {
+    return new CellDep(OutPoint.from(outPoint), depType);
+  }
+
+  static _toMolData(cellDep: DeepReadonly<CellDep>) {
+    return {
+      outPoint: OutPoint._toMolData(cellDep.outPoint),
+      depType: encodeDepType(cellDep.depType),
+    };
+  }
+
+  static encode(cellDep: DeepReadonly<CellDep>): Uint8Array {
+    return toBytes(mol.SerializeCellDep(CellDep._toMolData(cellDep)));
+  }
+
+  static decode(bytes: BytesLike | mol.CellDep): CellDep {
+    const view =
+      bytes instanceof mol.CellDep ? bytes : new mol.CellDep(toBytes(bytes));
+    return {
+      outPoint: OutPoint.decode(view.getOutPoint()),
+      depType: decodeDepType([view.getDepType()]),
+    };
+  }
+}
+
+export class WitnessArgs {
+  constructor(
+    public lock?: Hex,
+    public inputType?: Hex,
+    public outputType?: Hex,
+  ) {}
+
+  static from({
+    lock,
+    inputType,
+    outputType,
+  }: {
+    lock?: BytesLike;
+    inputType?: BytesLike;
+    outputType?: BytesLike;
+  }): WitnessArgs {
+    return new WitnessArgs(
+      lock ? toHex(lock) : undefined,
+      inputType ? toHex(inputType) : undefined,
+      outputType ? toHex(outputType) : undefined,
+    );
+  }
+
+  static _toMolData(witnessArgs: DeepReadonly<WitnessArgs>) {
+    return {
+      lock: witnessArgs.lock ? toBytes(witnessArgs.lock) : undefined,
+      inputType: witnessArgs.inputType
+        ? toBytes(witnessArgs.inputType)
+        : undefined,
+      outputType: witnessArgs.outputType
+        ? toBytes(witnessArgs.outputType)
+        : undefined,
+    };
+  }
+
+  static encode(witnessArgs: DeepReadonly<WitnessArgs>): Uint8Array {
+    return toBytes(
+      mol.SerializeWitnessArgs(WitnessArgs._toMolData(witnessArgs)),
+    );
+  }
+
+  static decode(bytes: BytesLike | mol.WitnessArgs): WitnessArgs {
+    const view =
+      bytes instanceof mol.WitnessArgs
+        ? bytes
+        : new mol.WitnessArgs(toBytes(bytes));
+    const lock = view.getLock();
+    const inputType = view.getInputType();
+    const outputType = view.getOutputType();
+    return {
+      lock: lock.hasValue() ? toHex(lock.value().raw()) : undefined,
+      inputType: inputType.hasValue()
+        ? toHex(inputType.value().raw())
+        : undefined,
+      outputType: outputType.hasValue()
+        ? toHex(outputType.value().raw())
+        : undefined,
+    };
+  }
+}
+
+export class Transaction {
+  constructor(
+    public version: string,
+    public cellDeps: CellDep[],
+    public headerDeps: Hex[],
+    public inputs: CellInput[],
+    public outputs: CellOutput[],
+    public outputsData: Hex[],
+    public witnesses: Hex[],
+  ) {}
+
+  static default(): Transaction {
+    return new Transaction("0", [], [], [], [], [], []);
+  }
+
+  private static fromLumosOutPoint(outPoint: {
+    index: string;
+    txHash: string;
+  }) {
+    return {
+      ...outPoint,
+      txHash: toHexFromHex(outPoint.txHash),
+    };
+  }
+
+  private static fromLumosScript(script: {
+    codeHash: string;
+    hashType: HashType;
+    args: string;
+  }) {
+    return {
+      codeHash: toHexFromHex(script.codeHash),
+      args: toHexFromHex(script.args),
+      hashType: script.hashType,
+    };
+  }
+
+  private static fromLumosOutput(output: {
+    lock: Parameters<typeof Transaction.fromLumosScript>[0];
+    type?: Parameters<typeof Transaction.fromLumosScript>[0];
+    capacity: string;
+  }) {
+    return {
+      lock: Transaction.fromLumosScript(output.lock),
+      type: output.type ? Transaction.fromLumosScript(output.type) : undefined,
+      capacity: toNumber(output.capacity),
+    };
+  }
+
+  static fromLumosSkeleton(skeleton: TransactionSkeletonType): Transaction {
+    return new Transaction(
+      "0",
+      skeleton.cellDeps.toArray().map((cellDep) =>
+        CellDep.from({
+          ...cellDep,
+          outPoint: Transaction.fromLumosOutPoint(cellDep.outPoint),
+        }),
+      ),
+      skeleton.headerDeps.toArray().map(toHex),
+      skeleton.inputs.toArray().map((input, i) => {
+        if (!input.outPoint) {
+          throw new Error("outPoint is required in input");
+        }
+
+        return CellInput.from({
+          previousOutput: Transaction.fromLumosOutPoint(input.outPoint),
+          since: skeleton.inputSinces.get(i, "0x00"),
+          cellOutput: Transaction.fromLumosOutput(input.cellOutput),
+          outputData: toHexFromHex(input.data),
+        });
+      }),
+      skeleton.outputs
+        .toArray()
+        .map((output) =>
+          CellOutput.from(Transaction.fromLumosOutput(output.cellOutput)),
+        ),
+      skeleton.outputs.toArray().map((output) => toHex(output.data)),
+      skeleton.witnesses.toArray().map(toHex),
+    );
+  }
+
+  static encodeRaw(
+    transaction: Readonly<Omit<Transaction, "witnesses">>,
+  ): Uint8Array {
+    return toBytes(
+      mol.SerializeRawTransaction({
+        version: toBytesFromNumber(transaction.version, 4),
+        cellDeps: transaction.cellDeps.map(CellDep._toMolData),
+        headerDeps: transaction.headerDeps.map(toBytes),
+        inputs: transaction.inputs.map(CellInput._toMolData),
+        outputs: transaction.outputs.map(CellOutput._toMolData),
+        outputsData: transaction.outputsData.map(toBytes),
+      }),
+    );
+  }
+
+  static hashRaw(transaction: Omit<Transaction, "witnesses">) {
+    return ckbHash(Transaction.encodeRaw(transaction));
+  }
+
+  static hashWitnessToHasher(witness: Hex, hasher: Hasher) {
+    const raw = toBytes(witness);
+    hasher.update(toBytesFromNumber(raw.length, 8))
+    hasher.update(raw);
+  }
+}

package/src/ckb/viewerCkbScript.ts

@@ -0,0 +1,21 @@
+import { Client } from "../client";
+import { Script } from "./types";
+import { Viewer } from "../viewer";
+import { Address } from "../address";
+
+export class ViewerCkbScript extends Viewer {
+  constructor(
+    private readonly script: Script,
+    client: Client,
+  ) {
+    super(client);
+  }
+
+  async getInternalAddress(): Promise<string> {
+    return this.getRecommendedAddress();
+  }
+
+  async getAddressObjs(): Promise<Address[]> {
+    return [await Address.fromScript(this.script, this.client)];
+  }
+}

package/src/client/advanced.ts

@@ -0,0 +1,2 @@
+export * from "./clientPublicMainnet.advanced";
+export * from "./clientPublicTestnet.advanced";

package/src/client/client.ts

@@ -1,4 +1,6 @@
-import { Script } from "../types";
+import { Hex } from "../primitive";
+import { Script, Transaction } from "../ckb";
+import { OutputsValidator } from "./clientTypes";
 
 export enum KnownScript {
   Secp256k1Blake160,
@@ -8,7 +10,12 @@ export enum KnownScript {
   OmniLock,
 }
 
-export abstract class Client {
-  abstract getAddressPrefix(): Promise<string>;
-  abstract getKnownScript(script: KnownScript): Promise<Omit<Script, "args">>;
+export interface Client {
+  getAddressPrefix(): Promise<string>;
+  getKnownScript(script: KnownScript): Promise<Omit<Script, "args">>;
+
+  sendTransaction(
+    transaction: Transaction,
+    validator?: OutputsValidator,
+  ): Promise<Hex>;
 }

package/src/client/clientPublicMainnet.advanced.ts

@@ -1,4 +1,4 @@
-import { Script } from "../types";
+import { Script } from "../ckb";
 import { KnownScript } from "./client";
 
 export const MAINNET_SCRIPTS: Record<KnownScript, Omit<Script, "args">> = {

package/src/client/clientPublicMainnet.ts

@@ -1,13 +1,18 @@
-import { Script } from "../types";
-import { Client, KnownScript } from "./client";
+import { Script } from "../ckb";
+import { KnownScript } from "./client";
 import { MAINNET_SCRIPTS } from "./clientPublicMainnet.advanced";
+import { ClientJsonRpc } from "./jsonRpc";
+
+export class ClientPublicMainnet extends ClientJsonRpc {
+  constructor(timeout?: number) {
+    super("https://mainnet.ckbapp.dev/", timeout);
+  }
 
-export class ClientPublicMainnet extends Client {
   async getAddressPrefix(): Promise<string> {
     return "ckb";
   }
 
   async getKnownScript(script: KnownScript): Promise<Omit<Script, "args">> {
-    return MAINNET_SCRIPTS[script];
+    return { ...MAINNET_SCRIPTS[script] };
   }
 }

package/src/client/clientPublicTestnet.advanced.ts

@@ -1,4 +1,4 @@
-import { Script } from "../types";
+import { Script } from "../ckb";
 import { KnownScript } from "./client";
 
 export const TESTNET_SCRIPTS: Record<KnownScript, Omit<Script, "args">> = {

package/src/client/clientPublicTestnet.ts

@@ -1,13 +1,18 @@
-import { Script } from "../types";
-import { Client, KnownScript } from "./client";
+import { Script } from "../ckb";
+import { KnownScript } from "./client";
 import { TESTNET_SCRIPTS } from "./clientPublicTestnet.advanced";
+import { ClientJsonRpc } from "./jsonRpc";
+
+export class ClientPublicTestnet extends ClientJsonRpc {
+  constructor(timeout?: number) {
+    super("https://testnet.ckbapp.dev/", timeout);
+  }
 
-export class ClientPublicTestnet extends Client {
   async getAddressPrefix(): Promise<string> {
     return "ckt";
   }
 
   async getKnownScript(script: KnownScript): Promise<Omit<Script, "args">> {
-    return TESTNET_SCRIPTS[script];
+    return { ...TESTNET_SCRIPTS[script] };
   }
 }

package/src/client/clientTypes.ts

@@ -0,0 +1 @@
+export type OutputsValidator = "passthrough" | "well_known_scripts_only";

package/src/client/index.ts

@@ -1,10 +1,4 @@
 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,
-};
+export * from "./clientTypes";

package/src/client/jsonRpc/advanced.ts

@@ -0,0 +1,93 @@
+import {
+  CellDep,
+  CellInput,
+  CellOutput,
+  DepType,
+  OutPoint,
+  Script,
+  Transaction,
+} from "../../ckb";
+import { toHex } from "../../bytes";
+import type { Client } from "../client";
+
+export type JsonRpcPayload = {
+  id: number;
+  jsonrpc: "2.0";
+  method: string;
+  params: unknown[] | Record<string, unknown>;
+};
+
+export type JsonRpcMethod = {
+  method: keyof Client;
+  rpcMethod: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  inTransformers: (((_: any) => unknown) | undefined)[];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  outTransformer?: (_: any) => unknown;
+};
+
+export class JsonRpcTransformers {
+  static toDepType(depType: DepType) {
+    switch (depType) {
+      case "code":
+        return "code";
+      case "depGroup":
+        return "dep_group";
+    }
+  }
+  static toScript(script?: Script) {
+    if (!script) {
+      return null;
+    }
+    return {
+      code_hash: script.codeHash,
+      hash_type: script.hashType,
+      args: script.args,
+    };
+  }
+  static toOutPoint(outPoint: OutPoint) {
+    return {
+      index: toHex(outPoint.index),
+      tx_hash: outPoint.txHash,
+    };
+  }
+  static toCellInput(cellInput: CellInput) {
+    return {
+      previous_output: JsonRpcTransformers.toOutPoint(cellInput.previousOutput),
+      since: toHex(cellInput.since),
+    };
+  }
+  static toCellOutput(cellOutput: CellOutput) {
+    return {
+      capacity: toHex(cellOutput.capacity),
+      lock: JsonRpcTransformers.toScript(cellOutput.lock),
+      type: JsonRpcTransformers.toScript(cellOutput.type),
+    };
+  }
+  static toCellDep(cellDep: CellDep) {
+    return {
+      out_point: JsonRpcTransformers.toOutPoint(cellDep.outPoint),
+      dep_type: JsonRpcTransformers.toDepType(cellDep.depType),
+    };
+  }
+  static toTransaction(tx: Transaction) {
+    return {
+      version: toHex(tx.version),
+      cell_deps: tx.cellDeps.map((c) => JsonRpcTransformers.toCellDep(c)),
+      header_deps: tx.headerDeps,
+      inputs: tx.inputs.map((i) => JsonRpcTransformers.toCellInput(i)),
+      outputs: tx.outputs.map((o) => JsonRpcTransformers.toCellOutput(o)),
+      outputs_data: tx.outputsData,
+      witnesses: tx.witnesses,
+    };
+  }
+}
+
+export const CkbRpcMethods: JsonRpcMethod[] = [
+  {
+    method: "sendTransaction",
+    rpcMethod: "send_transaction",
+    inTransformers: [JsonRpcTransformers.toTransaction],
+    outTransformer: toHex,
+  },
+];