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

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

@@ -0,0 +1,11 @@
+export * from "./generated";
+
+export function molOptional<T>(mol: {
+  hasValue: () => boolean;
+  value: () => T;
+}): T | undefined {
+  if (mol.hasValue()) {
+    return mol.value();
+  }
+  return;
+}

package/src/ckb/{types/script.advanced.ts → script.advanced.ts}

@@ -12,3 +12,4 @@ export const NUM_TO_HASH_TYPE: Record<number, HashType> = {
   0x02: "data1",
   0x04: "data2",
 };
+export const HASH_TYPES: string[] = Object.keys(HASH_TYPE_TO_NUM);

package/src/ckb/script.ts

@@ -0,0 +1,94 @@
+import { Bytes, BytesLike, bytesFrom } from "../bytes";
+import { Hex, hexFrom } from "../hex";
+import * as mol from "./molecule.advanced";
+import {
+  HASH_TYPES,
+  HASH_TYPE_TO_NUM,
+  NUM_TO_HASH_TYPE,
+} from "./script.advanced";
+
+export type HashTypeLike = string | number | bigint;
+export type HashType = "type" | "data" | "data1" | "data2";
+export function hashTypeFrom(val: HashTypeLike): HashType {
+  const hashType = (() => {
+    if (typeof val === "number") {
+      return NUM_TO_HASH_TYPE[val];
+    }
+
+    if (typeof val === "bigint") {
+      return NUM_TO_HASH_TYPE[Number(val)];
+    }
+
+    if (!HASH_TYPES.includes(val)) {
+      return;
+    }
+    return val as HashType;
+  })();
+  if (hashType === undefined) {
+    throw new Error(`Invalid hash type ${val}`);
+  }
+  return hashType;
+}
+export function hashTypeToBytes(hashType: HashType): Bytes {
+  return bytesFrom([HASH_TYPE_TO_NUM[hashType]]);
+}
+export function hashTypeFromBytes(bytes: BytesLike): HashType {
+  return NUM_TO_HASH_TYPE[bytesFrom(bytes)[0]];
+}
+
+export type ScriptLike = {
+  codeHash: BytesLike;
+  hashType: HashTypeLike;
+  args: BytesLike;
+};
+export class Script {
+  constructor(
+    public codeHash: Hex,
+    public hashType: HashType,
+    public args: Hex,
+  ) {}
+
+  static from(script: ScriptLike): Script {
+    if (script instanceof Script) {
+      return script;
+    }
+
+    return new Script(
+      hexFrom(script.codeHash),
+      hashTypeFrom(script.hashType),
+      hexFrom(script.args),
+    );
+  }
+
+  _toMolData() {
+    return {
+      codeHash: bytesFrom(this.codeHash),
+      hashType: hashTypeToBytes(this.hashType),
+      args: bytesFrom(this.args),
+    };
+  }
+
+  toBytes(): Bytes {
+    return bytesFrom(mol.SerializeScript(this._toMolData()));
+  }
+
+  static fromBytes(bytes: BytesLike | mol.Script): Script {
+    const view =
+      bytes instanceof mol.Script ? bytes : new mol.Script(bytesFrom(bytes));
+
+    return new Script(
+      hexFrom(view.getCodeHash().raw()),
+      hashTypeFromBytes([view.getHashType()]),
+      hexFrom(view.getArgs().raw()),
+    );
+  }
+
+  eq(val: ScriptLike): boolean {
+    const script = Script.from(val);
+    return (
+      this.codeHash === script.codeHash &&
+      this.args === script.args &&
+      this.hashType === script.hashType
+    );
+  }
+}

package/src/ckb/{types/transaction.advanced.ts → transaction.advanced.ts}

@@ -8,3 +8,4 @@ export const NUM_TO_DEP_TYPE: Record<number, DepType> = {
   0x00: "code",
   0x01: "depGroup",
 };
+export const DEP_TYPES: string[] = Object.keys(DEP_TYPE_TO_NUM);

package/src/ckb/transaction.ts

@@ -0,0 +1,357 @@
+import type { TransactionSkeletonType } from "@ckb-lumos/helpers";
+import { Bytes, BytesLike, bytesFrom } from "../bytes";
+import { Hasher, ckbHash } from "../hasher";
+import { Hex, HexLike, hexFrom } from "../hex";
+import { Num, NumLike, numFrom, numFromBytes, numToBytes } from "../num";
+import { apply } from "../utils";
+import * as mol from "./molecule.advanced";
+import { Script, ScriptLike } from "./script";
+import { DEP_TYPE_TO_NUM, NUM_TO_DEP_TYPE } from "./transaction.advanced";
+
+export type DepTypeLike = string | number | bigint;
+export type DepType = "depGroup" | "code";
+export function depTypeFrom(val: DepTypeLike): DepType {
+  const depType = (() => {
+    if (typeof val === "number") {
+      return NUM_TO_DEP_TYPE[val];
+    }
+
+    if (typeof val === "bigint") {
+      return NUM_TO_DEP_TYPE[Number(val)];
+    }
+
+    return val as DepType;
+  })();
+  if (depType === undefined) {
+    throw new Error(`Invalid dep type ${val}`);
+  }
+  return depType;
+}
+export function depTypeToBytes(depType: DepType): Bytes {
+  return bytesFrom([DEP_TYPE_TO_NUM[depType]]);
+}
+export function depTypeFromBytes(bytes: BytesLike): DepType {
+  return NUM_TO_DEP_TYPE[bytesFrom(bytes)[0]];
+}
+
+export type OutPointLike = {
+  txHash: HexLike;
+  index: NumLike;
+};
+export class OutPoint {
+  constructor(
+    public txHash: Hex,
+    public index: Num,
+  ) {}
+
+  static from(outPoint: OutPointLike): OutPoint {
+    if (outPoint instanceof OutPoint) {
+      return outPoint;
+    }
+    return new OutPoint(hexFrom(outPoint.txHash), numFrom(outPoint.index));
+  }
+
+  _toMolData() {
+    return {
+      txHash: bytesFrom(this.txHash),
+      index: numToBytes(this.index, 4),
+    };
+  }
+
+  encode(): Bytes {
+    return bytesFrom(mol.SerializeOutPoint(this._toMolData()));
+  }
+
+  static fromBytes(bytes: BytesLike | mol.OutPoint): OutPoint {
+    const view =
+      bytes instanceof mol.OutPoint
+        ? bytes
+        : new mol.OutPoint(bytesFrom(bytes));
+
+    return new OutPoint(
+      hexFrom(view.getTxHash().raw()),
+      numFromBytes(view.getIndex().raw()),
+    );
+  }
+}
+
+export type CellOutputLike = {
+  capacity: NumLike;
+  lock: ScriptLike;
+  type?: ScriptLike;
+};
+export class CellOutput {
+  constructor(
+    public capacity: Num,
+    public lock: Script,
+    public type?: Script,
+  ) {}
+
+  static from(cellOutput: CellOutputLike): CellOutput {
+    if (cellOutput instanceof CellOutput) {
+      return cellOutput;
+    }
+
+    return new CellOutput(
+      numFrom(cellOutput.capacity),
+      Script.from(cellOutput.lock),
+      apply(Script.from, cellOutput.type),
+    );
+  }
+
+  _toMolData() {
+    return {
+      capacity: numToBytes(this.capacity, 8),
+      lock: this.lock._toMolData(),
+      type: this.type?._toMolData(),
+    };
+  }
+
+  toBytes(): Bytes {
+    return bytesFrom(mol.SerializeCellOutput(this._toMolData()));
+  }
+
+  static fromBytes(bytes: BytesLike | mol.CellOutput): CellOutput {
+    const view =
+      bytes instanceof mol.CellOutput
+        ? bytes
+        : new mol.CellOutput(bytesFrom(bytes));
+
+    return new CellOutput(
+      numFromBytes(view.getCapacity().raw()),
+      Script.fromBytes(view.getLock()),
+      apply(Script.fromBytes, mol.molOptional(view.getType())),
+    );
+  }
+}
+
+export type CellInputLike = {
+  previousOutput: OutPointLike;
+  since: NumLike;
+  cellOutput?: CellOutputLike;
+  outputData?: HexLike;
+};
+export class CellInput {
+  constructor(
+    public previousOutput: OutPoint,
+    public since: Num,
+    public cellOutput?: CellOutput,
+    public outputData?: Hex,
+  ) {}
+
+  static from(cellInput: CellInputLike): CellInput {
+    if (cellInput instanceof CellInput) {
+      return cellInput;
+    }
+
+    return new CellInput(
+      OutPoint.from(cellInput.previousOutput),
+      numFrom(cellInput.since),
+      apply(CellOutput.from, cellInput.cellOutput),
+      apply(hexFrom, cellInput.outputData),
+    );
+  }
+
+  _toMolData() {
+    return {
+      previousOutput: this.previousOutput._toMolData(),
+      since: numToBytes(this.since, 8),
+    };
+  }
+
+  toBytes(): Bytes {
+    return bytesFrom(mol.SerializeCellInput(this._toMolData()));
+  }
+
+  static fromBytes(bytes: BytesLike | mol.CellInput): CellInput {
+    const view =
+      bytes instanceof mol.CellInput
+        ? bytes
+        : new mol.CellInput(bytesFrom(bytes));
+
+    return new CellInput(
+      OutPoint.fromBytes(view.getPreviousOutput()),
+      numFromBytes(view.getSince().raw()),
+    );
+  }
+}
+
+export type CellDepLike = {
+  outPoint: OutPointLike;
+  depType: DepTypeLike;
+};
+export class CellDep {
+  constructor(
+    public outPoint: OutPoint,
+    public depType: DepType,
+  ) {}
+
+  static from(cellDep: CellDepLike): CellDep {
+    if (cellDep instanceof CellDep) {
+      return cellDep;
+    }
+
+    return new CellDep(
+      OutPoint.from(cellDep.outPoint),
+      depTypeFrom(cellDep.depType),
+    );
+  }
+
+  _toMolData() {
+    return {
+      outPoint: this.outPoint._toMolData(),
+      depType: depTypeToBytes(this.depType),
+    };
+  }
+
+  toBytes(): Bytes {
+    return bytesFrom(mol.SerializeCellDep(this._toMolData()));
+  }
+
+  fromBytes(bytes: BytesLike | mol.CellDep): CellDep {
+    const view =
+      bytes instanceof mol.CellDep ? bytes : new mol.CellDep(bytesFrom(bytes));
+
+    return new CellDep(
+      OutPoint.fromBytes(view.getOutPoint()),
+      depTypeFromBytes([view.getDepType()]),
+    );
+  }
+}
+
+export type WitnessArgsLike = {
+  lock?: HexLike;
+  inputType?: HexLike;
+  outputType?: HexLike;
+};
+export class WitnessArgs {
+  constructor(
+    public lock?: Hex,
+    public inputType?: Hex,
+    public outputType?: Hex,
+  ) {}
+
+  static from(witnessArgs: WitnessArgsLike): WitnessArgs {
+    if (witnessArgs instanceof WitnessArgs) {
+      return witnessArgs;
+    }
+
+    return new WitnessArgs(
+      apply(hexFrom, witnessArgs.lock),
+      apply(hexFrom, witnessArgs.inputType),
+      apply(hexFrom, witnessArgs.outputType),
+    );
+  }
+
+  _toMolData() {
+    return {
+      lock: apply(bytesFrom, this.lock),
+      inputType: apply(bytesFrom, this.inputType),
+      outputType: apply(bytesFrom, this.outputType),
+    };
+  }
+
+  toBytes(): Bytes {
+    return bytesFrom(mol.SerializeWitnessArgs(this._toMolData()));
+  }
+
+  static fromBytes(bytes: BytesLike | mol.WitnessArgs): WitnessArgs {
+    const view =
+      bytes instanceof mol.WitnessArgs
+        ? bytes
+        : new mol.WitnessArgs(bytesFrom(bytes));
+
+    return new WitnessArgs(
+      apply(hexFrom, mol.molOptional(view.getLock())?.raw()),
+      apply(hexFrom, mol.molOptional(view.getInputType())?.raw()),
+      apply(hexFrom, mol.molOptional(view.getOutputType())?.raw()),
+    );
+  }
+}
+
+export type TransactionLike = {
+  version: NumLike;
+  cellDeps: CellDepLike[];
+  headerDeps: HexLike[];
+  inputs: CellInputLike[];
+  outputs: CellOutputLike[];
+  outputsData: HexLike[];
+  witnesses: HexLike[];
+};
+export class Transaction {
+  constructor(
+    public version: Num,
+    public cellDeps: CellDep[],
+    public headerDeps: Hex[],
+    public inputs: CellInput[],
+    public outputs: CellOutput[],
+    public outputsData: Hex[],
+    public witnesses: Hex[],
+  ) {}
+
+  static default(): Transaction {
+    return new Transaction(0n, [], [], [], [], [], []);
+  }
+
+  static from(tx: TransactionLike): Transaction {
+    if (tx instanceof Transaction) {
+      return tx;
+    }
+
+    return new Transaction(
+      numFrom(tx.version),
+      tx.cellDeps.map((cellDep) => CellDep.from(cellDep)),
+      tx.headerDeps.map(hexFrom),
+      tx.inputs.map((input) => CellInput.from(input)),
+      tx.outputs.map((output) => CellOutput.from(output)),
+      tx.outputsData.map(hexFrom),
+      tx.witnesses.map(hexFrom),
+    );
+  }
+
+  static fromLumosSkeleton(skeleton: TransactionSkeletonType): Transaction {
+    return Transaction.from({
+      version: 0n,
+      cellDeps: skeleton.cellDeps.toArray(),
+      headerDeps: skeleton.headerDeps.toArray(),
+      inputs: skeleton.inputs.toArray().map((input, i) => {
+        if (!input.outPoint) {
+          throw new Error("outPoint is required in input");
+        }
+
+        return CellInput.from({
+          previousOutput: input.outPoint,
+          since: skeleton.inputSinces.get(i, "0x0"),
+          cellOutput: input.cellOutput,
+          outputData: input.data,
+        });
+      }),
+      outputs: skeleton.outputs.toArray().map((output) => output.cellOutput),
+      outputsData: skeleton.outputs.toArray().map((output) => output.data),
+      witnesses: skeleton.witnesses.toArray(),
+    });
+  }
+
+  rawToBytes(): Bytes {
+    return bytesFrom(
+      mol.SerializeRawTransaction({
+        version: numToBytes(this.version, 4),
+        cellDeps: this.cellDeps.map((d) => d._toMolData()),
+        headerDeps: this.headerDeps.map(bytesFrom),
+        inputs: this.inputs.map((i) => i._toMolData()),
+        outputs: this.outputs.map((o) => o._toMolData()),
+        outputsData: this.outputsData.map(bytesFrom),
+      }),
+    );
+  }
+
+  hash() {
+    return ckbHash(this.rawToBytes());
+  }
+
+  static hashWitnessToHasher(witness: HexLike, hasher: Hasher) {
+    const raw = bytesFrom(hexFrom(witness));
+    hasher.update(numToBytes(raw.length, 8));
+    hasher.update(raw);
+  }
+}

package/src/client/client.ts

@@ -1,5 +1,5 @@
-import { Hex } from "../primitive";
-import { Script, Transaction } from "../ckb";
+import { ScriptLike, TransactionLike } from "../ckb";
+import { Hex } from "../hex";
 import { OutputsValidator } from "./clientTypes";
 
 export enum KnownScript {
@@ -11,11 +11,13 @@ export enum KnownScript {
 }
 
 export interface Client {
+  getUrl(): string;
+
   getAddressPrefix(): Promise<string>;
-  getKnownScript(script: KnownScript): Promise<Omit<Script, "args">>;
+  getKnownScript(script: KnownScript): Promise<Omit<ScriptLike, "args">>;
 
   sendTransaction(
-    transaction: Transaction,
+    transaction: TransactionLike,
     validator?: OutputsValidator,
   ): Promise<Hex>;
 }

package/src/client/clientPublicMainnet.advanced.ts

@@ -1,7 +1,7 @@
-import { Script } from "../ckb";
+import { ScriptLike } from "../ckb";
 import { KnownScript } from "./client";
 
-export const MAINNET_SCRIPTS: Record<KnownScript, Omit<Script, "args">> = {
+export const MAINNET_SCRIPTS: Record<KnownScript, Omit<ScriptLike, "args">> = {
   [KnownScript.Secp256k1Blake160]: {
     codeHash:
       "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",

package/src/client/clientPublicMainnet.ts

@@ -1,4 +1,4 @@
-import { Script } from "../ckb";
+import { ScriptLike } from "../ckb";
 import { KnownScript } from "./client";
 import { MAINNET_SCRIPTS } from "./clientPublicMainnet.advanced";
 import { ClientJsonRpc } from "./jsonRpc";
@@ -12,7 +12,7 @@ export class ClientPublicMainnet extends ClientJsonRpc {
     return "ckb";
   }
 
-  async getKnownScript(script: KnownScript): Promise<Omit<Script, "args">> {
+  async getKnownScript(script: KnownScript): Promise<Omit<ScriptLike, "args">> {
     return { ...MAINNET_SCRIPTS[script] };
   }
 }

package/src/client/clientPublicTestnet.advanced.ts

@@ -1,7 +1,7 @@
-import { Script } from "../ckb";
+import { ScriptLike } from "../ckb";
 import { KnownScript } from "./client";
 
-export const TESTNET_SCRIPTS: Record<KnownScript, Omit<Script, "args">> = {
+export const TESTNET_SCRIPTS: Record<KnownScript, Omit<ScriptLike, "args">> = {
   [KnownScript.Secp256k1Blake160]: {
     codeHash:
       "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",

package/src/client/clientPublicTestnet.ts

@@ -1,4 +1,4 @@
-import { Script } from "../ckb";
+import { ScriptLike } from "../ckb";
 import { KnownScript } from "./client";
 import { TESTNET_SCRIPTS } from "./clientPublicTestnet.advanced";
 import { ClientJsonRpc } from "./jsonRpc";
@@ -12,7 +12,7 @@ export class ClientPublicTestnet extends ClientJsonRpc {
     return "ckt";
   }
 
-  async getKnownScript(script: KnownScript): Promise<Omit<Script, "args">> {
+  async getKnownScript(script: KnownScript): Promise<Omit<ScriptLike, "args">> {
     return { ...TESTNET_SCRIPTS[script] };
   }
 }

package/src/client/clientTypes.ts

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

package/src/client/jsonRpc/advanced.ts

@@ -1,13 +1,16 @@
 import {
-  CellDep,
-  CellInput,
-  CellOutput,
-  DepType,
-  OutPoint,
-  Script,
-  Transaction,
+  CellDepLike,
+  CellInputLike,
+  CellOutputLike,
+  DepTypeLike,
+  OutPointLike,
+  ScriptLike,
+  TransactionLike,
+  depTypeFrom,
 } from "../../ckb";
-import { toHex } from "../../bytes";
+import { hexFrom } from "../../hex";
+import { numToHex } from "../../num";
+import { apply } from "../../utils";
 import type { Client } from "../client";
 
 export type JsonRpcPayload = {
@@ -27,52 +30,49 @@ export type JsonRpcMethod = {
 };
 
 export class JsonRpcTransformers {
-  static toDepType(depType: DepType) {
-    switch (depType) {
+  static toDepType(depType: DepTypeLike) {
+    switch (depTypeFrom(depType)) {
       case "code":
         return "code";
       case "depGroup":
         return "dep_group";
     }
   }
-  static toScript(script?: Script) {
-    if (!script) {
-      return null;
-    }
+  static toScript(script: ScriptLike) {
     return {
       code_hash: script.codeHash,
       hash_type: script.hashType,
       args: script.args,
     };
   }
-  static toOutPoint(outPoint: OutPoint) {
+  static toOutPoint(outPoint: OutPointLike) {
     return {
-      index: toHex(outPoint.index),
+      index: numToHex(outPoint.index),
       tx_hash: outPoint.txHash,
     };
   }
-  static toCellInput(cellInput: CellInput) {
+  static toCellInput(cellInput: CellInputLike) {
     return {
       previous_output: JsonRpcTransformers.toOutPoint(cellInput.previousOutput),
-      since: toHex(cellInput.since),
+      since: numToHex(cellInput.since),
     };
   }
-  static toCellOutput(cellOutput: CellOutput) {
+  static toCellOutput(cellOutput: CellOutputLike) {
     return {
-      capacity: toHex(cellOutput.capacity),
+      capacity: numToHex(cellOutput.capacity),
       lock: JsonRpcTransformers.toScript(cellOutput.lock),
-      type: JsonRpcTransformers.toScript(cellOutput.type),
+      type: apply(JsonRpcTransformers.toScript, cellOutput.type),
     };
   }
-  static toCellDep(cellDep: CellDep) {
+  static toCellDep(cellDep: CellDepLike) {
     return {
       out_point: JsonRpcTransformers.toOutPoint(cellDep.outPoint),
       dep_type: JsonRpcTransformers.toDepType(cellDep.depType),
     };
   }
-  static toTransaction(tx: Transaction) {
+  static toTransaction(tx: TransactionLike) {
     return {
-      version: toHex(tx.version),
+      version: numToHex(tx.version),
       cell_deps: tx.cellDeps.map((c) => JsonRpcTransformers.toCellDep(c)),
       header_deps: tx.headerDeps,
       inputs: tx.inputs.map((i) => JsonRpcTransformers.toCellInput(i)),
@@ -88,6 +88,6 @@ export const CkbRpcMethods: JsonRpcMethod[] = [
     method: "sendTransaction",
     rpcMethod: "send_transaction",
     inTransformers: [JsonRpcTransformers.toTransaction],
-    outTransformer: toHex,
+    outTransformer: hexFrom,
   },
 ];

package/src/client/jsonRpc/index.ts

@@ -1,8 +1,7 @@
-import type { Client } from "../client";
 import fetch from "cross-fetch";
+import type { Client } from "../client";
 import { CkbRpcMethods, JsonRpcMethod, JsonRpcPayload } from "./advanced";
 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export interface ClientJsonRpc extends Pick<Client, "sendTransaction"> {}
 
 async function transform(
@@ -15,7 +14,6 @@ async function transform(
   return value;
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export abstract class ClientJsonRpc implements Pick<Client, "sendTransaction"> {
   constructor(
     private readonly url: string,