@ckb-ccc/core 0.0.4-alpha.8 → 0.0.5-alpha.0

package/src/client/clientTypes.ts

@@ -1,4 +1,7 @@
-import { Transaction } from "../ckb";
+import { Cell, Script, ScriptLike, Transaction } from "../ckb";
+import { Hex, HexLike, hexFrom } from "../hex";
+import { Num, NumLike, numFrom } from "../num";
+import { apply } from "../utils";
 
 export type OutputsValidator = "passthrough" | "well_known_scripts_only";
 
@@ -11,4 +14,70 @@ export type TransactionStatus =
 export type ClientTransactionResponse = {
   transaction: Transaction;
   status: TransactionStatus;
+  blockNumber: Num;
+};
+
+export type ClientIndexerSearchKeyLike = {
+  script: ScriptLike;
+  scriptType: "lock" | "type";
+  scriptSearchMode?: "prefix" | "exact" | "partial";
+  filter?: {
+    script?: ScriptLike;
+    scriptLenRange?: [NumLike, NumLike];
+    outputData?: HexLike;
+    outputDataSearchMode?: "prefix" | "exact" | "partial";
+    outputDataLenRange?: [NumLike, NumLike];
+    outputCapacityRange?: [NumLike, NumLike];
+    blockRange?: [NumLike, NumLike];
+  };
+  withData?: boolean;
+};
+
+function rangeFrom([a, b]: [NumLike, NumLike]): [Num, Num] {
+  return [numFrom(a), numFrom(b)];
+}
+export class ClientIndexerSearchKey {
+  constructor(
+    public script: Script,
+    public scriptType: "lock" | "type",
+    public scriptSearchMode: "prefix" | "exact" | "partial" | undefined,
+    public filter:
+      | {
+          script?: Script;
+          scriptLenRange?: [Num, Num];
+          outputData?: Hex;
+          outputDataSearchMode?: "prefix" | "exact" | "partial";
+          outputDataLenRange?: [Num, Num];
+          outputCapacityRange?: [Num, Num];
+          blockRange?: [Num, Num];
+        }
+      | undefined,
+    public withData: boolean | undefined,
+  ) {}
+
+  static from(keyLike: ClientIndexerSearchKeyLike): ClientIndexerSearchKey {
+    return new ClientIndexerSearchKey(
+      Script.from(keyLike.script),
+      keyLike.scriptType,
+      keyLike.scriptSearchMode,
+      apply(
+        (filter: NonNullable<ClientIndexerSearchKeyLike["filter"]>) => ({
+          script: apply(Script.from, filter.script),
+          scriptLenRange: apply(rangeFrom, filter.scriptLenRange),
+          outputData: apply(hexFrom, filter.outputData),
+          outputDataSearchMode: filter.outputDataSearchMode,
+          outputDataLenRange: apply(rangeFrom, filter.outputDataLenRange),
+          outputCapacityRange: apply(rangeFrom, filter.outputCapacityRange),
+          blockRange: apply(rangeFrom, filter.blockRange),
+        }),
+        keyLike.filter,
+      ),
+      keyLike.withData,
+    );
+  }
+}
+
+export type ClientFindCellsResponse = {
+  lastCursor: string;
+  cells: Cell[];
 };

package/src/client/jsonRpc/index.ts

@@ -1,8 +1,14 @@
 import fetch from "cross-fetch";
 import { TransactionLike } from "../../ckb";
 import { Hex, HexLike, hexFrom } from "../../hex";
+import { NumLike, numToHex } from "../../num";
 import { Client } from "../client";
-import { ClientTransactionResponse, OutputsValidator } from "../clientTypes";
+import {
+  ClientFindCellsResponse,
+  ClientIndexerSearchKeyLike,
+  ClientTransactionResponse,
+  OutputsValidator,
+} from "../clientTypes";
 import { JsonRpcPayload, JsonRpcTransformers } from "./advanced";
 
 /**
@@ -89,6 +95,28 @@ export abstract class ClientJsonRpc extends Client {
     JsonRpcTransformers.transactionResponseTo,
   ) as (txHash: HexLike) => Promise<ClientTransactionResponse>;
 
+  /**
+   * find cells from node.
+   *
+   * @param txHash - The hash of the transaction.
+   * @returns The found cells.
+   */
+
+  findCellsPaged = this.buildSender(
+    "get_cells",
+    [
+      JsonRpcTransformers.indexerSearchKeyFrom,
+      (order) => order ?? "asc",
+      (limit) => numToHex(limit ?? 10),
+    ],
+    JsonRpcTransformers.findCellsResponseTo,
+  ) as (
+    key: ClientIndexerSearchKeyLike,
+    order?: "asc" | "desc",
+    limit?: NumLike,
+    after?: string,
+  ) => Promise<ClientFindCellsResponse>;
+
   /**
    * Builds a sender function for a JSON-RPC method.
    *
@@ -106,7 +134,15 @@ export abstract class ClientJsonRpc extends Client {
     return async (...req: unknown[]) => {
       const payload = ClientJsonRpc.buildPayload(
         rpcMethod,
-        await Promise.all(req.map((v, i) => transform(v, inTransformers[i]))),
+        await Promise.all(
+          req
+            .concat(
+              Array.from(
+                new Array(Math.max(inTransformers.length - req.length, 0)),
+              ),
+            )
+            .map((v, i) => transform(v, inTransformers[i])),
+        ),
       );
 
       return transform(await this.send(payload), outTransformer);

package/src/client/jsonRpc/transformers.ts

@@ -1,4 +1,5 @@
 import {
+  Cell,
   CellDep,
   CellDepLike,
   CellInput,
@@ -18,15 +19,23 @@ import {
   depTypeFrom,
   hashTypeFrom,
 } from "../../ckb";
-import { numToHex } from "../../num";
+import { Hex } from "../../hex";
+import { NumLike, numFrom, numToHex } from "../../num";
 import { apply } from "../../utils";
-import { ClientTransactionResponse, TransactionStatus } from "../clientTypes";
+import {
+  ClientFindCellsResponse,
+  ClientIndexerSearchKey,
+  ClientIndexerSearchKeyLike,
+  ClientTransactionResponse,
+  TransactionStatus,
+} from "../clientTypes";
 import {
   JsonRpcCellDep,
   JsonRpcCellInput,
   JsonRpcCellOutput,
   JsonRpcDepType,
   JsonRpcHashType,
+  JsonRpcIndexerSearchKey,
   JsonRpcOutPoint,
   JsonRpcScript,
   JsonRpcTransaction,
@@ -147,15 +156,75 @@ export class JsonRpcTransformers {
     });
   }
   static transactionResponseTo({
-    tx_status: { status },
+    tx_status: { status, block_number },
     transaction,
   }: {
-    tx_status: { status: TransactionStatus };
+    tx_status: { status: TransactionStatus; block_number: Hex };
     transaction: JsonRpcTransaction;
   }): ClientTransactionResponse {
     return {
       transaction: JsonRpcTransformers.transactionTo(transaction),
       status,
+      blockNumber: numFrom(block_number),
+    };
+  }
+  static rangeFrom([a, b]: [NumLike, NumLike]): [Hex, Hex] {
+    return [numToHex(a), numToHex(b)];
+  }
+  static indexerSearchKeyFrom(
+    keyLike: ClientIndexerSearchKeyLike,
+  ): JsonRpcIndexerSearchKey {
+    const key = ClientIndexerSearchKey.from(keyLike);
+    return {
+      script: JsonRpcTransformers.scriptFrom(key.script),
+      script_type: key.scriptType,
+      script_search_mode: key.scriptSearchMode,
+      filter: apply(
+        (filter: NonNullable<ClientIndexerSearchKey["filter"]>) => ({
+          script: apply(JsonRpcTransformers.scriptFrom, filter.script),
+          script_len_range: apply(
+            JsonRpcTransformers.rangeFrom,
+            filter.scriptLenRange,
+          ),
+          output_data: filter.outputData,
+          output_data_filter_mode: filter.outputDataSearchMode,
+          output_data_len_range: apply(
+            JsonRpcTransformers.rangeFrom,
+            filter.outputDataLenRange,
+          ),
+          output_capacity_range: apply(
+            JsonRpcTransformers.rangeFrom,
+            filter.outputCapacityRange,
+          ),
+          block_range: apply(JsonRpcTransformers.rangeFrom, filter.blockRange),
+        }),
+        key.filter,
+      ),
+      with_data: key.withData,
+    };
+  }
+  static findCellsResponseTo({
+    last_cursor,
+    objects,
+  }: {
+    last_cursor: string;
+    objects: {
+      block_number: Hex;
+      out_point: JsonRpcOutPoint;
+      output: JsonRpcCellOutput;
+      output_data: Hex;
+    }[];
+  }): ClientFindCellsResponse {
+    return {
+      lastCursor: last_cursor,
+      cells: objects.map((cell) =>
+        Cell.from({
+          blockNumber: cell.block_number,
+          outPoint: JsonRpcTransformers.outPointTo(cell.out_point),
+          cellOutput: JsonRpcTransformers.cellOutputTo(cell.output),
+          outputData: cell.output_data,
+        }),
+      ),
     };
   }
 }

package/src/client/jsonRpc/types.ts

@@ -46,3 +46,19 @@ export type JsonRpcTransaction = {
   outputs_data: Hex[];
   witnesses: Hex[];
 };
+
+export type JsonRpcIndexerSearchKey = {
+  script: JsonRpcScript;
+  script_type: "lock" | "type";
+  script_search_mode?: "prefix" | "exact" | "partial";
+  filter?: {
+    script?: JsonRpcScript;
+    script_len_range?: [Hex, Hex];
+    output_data?: Hex;
+    output_data_filter_mode?: "prefix" | "exact" | "partial";
+    output_data_len_range?: [Hex, Hex];
+    output_capacity_range?: [Hex, Hex];
+    block_range?: [Hex, Hex];
+  };
+  with_data?: boolean;
+};

package/src/fixedPoint/index.test.ts

@@ -0,0 +1,55 @@
+import { fixedPointFrom, fixedPointToString } from ".";
+
+describe("fixedPointToString", () => {
+  const cases: [bigint, string, number?][] = [
+    [0n, "0"],
+    [1n, "0.00000001"],
+    [100000000n, "1"],
+    [1000000000n, "10"],
+    [1010100000n, "10.101"],
+    [11n, "1.1", 1],
+    [0n, "0", 1],
+    [1n, "1", 0],
+    [0n, "0", 0],
+  ];
+
+  cases.forEach(([i, o, decimals]) =>
+    test(`${i} with ${decimals ?? "default"} decimals = "${o}"`, () => {
+      expect(fixedPointToString(i, decimals)).toBe(o);
+    }),
+  );
+});
+
+describe("fixedPointFrom string", () => {
+  const cases: [string, bigint, number?][] = [
+    ["0", 0n],
+    ["0.00000001", 1n],
+    ["1", 100000000n],
+    ["10", 1000000000n],
+    ["10.101", 1010100000n],
+    ["1.1", 11n, 1],
+    ["0", 0n, 1],
+    ["1", 1n, 0],
+    ["0", 0n, 0],
+  ];
+
+  cases.forEach(([i, o, decimals]) =>
+    test(`"${i}" = ${o} with ${decimals ?? "default"} decimals `, () => {
+      expect(fixedPointFrom(i, decimals)).toBe(o);
+    }),
+  );
+});
+
+describe("fixedPointFrom number", () => {
+  const cases: [number, bigint, number?][] = [
+    [0.00000001, 1n],
+    [10.101, 1010100000n],
+    [1.1, 11n, 1],
+  ];
+
+  cases.forEach(([i, o, decimals]) =>
+    test(`${i} = ${o} with ${decimals ?? "default"} decimals `, () => {
+      expect(fixedPointFrom(i, decimals)).toBe(o);
+    }),
+  );
+});

package/src/fixedPoint/index.ts

@@ -28,6 +28,10 @@ export type FixedPointLike = bigint | string | number;
 
 export function fixedPointToString(val: FixedPointLike, decimals = 8): string {
   const str = fixedPointFrom(val).toString();
+  if (decimals === 0) {
+    return str;
+  }
+
   const l = str.length <= decimals ? "0" : str.slice(0, -decimals);
   const r = str.slice(-decimals).padStart(decimals, "0").replace(/0*$/, "");
   if (r === "") {
@@ -57,7 +61,9 @@ export function fixedPointFrom(val: FixedPointLike, decimals = 8): FixedPoint {
     return val;
   }
 
-  const [l, r] = val.toString().split(".");
+  const [l, r] = (
+    typeof val === "number" ? val.toFixed(decimals) : val.toString()
+  ).split(".");
   const lVal = BigInt(l.padEnd(l.length + decimals, "0"));
   if (r === undefined) {
     return lVal;

package/src/signer/btc/signerBtc.ts

@@ -6,7 +6,6 @@ import { Transaction, TransactionLike, WitnessArgs } from "../../ckb";
 import { KnownScript } from "../../client";
 import { HexLike, hexFrom } from "../../hex";
 import { numToBytes } from "../../num";
-import { getSignHashInfo, prepareSighashAllWitness } from "../helpers";
 import { Signer } from "../signer";
 
 /**
@@ -64,7 +63,11 @@ export abstract class SignerBtc extends Signer {
    */
   async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
     const { script } = await this.getRecommendedAddressObj();
-    return prepareSighashAllWitness(txLike, script, 85, this.client);
+    return Transaction.from(txLike).prepareSighashAllWitness(
+      script,
+      85,
+      this.client,
+    );
   }
 
   /**
@@ -76,7 +79,7 @@ export abstract class SignerBtc extends Signer {
   async signOnlyTransaction(txLike: TransactionLike): Promise<Transaction> {
     const tx = Transaction.from(txLike);
     const { script } = await this.getRecommendedAddressObj();
-    const info = await getSignHashInfo(tx, script, this.client);
+    const info = await tx.getSignHashInfo(script, this.client);
     if (!info) {
       return tx;
     }

package/src/signer/btc/signerBtcPublicKeyReadonly.ts

@@ -26,6 +26,15 @@ export class SignerBtcPublicKeyReadonly extends SignerBtc {
     this.publicKey = hexFrom(publicKey);
   }
 
+  /**
+   * Construct a new signer with the client replaced.
+   *
+   * @returns A promise that resolves the new Signer.
+   */
+  async replaceClient(client: Client): Promise<SignerBtcPublicKeyReadonly> {
+    return new SignerBtcPublicKeyReadonly(client, this.account, this.publicKey);
+  }
+
   /**
    * Connects to the client. This implementation does nothing as the class is read-only.
    *
@@ -33,6 +42,15 @@ export class SignerBtcPublicKeyReadonly extends SignerBtc {
    */
   async connect(): Promise<void> {}
 
+  /**
+   * Check if the signer is connected.
+   *
+   * @returns A promise that resolves the connection status.
+   */
+  async isConnected(): Promise<boolean> {
+    return true;
+  }
+
   /**
    * Gets the Bitcoin account associated with the signer.
    *

package/src/signer/ckb/signerCkbScriptReadonly.ts

@@ -22,6 +22,15 @@ export class SignerCkbScriptReadonly extends Signer {
     this.script = Script.from(script);
   }
 
+  /**
+   * Construct a new signer with the client replaced.
+   *
+   * @returns A promise that resolves the new Signer.
+   */
+  async replaceClient(client: Client): Promise<SignerCkbScriptReadonly> {
+    return new SignerCkbScriptReadonly(client, this.script);
+  }
+
   /**
    * Connects to the client. This implementation does nothing as the class is read-only.
    *
@@ -29,6 +38,15 @@ export class SignerCkbScriptReadonly extends Signer {
    */
   async connect(): Promise<void> {}
 
+  /**
+   * Check if the signer is connected.
+   *
+   * @returns A promise that resolves the connection status.
+   */
+  async isConnected(): Promise<boolean> {
+    return true;
+  }
+
   /**
    * Gets the internal address for the script.
    *

package/src/signer/evm/signerEvm.ts

@@ -1,10 +1,9 @@
 import { Address } from "../../address";
-import { bytesConcat, bytesFrom } from "../../bytes";
-import { Transaction, TransactionLike, WitnessArgs } from "../../ckb";
+import { BytesLike, bytesConcat, bytesFrom } from "../../bytes";
+import { Script, Transaction, TransactionLike, WitnessArgs } from "../../ckb";
 import { KnownScript } from "../../client";
 import { hexFrom } from "../../hex";
 import { numToBytes } from "../../num";
-import { getSignHashInfo, prepareSighashAllWitness } from "../helpers";
 import { Signer } from "../signer";
 
 /**
@@ -36,14 +35,27 @@ export abstract class SignerEvm extends Signer {
   async getAddressObjs(): Promise<Address[]> {
     const account = await this.getEvmAccount();
     return [
-      await Address.fromKnownScript(
-        KnownScript.OmniLock,
-        hexFrom([0x12, ...bytesFrom(account), 0x00]),
-        this.client,
-      ),
+      await this._getOmniLockEvmAddressObj(account),
+      await this._getOmniLockOldEvmAddressObj(account),
     ];
   }
 
+  async _getOmniLockEvmAddressObj(account: string): Promise<Address> {
+    return Address.fromKnownScript(
+      KnownScript.OmniLock,
+      hexFrom([0x12, ...bytesFrom(account), 0x00]),
+      this.client,
+    );
+  }
+
+  async _getOmniLockOldEvmAddressObj(account: string): Promise<Address> {
+    return Address.fromKnownScript(
+      KnownScript.OmniLock,
+      hexFrom([0x1, ...bytesFrom(account), 0x00]),
+      this.client,
+    );
+  }
+
   /**
    * prepare a transaction before signing. This method is not implemented and should be overridden by subclasses.
    *
@@ -51,8 +63,15 @@ export abstract class SignerEvm extends Signer {
    * @returns A promise that resolves to the prepared Transaction object.
    */
   async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
-    const { script } = await this.getRecommendedAddressObj();
-    return prepareSighashAllWitness(txLike, script, 85, this.client);
+    const addresses = await this.getAddressObjs();
+
+    return addresses.reduce(
+      (txPromise, { script }) =>
+        txPromise.then((tx) =>
+          tx.prepareSighashAllWitness(script, 85, this.client),
+        ),
+      Promise.resolve(Transaction.from(txLike)),
+    );
   }
 
   /**
@@ -62,16 +81,39 @@ export abstract class SignerEvm extends Signer {
    * @returns A promise that resolves to a signed Transaction object.
    */
   async signOnlyTransaction(txLike: TransactionLike): Promise<Transaction> {
-    const tx = Transaction.from(txLike);
+    let tx = Transaction.from(txLike);
+
+    const account = await this.getEvmAccount();
+    const { script: evmScript } = await this._getOmniLockEvmAddressObj(account);
+    const { script: oldEvmScript } =
+      await this._getOmniLockOldEvmAddressObj(account);
+
+    tx = await this._signOmniLockScriptForTransaction(
+      tx,
+      evmScript,
+      (hash) => `CKB transaction: ${hash}`,
+    );
+    tx = await this._signOmniLockScriptForTransaction(
+      tx,
+      oldEvmScript,
+      (hash) => bytesFrom(hash),
+    );
+
+    return tx;
+  }
 
-    const { script } = await this.getRecommendedAddressObj();
-    const info = await getSignHashInfo(tx, script, this.client);
+  async _signOmniLockScriptForTransaction(
+    tx: Transaction,
+    script: Script,
+    messageTransformer: (hash: string) => BytesLike,
+  ): Promise<Transaction> {
+    const info = await tx.getSignHashInfo(script, this.client);
     if (!info) {
       return tx;
     }
 
     const signature = bytesFrom(
-      await this.signMessage(`CKB transaction: ${info.message}`),
+      await this.signMessage(messageTransformer(info.message)),
     );
     if (signature[signature.length - 1] >= 27) {
       signature[signature.length - 1] -= 27;

package/src/signer/evm/signerEvmAddressReadonly.ts

@@ -6,7 +6,7 @@ import { SignerEvm } from "./signerEvm";
  * A class extending SignerEvm that provides read-only access to an EVM address.
  * This class does not support signing operations.
  */
-export abstract class SignerEvmAddressReadonly extends SignerEvm {
+export class SignerEvmAddressReadonly extends SignerEvm {
   private readonly address: Hex;
 
   /**
@@ -21,6 +21,15 @@ export abstract class SignerEvmAddressReadonly extends SignerEvm {
     this.address = hexFrom(address);
   }
 
+  /**
+   * Construct a new signer with the client replaced.
+   *
+   * @returns A promise that resolves the new Signer.
+   */
+  async replaceClient(client: Client): Promise<SignerEvmAddressReadonly> {
+    return new SignerEvmAddressReadonly(client, this.address);
+  }
+
   /**
    * Connects to the client. This implementation does nothing as the class is read-only.
    *
@@ -34,6 +43,15 @@ export abstract class SignerEvmAddressReadonly extends SignerEvm {
 
   async connect(): Promise<void> {}
 
+  /**
+   * Check if the signer is connected.
+   *
+   * @returns A promise that resolves the connection status.
+   */
+  async isConnected(): Promise<boolean> {
+    return true;
+  }
+
   /**
    * Gets the EVM account associated with the signer.
    *

package/src/signer/index.ts

@@ -1,5 +1,4 @@
 export * from "./btc";
 export * from "./ckb";
 export * from "./evm";
-export * from "./helpers";
 export * from "./signer";

package/src/signer/signer.ts

@@ -9,15 +9,40 @@ import { Hex } from "../hex";
  * This class provides methods to connect, get addresses, and sign transactions.
  */
 export abstract class Signer {
-  constructor(public readonly client: Client) {}
+  constructor(protected client_: Client) {}
+
+  get client(): Client {
+    return this.client_;
+  }
 
   /**
-   * Connects to the client.
+   * Construct a new signer with the client replaced.
+   *
+   * @returns A promise that resolves the new Signer.
+   */
+  abstract replaceClient(client: Client): Promise<Signer>;
+
+  /**
+   * Connects to the signer.
    *
    * @returns A promise that resolves when the connection is complete.
    */
   abstract connect(): Promise<void>;
 
+  /**
+   * Disconnects to the signer.
+   *
+   * @returns A promise that resolves when disconnected.
+   */
+  async disconnect(): Promise<void> {}
+
+  /**
+   * Check if the signer is connected.
+   *
+   * @returns A promise that resolves the connection status.
+   */
+  abstract isConnected(): Promise<boolean>;
+
   /**
    * Gets the internal address associated with the signer.
    *
@@ -124,6 +149,7 @@ export abstract class Signer {
 export enum SignerType {
   EVM = "EVM",
   BTC = "BTC",
+  CKB = "CKB",
 }
 
 /**
@@ -131,6 +157,7 @@ export enum SignerType {
  */
 export class SignerInfo {
   constructor(
+    public name: string,
     public type: SignerType,
     public signer: Signer,
   ) {}
@@ -142,5 +169,4 @@ export class SignerInfo {
 export type Wallet = {
   name: string;
   icon: string;
-  signers: SignerInfo[];
 };