@ckb-ccc/core 0.0.9-alpha.1 → 0.0.10-alpha.4

package/src/ckb/transaction.ts

@@ -2,7 +2,7 @@ import type { TransactionSkeletonType } from "@ckb-lumos/helpers";
 import { ClientCollectableSearchKeyFilterLike } from "../advancedBarrel";
 import { Bytes, BytesLike, bytesFrom } from "../bytes";
 import { CellDepInfoLike, Client, KnownScript } from "../client";
-import { Zero, fixedPointFrom } from "../fixedPoint";
+import { Zero, fixedPointFrom, fixedPointToString } from "../fixedPoint";
 import { Hasher, hashCkb } from "../hasher";
 import { Hex, HexLike, hexFrom } from "../hex";
 import {
@@ -210,7 +210,7 @@ export class OutPoint {
 export type CellOutputLike = {
   capacity: NumLike;
   lock: ScriptLike;
-  type?: ScriptLike;
+  type?: ScriptLike | null;
 };
 export class CellOutput {
   /**
@@ -387,9 +387,9 @@ export class Cell {
 
 export type CellInputLike = {
   previousOutput: OutPointLike;
-  since?: NumLike;
-  cellOutput?: CellOutputLike;
-  outputData?: HexLike;
+  since?: NumLike | null;
+  cellOutput?: CellOutputLike | null;
+  outputData?: HexLike | null;
 };
 export class CellInput {
   /**
@@ -659,9 +659,9 @@ export class CellDep {
 }
 
 export type WitnessArgsLike = {
-  lock?: HexLike;
-  inputType?: HexLike;
-  outputType?: HexLike;
+  lock?: HexLike | null;
+  inputType?: HexLike | null;
+  outputType?: HexLike | null;
 };
 export class WitnessArgs {
   /**
@@ -771,14 +771,16 @@ export function udtBalanceFrom(dataLike: BytesLike) {
 }
 
 export type TransactionLike = {
-  version?: NumLike;
-  cellDeps?: CellDepLike[];
-  headerDeps?: HexLike[];
-  inputs?: CellInputLike[];
-  outputs?: (Omit<CellOutputLike, "capacity"> &
-    Partial<Pick<CellOutputLike, "capacity">>)[];
-  outputsData?: HexLike[];
-  witnesses?: HexLike[];
+  version?: NumLike | null;
+  cellDeps?: CellDepLike[] | null;
+  headerDeps?: HexLike[] | null;
+  inputs?: CellInputLike[] | null;
+  outputs?:
+    | (Omit<CellOutputLike, "capacity"> &
+        Partial<Pick<CellOutputLike, "capacity">>)[]
+    | null;
+  outputsData?: HexLike[] | null;
+  witnesses?: HexLike[] | null;
 };
 export class Transaction {
   /**
@@ -899,10 +901,7 @@ export class Transaction {
     const outputsData = outputs.map((_, i) =>
       hexFrom(tx.outputsData?.[i] ?? "0x"),
     );
-    if (
-      tx.outputsData !== undefined &&
-      outputsData.length < tx.outputsData.length
-    ) {
+    if (tx.outputsData != null && outputsData.length < tx.outputsData.length) {
       outputsData.push(
         ...tx.outputsData.slice(outputsData.length).map((d) => hexFrom(d)),
       );
@@ -1418,7 +1417,10 @@ export class Transaction {
       array: Cell[],
     ) => Promise<T | undefined> | T | undefined,
     init: T,
-  ): Promise<number> {
+  ): Promise<{
+    addedCount: number;
+    accumulated?: T;
+  }> {
     const scripts = (await from.getAddressObjs()).map(({ script }) => script);
     const collectedCells = [];
     let acc: T = init;
@@ -1453,13 +1455,18 @@ export class Transaction {
               }),
             ),
           );
-          return collectedCells.length;
+          return {
+            addedCount: collectedCells.length,
+          };
         }
         acc = next;
       }
     }
 
-    throw new Error("Failed to find enough cells for input");
+    return {
+      addedCount: collectedCells.length,
+      accumulated: acc,
+    };
   }
 
   async completeInputsByCapacity(
@@ -1474,7 +1481,7 @@ export class Transaction {
       return 0;
     }
 
-    return this.completeInputs(
+    const { addedCount, accumulated } = await this.completeInputs(
       from,
       filter ?? {
         scriptLenRange: [0, 1],
@@ -1482,10 +1489,35 @@ export class Transaction {
       },
       (acc, { cellOutput: { capacity } }) => {
         const sum = acc + capacity;
-        return sum > exceptedCapacity ? undefined : sum;
+        return sum >= exceptedCapacity ? undefined : sum;
       },
       inputsCapacity,
     );
+
+    if (accumulated === undefined) {
+      return addedCount;
+    }
+
+    throw new Error(
+      `Insufficient CKB, need ${fixedPointToString(exceptedCapacity - accumulated)} extra CKB`,
+    );
+  }
+
+  async completeInputsAll(
+    from: Signer,
+    filter?: ClientCollectableSearchKeyFilterLike,
+  ): Promise<number> {
+    const { addedCount } = await this.completeInputs(
+      from,
+      filter ?? {
+        scriptLenRange: [0, 1],
+        outputDataLenRange: [0, 1],
+      },
+      (acc, { cellOutput: { capacity } }) => acc + capacity,
+      Zero,
+    );
+
+    return addedCount;
   }
 
   async completeInputsByUdt(from: Signer, type: ScriptLike): Promise<number> {
@@ -1495,7 +1527,7 @@ export class Transaction {
       return 0;
     }
 
-    return this.completeInputs(
+    const { addedCount, accumulated } = await this.completeInputs(
       from,
       {
         script: type,
@@ -1504,10 +1536,18 @@ export class Transaction {
       (acc, { outputData }) => {
         const balance = udtBalanceFrom(outputData);
         const sum = acc + balance;
-        return sum > exceptedBalance ? undefined : sum;
+        return sum >= exceptedBalance ? undefined : sum;
       },
       inputsBalance,
     );
+
+    if (accumulated === undefined) {
+      return addedCount;
+    }
+
+    throw new Error(
+      `Insufficient coin, need ${exceptedBalance - accumulated} extra coin`,
+    );
   }
 
   estimateFee(feeRate: NumLike): Num {
@@ -1524,17 +1564,31 @@ export class Transaction {
     // Complete all inputs extra infos for cache
     await this.getInputsCapacity(from.client);
 
-    let leastFee = this.estimateFee(feeRate);
+    let leastFee = Zero;
     let leastExtraCapacity = Zero;
 
     while (true) {
       const prepared = await from.prepareTransaction(this.clone());
-      const collected = await prepared.completeInputsByCapacity(
-        from,
-        leastFee + leastExtraCapacity,
-        filter,
-      );
+      const collected = await (async () => {
+        try {
+          return await prepared.completeInputsByCapacity(
+            from,
+            leastFee + leastExtraCapacity,
+            filter,
+          );
+        } catch (err) {
+          if (leastExtraCapacity !== Zero) {
+            throw new Error("Not enough capacity for the change cell");
+          }
 
+          throw err;
+        }
+      })();
+
+      if (leastFee === Zero) {
+        // The initial fee is calculated based on prepared transaction
+        leastFee = prepared.estimateFee(feeRate);
+      }
       const extraCapacity =
         (await prepared.getInputsCapacity(from.client)) -
         prepared.getOutputsCapacity();

package/src/client/client.ts

@@ -41,7 +41,7 @@ export enum KnownScript {
 
 export type CellDepInfoLike = {
   cellDep: CellDepLike;
-  type?: ScriptLike;
+  type?: ScriptLike | null;
 };
 
 export class CellDepInfo {

package/src/client/clientPublicMainnet.advanced.ts

@@ -187,6 +187,38 @@ export const MAINNET_SCRIPTS: Record<
       },
     ],
   },
-  [KnownScript.SingleUseLock]: undefined,
-  [KnownScript.OutputTypeProxyLock]: undefined,
+  [KnownScript.SingleUseLock]: {
+    codeHash:
+      "0x8290467a512e5b9a6b816469b0edabba1f4ac474e28ffdd604c2a7c76446bbaf",
+    hashType: "data1",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x10d63a996157d32c01078058000052674ca58d15f921bec7f1dcdac2160eb66b",
+            index: 4,
+          },
+          depType: "code",
+        },
+      },
+    ],
+  },
+  [KnownScript.OutputTypeProxyLock]: {
+    codeHash:
+      "0x2df53b592db3ae3685b7787adcfef0332a611edb83ca3feca435809964c3aff2",
+    hashType: "data1",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x10d63a996157d32c01078058000052674ca58d15f921bec7f1dcdac2160eb66b",
+            index: 2,
+          },
+          depType: "code",
+        },
+      },
+    ],
+  },
 };

package/src/client/clientPublicMainnet.ts

@@ -4,7 +4,7 @@ import { MAINNET_SCRIPTS } from "./clientPublicMainnet.advanced";
 import { ClientJsonRpc } from "./jsonRpc";
 
 export class ClientPublicMainnet extends ClientJsonRpc {
-  constructor(url = "https://mainnet.ckbapp.dev/", timeout?: number) {
+  constructor(url = "https://mainnet.ckb.dev/", timeout?: number) {
     super(url, timeout);
   }
 

package/src/client/clientPublicTestnet.advanced.ts

@@ -207,7 +207,7 @@ export const TESTNET_SCRIPTS: Record<
         cellDep: {
           outPoint: {
             txHash:
-              "0x968c326f7a418f07a128f30d9a415251beaa2ec8bd6bbfda65780c94bebb2a85",
+              "0xb4f171c9c9caf7401f54a8e56225ae21d95032150a87a4678eac3f66a3137b93",
             index: 4,
           },
           depType: "code",
@@ -217,14 +217,14 @@ export const TESTNET_SCRIPTS: Record<
   },
   [KnownScript.OutputTypeProxyLock]: {
     codeHash:
-      "0xc0382e4109cff68a4f536441c0266d2e22f2808e61573129c9289ee0e5e5ed43",
+      "0x2df53b592db3ae3685b7787adcfef0332a611edb83ca3feca435809964c3aff2",
     hashType: "data1",
     cellDeps: [
       {
         cellDep: {
           outPoint: {
             txHash:
-              "0x968c326f7a418f07a128f30d9a415251beaa2ec8bd6bbfda65780c94bebb2a85",
+              "0xb4f171c9c9caf7401f54a8e56225ae21d95032150a87a4678eac3f66a3137b93",
             index: 2,
           },
           depType: "code",

package/src/client/clientPublicTestnet.ts

@@ -4,7 +4,7 @@ import { TESTNET_SCRIPTS } from "./clientPublicTestnet.advanced";
 import { ClientJsonRpc } from "./jsonRpc";
 
 export class ClientPublicTestnet extends ClientJsonRpc {
-  constructor(url = "https://testnet.ckbapp.dev/", timeout?: number) {
+  constructor(url = "https://testnet.ckb.dev/", timeout?: number) {
     super(url, timeout);
   }
 

package/src/client/clientTypes.advanced.ts

@@ -10,17 +10,17 @@ export function clientSearchKeyRangeFrom([a, b]: [NumLike, NumLike]): [
 }
 
 export type ClientCollectableSearchKeyFilterLike = {
-  script?: ScriptLike;
-  scriptLenRange?: [NumLike, NumLike];
-  outputData?: HexLike;
-  outputDataSearchMode?: "prefix" | "exact" | "partial";
-  outputDataLenRange?: [NumLike, NumLike];
-  outputCapacityRange?: [NumLike, NumLike];
+  script?: ScriptLike | null;
+  scriptLenRange?: [NumLike, NumLike] | null;
+  outputData?: HexLike | null;
+  outputDataSearchMode?: "prefix" | "exact" | "partial" | null;
+  outputDataLenRange?: [NumLike, NumLike] | null;
+  outputCapacityRange?: [NumLike, NumLike] | null;
 };
 export type ClientCollectableSearchKeyLike = {
   script: ScriptLike;
   scriptType: "lock" | "type";
   scriptSearchMode: "prefix" | "exact" | "partial";
-  filter?: ClientCollectableSearchKeyFilterLike;
-  withData?: boolean;
+  filter?: ClientCollectableSearchKeyFilterLike | null;
+  withData?: boolean | null;
 };

package/src/client/clientTypes.ts

@@ -23,7 +23,7 @@ export type ClientTransactionResponse = {
 
 export type ClientIndexerSearchKeyFilterLike =
   ClientCollectableSearchKeyFilterLike & {
-    blockRange?: [NumLike, NumLike];
+    blockRange?: [NumLike, NumLike] | null;
   };
 export class ClientIndexerSearchKeyFilter {
   constructor(
@@ -43,7 +43,7 @@ export class ClientIndexerSearchKeyFilter {
       apply(Script.from, filterLike.script),
       apply(clientSearchKeyRangeFrom, filterLike.scriptLenRange),
       apply(hexFrom, filterLike.outputData),
-      filterLike.outputDataSearchMode,
+      filterLike.outputDataSearchMode ?? undefined,
       apply(clientSearchKeyRangeFrom, filterLike.outputDataLenRange),
       apply(clientSearchKeyRangeFrom, filterLike.outputCapacityRange),
       apply(clientSearchKeyRangeFrom, filterLike.blockRange),
@@ -52,7 +52,7 @@ export class ClientIndexerSearchKeyFilter {
 }
 
 export type ClientIndexerSearchKeyLike = ClientCollectableSearchKeyLike & {
-  filter?: ClientIndexerSearchKeyFilterLike;
+  filter?: ClientIndexerSearchKeyFilterLike | null;
 };
 
 export class ClientIndexerSearchKey {
@@ -70,7 +70,7 @@ export class ClientIndexerSearchKey {
       keyLike.scriptType,
       keyLike.scriptSearchMode,
       apply(ClientIndexerSearchKeyFilter.from, keyLike.filter),
-      keyLike.withData,
+      keyLike.withData ?? undefined,
     );
   }
 }

package/src/signer/ckb/index.ts

@@ -1,2 +1,5 @@
+export * from "./signerCkbPrivateKey";
+export * from "./signerCkbPublicKey";
 export * from "./signerCkbScriptReadonly";
+export * from "./verifyCkbSecp256k1";
 export * from "./verifyJoyId";

package/src/signer/ckb/signerCkbPrivateKey.ts

@@ -0,0 +1,58 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { bytesConcat, bytesFrom, BytesLike } from "../../bytes";
+import { Transaction, TransactionLike, WitnessArgs } from "../../ckb";
+import { Client } from "../../client";
+import { hashCkb } from "../../hasher";
+import { Hex, hexFrom, HexLike } from "../../hex";
+import { numBeToBytes } from "../../num";
+import { SignerCkbPublicKey } from "./signerCkbPublicKey";
+
+export class SignerCkbPrivateKey extends SignerCkbPublicKey {
+  public readonly privateKey: Hex;
+
+  constructor(client: Client, privateKey: HexLike) {
+    const pk = hexFrom(privateKey);
+    if (bytesFrom(pk).length !== 32) {
+      throw new Error("Private key must be 32 bytes!");
+    }
+
+    super(client, secp256k1.getPublicKey(bytesFrom(pk), true));
+    this.privateKey = pk;
+  }
+
+  async signMessageRaw(message: string | BytesLike): Promise<Hex> {
+    const msg = typeof message === "string" ? message : hexFrom(message);
+    const buffer = bytesFrom(`Nervos Message:${msg}`, "utf8");
+    const hash = hashCkb(buffer);
+
+    const signature = secp256k1.sign(
+      bytesFrom(hash),
+      bytesFrom(this.privateKey),
+    );
+    const { r, s, recovery } = signature;
+
+    return hexFrom(
+      bytesConcat(
+        numBeToBytes(r, 32),
+        numBeToBytes(s, 32),
+        numBeToBytes(recovery, 1),
+      ),
+    );
+  }
+
+  async signOnlyTransaction(txLike: TransactionLike): Promise<Transaction> {
+    const tx = Transaction.from(txLike);
+    const { script } = await this.getRecommendedAddressObj();
+    const info = await tx.getSignHashInfo(script, this.client);
+    if (!info) {
+      return tx;
+    }
+
+    const signature = await this.signMessageRaw(info.message);
+
+    const witness = tx.getWitnessArgsAt(info.position) ?? WitnessArgs.from({});
+    witness.lock = signature;
+    tx.setWitnessArgsAt(info.position, witness);
+    return tx;
+  }
+}

package/src/signer/ckb/signerCkbPublicKey.ts

@@ -0,0 +1,63 @@
+import { Address } from "../../address";
+import { bytesFrom } from "../../bytes";
+import { Transaction, TransactionLike } from "../../ckb";
+import { Client, KnownScript } from "../../client";
+import { hashCkb } from "../../hasher";
+import { Hex, HexLike, hexFrom } from "../../hex";
+import { Signer, SignerSignType, SignerType } from "../signer";
+
+export class SignerCkbPublicKey extends Signer {
+  get type(): SignerType {
+    return SignerType.CKB;
+  }
+
+  get signType(): SignerSignType {
+    return SignerSignType.CkbSecp256k1;
+  }
+
+  public readonly publicKey: Hex;
+
+  constructor(client: Client, publicKey: HexLike) {
+    super(client);
+    this.publicKey = hexFrom(publicKey);
+
+    if (bytesFrom(this.publicKey).length !== 33) {
+      throw new Error("Public key must be 33 bytes!");
+    }
+  }
+
+  async connect(): Promise<void> {}
+
+  async isConnected(): Promise<boolean> {
+    return true;
+  }
+
+  async getInternalAddress(): Promise<string> {
+    return this.getRecommendedAddress();
+  }
+
+  async getIdentity(): Promise<string> {
+    return this.publicKey;
+  }
+
+  async getAddressObjs(): Promise<Address[]> {
+    return [
+      await Address.fromKnownScript(
+        this.client,
+        KnownScript.Secp256k1Blake160,
+        bytesFrom(hashCkb(this.publicKey)).slice(0, 20),
+      ),
+    ];
+  }
+
+  async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
+    const tx = Transaction.from(txLike);
+    const { script } = await this.getRecommendedAddressObj();
+    await tx.addCellDepsOfKnownScripts(
+      this.client,
+      KnownScript.Secp256k1Blake160,
+    );
+    await tx.prepareSighashAllWitness(script, 65, this.client);
+    return tx;
+  }
+}

package/src/signer/ckb/verifyCkbSecp256k1.ts

@@ -0,0 +1,27 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { BytesLike, bytesFrom } from "../../bytes";
+import { hashCkb } from "../../hasher";
+import { Hex, hexFrom } from "../../hex";
+import { numFrom } from "../../num";
+
+export function messageHashCkbSecp256k1(message: string | BytesLike): Hex {
+  const msg = typeof message === "string" ? message : hexFrom(message);
+  const buffer = bytesFrom(`Nervos Message:${msg}`, "utf8");
+  return hashCkb(buffer);
+}
+
+export function verifyMessageCkbSecp256k1(
+  message: string | BytesLike,
+  signature: string,
+  publicKey: string,
+): boolean {
+  const signatureBytes = bytesFrom(signature);
+  return secp256k1.verify(
+    new secp256k1.Signature(
+      numFrom(signatureBytes.slice(0, 32)),
+      numFrom(signatureBytes.slice(32, 64)),
+    ).addRecoveryBit(Number(numFrom(signatureBytes.slice(64, 65)))),
+    bytesFrom(messageHashCkbSecp256k1(message)),
+    bytesFrom(publicKey),
+  );
+}

package/src/signer/evm/signerEvm.ts

@@ -2,7 +2,7 @@ import { Address } from "../../address";
 import { BytesLike, bytesConcat, bytesFrom } from "../../bytes";
 import { Script, Transaction, TransactionLike, WitnessArgs } from "../../ckb";
 import { KnownScript } from "../../client";
-import { hexFrom } from "../../hex";
+import { Hex, hexFrom } from "../../hex";
 import { numToBytes } from "../../num";
 import { reduceAsync } from "../../utils";
 import { Signer, SignerSignType, SignerType } from "../signer";
@@ -25,7 +25,7 @@ export abstract class SignerEvm extends Signer {
    *
    * @returns A promise that resolves to a string representing the EVM account.
    */
-  abstract getEvmAccount(): Promise<string>;
+  abstract getEvmAccount(): Promise<Hex>;
 
   /**
    * Gets the internal address, which is the EVM account in this case.

package/src/signer/evm/signerEvmAddressReadonly.ts

@@ -53,7 +53,7 @@ export class SignerEvmAddressReadonly extends SignerEvm {
    * const account = await signer.getEvmAccount(); // Outputs the EVM account
    * ```
    */
-  async getEvmAccount(): Promise<string> {
+  async getEvmAccount(): Promise<Hex> {
     return this.address;
   }
 }

package/src/signer/signer/index.ts

@@ -5,6 +5,7 @@ import { Client } from "../../client";
 import { Hex } from "../../hex";
 import { Num } from "../../num";
 import { verifyMessageBtcEcdsa } from "../btc";
+import { verifyMessageCkbSecp256k1 } from "../ckb/verifyCkbSecp256k1";
 import { verifyMessageJoyId } from "../ckb/verifyJoyId";
 import { verifyMessageEvmPersonal } from "../evm/verify";
 import { verifyMessageNostrEvent } from "../nostr/verify";
@@ -15,6 +16,7 @@ export enum SignerSignType {
   EvmPersonal = "EvmPersonal",
   JoyId = "JoyId",
   NostrEvent = "NostrEvent",
+  CkbSecp256k1 = "CkbSecp256k1",
 }
 
 /**
@@ -116,20 +118,17 @@ export abstract class Signer {
           signature.signature,
           signature.identity,
         );
+      case SignerSignType.CkbSecp256k1:
+        return verifyMessageCkbSecp256k1(
+          message,
+          signature.signature,
+          signature.identity,
+        );
       case SignerSignType.Unknown:
         throw new Error("Unknown signer sign type");
     }
   }
 
-  /**
-   * Replace the current client.
-   * returns false if the new client is invalid for this signer.
-   */
-  async replaceClient(client: Client): Promise<boolean> {
-    this.client_ = client;
-    return true;
-  }
-
   /**
    * Connects to the signer.
    *
@@ -137,6 +136,15 @@ export abstract class Signer {
    */
   abstract connect(): Promise<void>;
 
+  /**
+   * Register a listener to be called when this signer is replaced.
+   *
+   * @returns A function for unregister
+   */
+  onReplaced(_: () => void): () => void {
+    return () => {};
+  }
+
   /**
    * Disconnects to the signer.
    *