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

package/dist/viewer.d.ts

@@ -1,12 +0,0 @@
-import { Address } from "./address";
-import { Client } from "./client";
-export declare abstract class Viewer {
-    readonly client: Client;
-    constructor(client: Client);
-    abstract getInternalAddress(): Promise<string>;
-    abstract getAddressObjs(): Promise<Address[]>;
-    getRecommendedAddressObj(_preference?: unknown): Promise<Address>;
-    getRecommendedAddress(preference?: unknown): Promise<string>;
-    getAddresses(): Promise<string[]>;
-}
-//# sourceMappingURL=viewer.d.ts.map

package/dist/viewer.d.ts.map

@@ -1 +0,0 @@
-{"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,19 +0,0 @@
-"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/src/bytes.ts

@@ -1,127 +0,0 @@
-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/types/advanced.ts

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

package/src/ckb/types/index.ts

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

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

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

package/src/ckb/types/script.ts

@@ -1,70 +0,0 @@
-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.ts

@@ -1,366 +0,0 @@
-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/fixedPoint.ts

@@ -1,53 +0,0 @@
-export function composeFixedPoint(
-  val: undefined | null,
-  decimals?: number,
-): null;
-export function composeFixedPoint(val: bigint, decimals?: number): string;
-export function composeFixedPoint(
-  val: bigint | undefined | null,
-  decimals?: number,
-): string | null;
-export function composeFixedPoint(
-  val: bigint | undefined | null,
-  decimals = 8,
-): string | null {
-  if (val == null) {
-    return null;
-  }
-  const str = val.toString();
-  const l = str.length <= decimals ? "0" : str.slice(0, -decimals);
-  const r = str.slice(-decimals).padStart(decimals, "0").replace(/0*$/, "");
-  if (r === "") {
-    return l;
-  }
-
-  return `${l}.${r}`;
-}
-
-export function parseFixedPoint(ori: undefined | null, decimals?: number): null;
-export function parseFixedPoint(
-  ori: string | number,
-  decimals?: number,
-): bigint;
-export function parseFixedPoint(
-  ori: string | number | undefined | null,
-  decimals?: number,
-): bigint | null;
-export function parseFixedPoint(
-  ori: string | number | undefined | null,
-  decimals = 8,
-): bigint | null {
-  if (ori == null) {
-    return null;
-  }
-  const [l, r] = ori.toString().split(".");
-  const lVal = BigInt(l.padEnd(l.length + decimals, "0"));
-  if (r === undefined) {
-    return lVal;
-  }
-
-  return lVal + BigInt(r.slice(0, decimals).padEnd(decimals, "0"));
-}
-
-export const Zero = 0n;
-export const One = parseFixedPoint("1");

package/src/primitive.ts

@@ -1,8 +0,0 @@
-export type Hex = `0x${string}`;
-export type BytesLike =
-  | Hex
-  | Uint8Array
-  | ArrayBuffer
-  | number[];
-export type HexLike = BytesLike | number | string;
-export type NumberLike = string | Hex | number | bigint;

package/src/viewer.ts

@@ -1,22 +0,0 @@
-import { Address } from "./address";
-import { Client } from "./client";
-
-export abstract class Viewer {
-  constructor(public readonly client: Client) {}
-
-  abstract getInternalAddress(): Promise<string>;
-
-  abstract getAddressObjs(): Promise<Address[]>;
-  async getRecommendedAddressObj(_preference?: unknown): Promise<Address> {
-    return (await this.getAddressObjs())[0];
-  }
-
-  async getRecommendedAddress(preference?: unknown): Promise<string> {
-    return Address.toString(await this.getRecommendedAddressObj(preference));
-  }
-  async getAddresses(): Promise<string[]> {
-    return this.getAddressObjs().then((addresses) =>
-      addresses.map((address) => Address.toString(address)),
-    );
-  }
-}