@ckb-ccc/core 0.0.11-alpha.3 → 0.0.12-alpha.0

package/src/hasher/hasher.ts

@@ -0,0 +1,35 @@
+import { BytesLike } from "../bytes/index.js";
+import { Hex } from "../hex/index.js";
+
+export interface Hasher {
+  /**
+   * Updates the hash with the given data.
+   *
+   * @param data - The data to update the hash with.
+   * @returns The current Hasher instance for chaining.
+   *
+   * @example
+   * ```typescript
+   * const hasher = new Hasher();
+   * hasher.update("some data").update("more data");
+   * const hash = hasher.digest();
+   * ```
+   */
+
+  update(data: BytesLike): Hasher;
+
+  /**
+   * Finalizes the hash and returns the digest as a hexadecimal string.
+   *
+   * @returns The hexadecimal string representation of the hash.
+   *
+   * @example
+   * ```typescript
+   * const hasher = new Hasher();
+   * hasher.update("some data");
+   * const hash = hasher.digest(); // Outputs something like "0x..."
+   * ```
+   */
+
+  digest(): Hex;
+}

package/src/hasher/hasherCkb.ts

@@ -0,0 +1,102 @@
+import { blake2b } from "@noble/hashes/blake2b";
+import { BytesLike, bytesFrom } from "../bytes/index.js";
+import { CellInput, CellInputLike } from "../ckb/index.js";
+import { Hex, hexFrom } from "../hex/index.js";
+import { NumLike, numLeToBytes } from "../num/index.js";
+import { CKB_BLAKE2B_PERSONAL } from "./advanced.js";
+import { Hasher } from "./hasher.js";
+
+export class HasherCkb implements Hasher {
+  private readonly hasher: ReturnType<(typeof blake2b)["create"]>;
+
+  /**
+   * Creates an instance of Hasher.
+   *
+   * @param outLength - The output length of the hash in bytes. Default is 32.
+   * @param personal - The personal string for the Blake2b algorithm. Default is CKB_BLAKE2B_PERSONAL.
+   */
+
+  constructor(outLength = 32, personal = CKB_BLAKE2B_PERSONAL) {
+    this.hasher = blake2b.create({
+      personalization: personal,
+      dkLen: outLength,
+    });
+  }
+
+  /**
+   * Updates the hash with the given data.
+   *
+   * @param data - The data to update the hash with.
+   * @returns The current Hasher instance for chaining.
+   *
+   * @example
+   * ```typescript
+   * const hasher = new Hasher();
+   * hasher.update("some data").update("more data");
+   * const hash = hasher.digest();
+   * ```
+   */
+
+  update(data: BytesLike): HasherCkb {
+    this.hasher.update(bytesFrom(data));
+    return this;
+  }
+
+  /**
+   * Finalizes the hash and returns the digest as a hexadecimal string.
+   *
+   * @returns The hexadecimal string representation of the hash.
+   *
+   * @example
+   * ```typescript
+   * const hasher = new Hasher();
+   * hasher.update("some data");
+   * const hash = hasher.digest(); // Outputs something like "0x..."
+   * ```
+   */
+
+  digest(): Hex {
+    return hexFrom(this.hasher.digest());
+  }
+}
+
+/**
+ * Computes the CKB hash of the given data using the Blake2b algorithm.
+ *
+ * @param data - The data to hash.
+ * @returns The hexadecimal string representation of the hash.
+ *
+ * @example
+ * ```typescript
+ * const hash = hashCkb("some data"); // Outputs something like "0x..."
+ * ```
+ */
+
+export function hashCkb(...data: BytesLike[]): Hex {
+  const hasher = new HasherCkb();
+  data.forEach((d) => hasher.update(d));
+  return hasher.digest();
+}
+
+/**
+ * Computes the Type ID hash of the given data.
+ *
+ * @param cellInput - The first cell input of the transaction.
+ * @param outputIndex - The output index of the Type ID cell.
+ * @returns The hexadecimal string representation of the hash.
+ *
+ * @example
+ * ```typescript
+ * const hash = hashTypeId(cellInput, outputIndex); // Outputs something like "0x..."
+ * ```
+ */
+
+export function hashTypeId(
+  cellInputLike: CellInputLike,
+  outputIndex: NumLike,
+): Hex {
+  return hashCkb(
+    CellInput.from(cellInputLike).toBytes(),
+    numLeToBytes(outputIndex, 8),
+  );
+}

package/src/hasher/hasherKeecak256.ts

@@ -0,0 +1,52 @@
+import { keccak_256 } from "@noble/hashes/sha3";
+import { BytesLike, bytesFrom } from "../bytes/index.js";
+import { Hex, hexFrom } from "../hex/index.js";
+import { Hasher } from "./hasher.js";
+
+export class HasherKeecak256 implements Hasher {
+  private readonly hasher: ReturnType<(typeof keccak_256)["create"]>;
+
+  /**
+   * Creates an instance of Hasher.
+   */
+
+  constructor() {
+    this.hasher = keccak_256.create();
+  }
+
+  /**
+   * Updates the hash with the given data.
+   *
+   * @param data - The data to update the hash with.
+   * @returns The current Hasher instance for chaining.
+   *
+   * @example
+   * ```typescript
+   * const hasher = new Hasher();
+   * hasher.update("some data").update("more data");
+   * const hash = hasher.digest();
+   * ```
+   */
+
+  update(data: BytesLike): HasherKeecak256 {
+    this.hasher.update(bytesFrom(data));
+    return this;
+  }
+
+  /**
+   * Finalizes the hash and returns the digest as a hexadecimal string.
+   *
+   * @returns The hexadecimal string representation of the hash.
+   *
+   * @example
+   * ```typescript
+   * const hasher = new Hasher();
+   * hasher.update("some data");
+   * const hash = hasher.digest(); // Outputs something like "0x..."
+   * ```
+   */
+
+  digest(): Hex {
+    return hexFrom(this.hasher.digest());
+  }
+}

package/src/hasher/index.ts

@@ -1,103 +1,3 @@
-import blake2b, { Blake2b } from "blake2b";
-import { BytesLike, bytesFrom } from "../bytes/index.js";
-import { CellInput, CellInputLike } from "../ckb/index.js";
-import { Hex } from "../hex/index.js";
-import { NumLike, numLeToBytes } from "../num/index.js";
-import { CKB_BLAKE2B_PERSONAL } from "./advanced.js";
-
-export class Hasher {
-  private readonly hasher: Blake2b;
-
-  /**
-   * Creates an instance of Hasher.
-   *
-   * @param outLength - The output length of the hash in bytes. Default is 32.
-   * @param personal - The personal string for the Blake2b algorithm. Default is CKB_BLAKE2B_PERSONAL.
-   */
-
-  constructor(outLength = 32, personal = CKB_BLAKE2B_PERSONAL) {
-    this.hasher = blake2b(
-      outLength,
-      undefined,
-      undefined,
-      bytesFrom(personal, "utf8"),
-    );
-  }
-
-  /**
-   * Updates the hash with the given data.
-   *
-   * @param data - The data to update the hash with.
-   * @returns The current Hasher instance for chaining.
-   *
-   * @example
-   * ```typescript
-   * const hasher = new Hasher();
-   * hasher.update("some data").update("more data");
-   * const hash = hasher.digest();
-   * ```
-   */
-
-  update(data: BytesLike): Hasher {
-    this.hasher.update(bytesFrom(data));
-    return this;
-  }
-
-  /**
-   * Finalizes the hash and returns the digest as a hexadecimal string.
-   *
-   * @returns The hexadecimal string representation of the hash.
-   *
-   * @example
-   * ```typescript
-   * const hasher = new Hasher();
-   * hasher.update("some data");
-   * const hash = hasher.digest(); // Outputs something like "0x..."
-   * ```
-   */
-
-  digest(): Hex {
-    return `0x${this.hasher.digest("hex")}`;
-  }
-}
-
-/**
- * Computes the CKB hash of the given data using the Blake2b algorithm.
- *
- * @param data - The data to hash.
- * @returns The hexadecimal string representation of the hash.
- *
- * @example
- * ```typescript
- * const hash = hashCkb("some data"); // Outputs something like "0x..."
- * ```
- */
-
-export function hashCkb(...data: BytesLike[]): Hex {
-  const hasher = new Hasher();
-  data.forEach((d) => hasher.update(d));
-  return hasher.digest();
-}
-
-/**
- * Computes the Type ID hash of the given data.
- *
- * @param cellInput - The first cell input of the transaction.
- * @param outputIndex - The output index of the Type ID cell.
- * @returns The hexadecimal string representation of the hash.
- *
- * @example
- * ```typescript
- * const hash = hashTypeId(cellInput, outputIndex); // Outputs something like "0x..."
- * ```
- */
-
-export function hashTypeId(
-  cellInputLike: CellInputLike,
-  outputIndex: NumLike,
-): Hex {
-  return hashCkb(
-    CellInput.from(cellInputLike).toBytes(),
-    numLeToBytes(outputIndex, 8),
-  );
-}
+export * from "./hasher.js";
+export * from "./hasherCkb.js";
+export * from "./hasherKeecak256.js";

package/src/keystore/index.ts

@@ -22,7 +22,25 @@ export async function keystoreEncrypt(
   privateKeyLike: BytesLike,
   chainCodeLike: BytesLike,
   password: string,
-) {
+): Promise<{
+  id: string;
+  crypto: {
+    ciphertext: string;
+    cipherparams: {
+      iv: string;
+    };
+    cipher: string;
+    kdf: string;
+    kdfparams: {
+      n: number;
+      r: number;
+      p: number;
+      dklen: number;
+      salt: string;
+    };
+    mac: string;
+  };
+}> {
   const salt = randomBytes(32);
   const iv = randomBytes(16);
   const kdfparams = {

package/src/signer/evm/signerEvm.ts

@@ -1,5 +1,5 @@
 import { Address } from "../../address/index.js";
-import { BytesLike, bytesConcat, bytesFrom } from "../../bytes/index.js";
+import { Bytes, BytesLike, bytesConcat, bytesFrom } from "../../bytes/index.js";
 import {
   Script,
   Transaction,
@@ -7,7 +7,8 @@ import {
   WitnessArgs,
 } from "../../ckb/index.js";
 import { KnownScript } from "../../client/index.js";
-import { Hex, hexFrom } from "../../hex/index.js";
+import { Hasher, HasherKeecak256 } from "../../hasher/index.js";
+import { Hex, HexLike, hexFrom } from "../../hex/index.js";
 import { numToBytes } from "../../num/index.js";
 import { reduceAsync } from "../../utils/index.js";
 import { Signer, SignerSignType, SignerType } from "../signer/index.js";
@@ -48,13 +49,30 @@ export abstract class SignerEvm extends Signer {
    */
   async getAddressObjs(): Promise<Address[]> {
     const account = await this.getEvmAccount();
-    return [
-      await this._getOmniLockEvmAddressObj(account),
-      await this._getOmniLockOldEvmAddressObj(account),
-    ];
+    const addresses = await Promise.all([
+      this._getOmniLockAddresses(account),
+      this._getPWLockAddresses(account),
+    ]);
+
+    return addresses.flat();
+  }
+
+  _getOmniLockAddresses(account: HexLike): Promise<Address[]> {
+    return Promise.all([
+      this._getOmniLockEvmAddressObj(account),
+      this._getOmniLockOldEvmAddressObj(account),
+    ]);
+  }
+
+  async _getPWLockAddresses(account: HexLike): Promise<Address[]> {
+    const addr = await this._getPWLockEvmAddressObj(account);
+    if (!addr) {
+      return [];
+    }
+    return [addr];
   }
 
-  async _getOmniLockEvmAddressObj(account: string): Promise<Address> {
+  async _getOmniLockEvmAddressObj(account: HexLike): Promise<Address> {
     return Address.fromKnownScript(
       this.client,
       KnownScript.OmniLock,
@@ -62,7 +80,7 @@ export abstract class SignerEvm extends Signer {
     );
   }
 
-  async _getOmniLockOldEvmAddressObj(account: string): Promise<Address> {
+  async _getOmniLockOldEvmAddressObj(account: HexLike): Promise<Address> {
     return Address.fromKnownScript(
       this.client,
       KnownScript.OmniLock,
@@ -70,6 +88,19 @@ export abstract class SignerEvm extends Signer {
     );
   }
 
+  async _getPWLockEvmAddressObj(
+    account: HexLike,
+  ): Promise<Address | undefined> {
+    try {
+      return Address.fromKnownScript(
+        this.client,
+        KnownScript.PWLock,
+        hexFrom(bytesFrom(account)),
+      );
+    } catch {}
+    return;
+  }
+
   /**
    * prepare a transaction before signing. This method is not implemented and should be overridden by subclasses.
    *
@@ -78,13 +109,40 @@ export abstract class SignerEvm extends Signer {
    */
   async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
     const tx = Transaction.from(txLike);
-    await tx.addCellDepsOfKnownScripts(this.client, KnownScript.OmniLock);
-    return reduceAsync(
-      await this.getAddressObjs(),
+    if (
+      (await tx.findInputIndexByLockId(
+        await this.client.getKnownScript(KnownScript.OmniLock),
+        this.client,
+      )) !== undefined
+    ) {
+      await tx.addCellDepsOfKnownScripts(this.client, KnownScript.OmniLock);
+    }
+    if (
+      (await tx.findInputIndexByLockId(
+        await this.client.getKnownScript(KnownScript.PWLock),
+        this.client,
+      )) !== undefined
+    ) {
+      await tx.addCellDepsOfKnownScripts(this.client, KnownScript.PWLock);
+    }
+
+    const account = await this.getEvmAccount();
+    const omniLockAddresses = await this._getOmniLockAddresses(account);
+    const pwLockAddresses = await this._getPWLockAddresses(account);
+
+    const omniTx = reduceAsync(
+      omniLockAddresses,
       (tx: Transaction, { script }) =>
         tx.prepareSighashAllWitness(script, 85, this.client),
       tx,
     );
+
+    return reduceAsync(
+      pwLockAddresses,
+      (tx: Transaction, { script }) =>
+        tx.prepareSighashAllWitness(script, 65, this.client),
+      omniTx,
+    );
   }
 
   /**
@@ -112,6 +170,15 @@ export abstract class SignerEvm extends Signer {
       (hash) => bytesFrom(hash),
     );
 
+    const pwAddress = await this._getPWLockEvmAddressObj(account);
+    if (pwAddress) {
+      tx = await this._signPWLockScriptForTransaction(
+        tx,
+        pwAddress.script,
+        (hash) => bytesFrom(hash),
+      );
+    }
+
     return tx;
   }
 
@@ -120,27 +187,24 @@ export abstract class SignerEvm extends Signer {
     script: Script,
     messageTransformer: (hash: string) => BytesLike,
   ): Promise<Transaction> {
-    const info = await tx.getSignHashInfo(script, this.client);
+    const info = await this._signPersonalEvmForTransaction(
+      tx,
+      script,
+      messageTransformer,
+    );
     if (!info) {
       return tx;
     }
 
-    const signature = bytesFrom(
-      await this.signMessageRaw(messageTransformer(info.message)),
-    );
-    if (signature[signature.length - 1] >= 27) {
-      signature[signature.length - 1] -= 27;
-    }
-
     const witness = WitnessArgs.fromBytes(tx.witnesses[info.position]);
     witness.lock = hexFrom(
       bytesConcat(
-        numToBytes(5 * 4 + signature.length, 4),
+        numToBytes(5 * 4 + info.signature.length, 4),
         numToBytes(4 * 4, 4),
-        numToBytes(5 * 4 + signature.length, 4),
-        numToBytes(5 * 4 + signature.length, 4),
-        numToBytes(signature.length, 4),
-        signature,
+        numToBytes(5 * 4 + info.signature.length, 4),
+        numToBytes(5 * 4 + info.signature.length, 4),
+        numToBytes(info.signature.length, 4),
+        info.signature,
       ),
     );
 
@@ -148,4 +212,47 @@ export abstract class SignerEvm extends Signer {
 
     return tx;
   }
+
+  async _signPWLockScriptForTransaction(
+    tx: Transaction,
+    script: Script,
+    messageTransformer: (hash: string) => BytesLike,
+  ): Promise<Transaction> {
+    const info = await this._signPersonalEvmForTransaction(
+      tx,
+      script,
+      messageTransformer,
+      new HasherKeecak256(),
+    );
+    if (!info) {
+      return tx;
+    }
+
+    const witness = WitnessArgs.fromBytes(tx.witnesses[info.position]);
+    witness.lock = hexFrom(info.signature);
+    tx.setWitnessArgsAt(info.position, witness);
+
+    return tx;
+  }
+
+  async _signPersonalEvmForTransaction(
+    tx: Transaction,
+    script: Script,
+    messageTransformer: (hash: string) => BytesLike,
+    hasher?: Hasher,
+  ): Promise<{ signature: Bytes; position: number } | undefined> {
+    const info = await tx.getSignHashInfo(script, this.client, hasher);
+    if (!info) {
+      return;
+    }
+
+    const signature = bytesFrom(
+      await this.signMessageRaw(messageTransformer(info.message)),
+    );
+    if (signature[signature.length - 1] >= 27) {
+      signature[signature.length - 1] -= 27;
+    }
+
+    return { signature, position: info.position };
+  }
 }

package/src/signer/signer/index.ts

@@ -73,7 +73,7 @@ export abstract class Signer {
   matchNetworkPreference(
     preferences: NetworkPreference[],
     currentNetwork: string,
-  ) {
+  ): NetworkPreference | undefined {
     if (
       preferences.some(({ signerType, addressPrefix, network }) => {
         signerType === this.type &&

package/src/utils/index.ts

@@ -118,7 +118,7 @@ export async function reduceAsync<T, V>(
     i: number,
     values: V[],
   ) => Promise<T | undefined | null | void> | T | undefined | null | void,
-  init: T,
+  init: T | Promise<T>,
 ): Promise<T>;
 export async function reduceAsync<T, V>(
   values: (V | T)[],
@@ -128,7 +128,7 @@ export async function reduceAsync<T, V>(
     i: number,
     values: (V | T)[],
   ) => Promise<T | undefined | null | void> | T | undefined | null | void,
-  init?: T,
+  init?: T | Promise<T>,
 ): Promise<T> {
   if (init === undefined) {
     if (values.length === 0) {