@ckb-ccc/core 0.0.4-alpha.1 → 0.0.4-alpha.11

package/src/signer/helpers.ts

@@ -1,10 +1,36 @@
-import { Script, ScriptLike, Transaction, TransactionLike } from "../ckb";
+import {
+  Script,
+  ScriptLike,
+  Transaction,
+  TransactionLike,
+  WitnessArgs,
+} from "../ckb";
+import { Client } from "../client";
 import { Hasher } from "../hasher";
-import { Hex } from "../hex";
+import { Hex, hexFrom } from "../hex";
 
+/**
+ * Computes the signing hash information for a given transaction and script.
+ *
+ * @param txLike - The transaction to sign, represented as a TransactionLike object.
+ * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+ * @param client - The client for complete extra infos in the transaction.
+ * @returns A promise that resolves to an object containing the signing message and the witness position,
+ *          or undefined if no matching input is found.
+ *
+ * @example
+ * ```typescript
+ * const signHashInfo = await getSignHashInfo(transactionLike, scriptLike, client);
+ * if (signHashInfo) {
+ *   console.log(signHashInfo.message); // Outputs the signing message
+ *   console.log(signHashInfo.position); // Outputs the witness position
+ * }
+ * ```
+ */
 export async function getSignHashInfo(
   txLike: TransactionLike,
   scriptLike: ScriptLike,
+  client: Client,
 ): Promise<{ message: Hex; position: number } | undefined> {
   const tx = Transaction.from(txLike);
   const script = Script.from(scriptLike);
@@ -12,15 +38,16 @@ export async function getSignHashInfo(
   const hasher = new Hasher();
   hasher.update(tx.hash());
 
-  tx.witnesses.forEach((witness, i) => {
-    const input = tx.inputs[i];
-    if (input) {
-      if (!input.cellOutput?.lock) {
-        throw Error("Incomplete inputs info");
+  for (let i = 0; i < tx.witnesses.length; i += 1) {
+    if (tx.inputs[i]) {
+      const input = await tx.inputs[i].completeExtraInfos(client);
+
+      if (!input.cellOutput) {
+        throw Error("Unable to resolve inputs info");
       }
 
-      if (!script.eq(input.cellOutput?.lock)) {
-        return;
+      if (!script.eq(input.cellOutput.lock)) {
+        continue;
       }
 
       if (position === -1) {
@@ -32,8 +59,8 @@ export async function getSignHashInfo(
       return undefined;
     }
 
-    Transaction.hashWitnessToHasher(witness, hasher);
-  });
+    Transaction.hashWitnessToHasher(tx.witnesses[i], hasher);
+  }
 
   if (position === -1) {
     return undefined;
@@ -44,3 +71,52 @@ export async function getSignHashInfo(
     position,
   };
 }
+
+/**
+ * Prepare dummy witness for sighash all method
+ *
+ * @param txLike - The transaction to prepare, represented as a TransactionLike object.
+ * @param scriptLike - The script associated with the transaction, represented as a ScriptLike object.
+ * @param client - The client for complete extra infos in the transaction.
+ * @returns A promise that resolves to the prepared transaction
+ *
+ * @example
+ * ```typescript
+ * const tx = await prepareSighashAllWitness(transactionLike, scriptLike, client);
+ * ```
+ */
+export async function prepareSighashAllWitness(
+  txLike: TransactionLike,
+  scriptLike: ScriptLike,
+  lockLen: number,
+  client: Client,
+): Promise<Transaction> {
+  const tx = Transaction.from(txLike);
+  const script = Script.from(scriptLike);
+
+  let position = -1;
+
+  for (let i = 0; i < tx.inputs.length; i += 1) {
+    const input = await tx.inputs[i].completeExtraInfos(client);
+
+    if (!input.cellOutput) {
+      throw Error("Unable to resolve inputs info");
+    }
+
+    if (script.eq(input.cellOutput.lock)) {
+      position = i;
+      break;
+    }
+  }
+  if (position === -1) {
+    return tx;
+  }
+
+  const witness = tx.witnesses[position]
+    ? WitnessArgs.fromBytes(tx.witnesses[position])
+    : WitnessArgs.from({});
+  witness.lock = hexFrom(Array.from(new Array(lockLen), () => 0));
+  tx.witnesses[position] = hexFrom(witness.toBytes());
+
+  return tx;
+}

package/src/signer/signer.ts

@@ -1,52 +1,152 @@
 import { Address } from "../address";
 import { BytesLike } from "../bytes";
-import { Transaction } from "../ckb";
+import { Transaction, TransactionLike } from "../ckb";
 import { Client } from "../client";
 import { Hex } from "../hex";
 
+/**
+ * An abstract class representing a generic signer.
+ * 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_;
+  }
+
+  /**
+   * 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>;
 
+  /**
+   * 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.
+   *
+   * @returns A promise that resolves to a string representing the internal address.
+   */
   abstract getInternalAddress(): Promise<string>;
 
+  /**
+   * Gets an array of Address objects associated with the signer.
+   *
+   * @returns A promise that resolves to an array of Address objects.
+   */
   abstract getAddressObjs(): Promise<Address[]>;
+
+  /**
+   * Gets the recommended Address object for the signer.
+   *
+   * @param _preference - Optional preference parameter.
+   * @returns A promise that resolves to the recommended Address object.
+   */
   async getRecommendedAddressObj(_preference?: unknown): Promise<Address> {
     return (await this.getAddressObjs())[0];
   }
 
+  /**
+   * Gets the recommended address for the signer as a string.
+   *
+   * @param preference - Optional preference parameter.
+   * @returns A promise that resolves to the recommended address as a string.
+   */
   async getRecommendedAddress(preference?: unknown): Promise<string> {
     return (await this.getRecommendedAddressObj(preference)).toString();
   }
+
+  /**
+   * Gets an array of addresses associated with the signer as strings.
+   *
+   * @returns A promise that resolves to an array of addresses as strings.
+   */
   async getAddresses(): Promise<string[]> {
     return this.getAddressObjs().then((addresses) =>
       addresses.map((address) => address.toString()),
     );
   }
 
+  /**
+   * Signs a message. This method is not implemented and should be overridden by subclasses.
+   *
+   * @param _ - The message to sign, as a string or BytesLike object.
+   * @returns A promise that resolves to the signed message as a string.
+   * @throws Will throw an error if not implemented.
+   */
   signMessage(_: string | BytesLike): Promise<string> {
     throw Error("Signer.signMessage not implemented");
   }
 
-  async sendTransaction(tx: Transaction): Promise<Hex> {
+  /**
+   * Sends a transaction after signing it.
+   *
+   * @param tx - The transaction to send, represented as a TransactionLike object.
+   * @returns A promise that resolves to the transaction hash as a Hex string.
+   */
+  async sendTransaction(tx: TransactionLike): Promise<Hex> {
     return this.client.sendTransaction(await this.signTransaction(tx));
   }
 
-  async signTransaction(tx: Transaction): Promise<Transaction> {
-    return this.signOnlyTransaction(tx);
+  /**
+   * Signs a transaction.
+   *
+   * @param tx - The transaction to sign, represented as a TransactionLike object.
+   * @returns A promise that resolves to the signed Transaction object.
+   */
+  async signTransaction(tx: TransactionLike): Promise<Transaction> {
+    const preparedTx = await this.prepareTransaction(tx);
+    return this.signOnlyTransaction(preparedTx);
+  }
+
+  /**
+   * prepare a transaction before signing. This method is not implemented and should be overridden by subclasses.
+   *
+   * @param _ - The transaction to prepare, represented as a TransactionLike object.
+   * @returns A promise that resolves to the prepared Transaction object.
+   * @throws Will throw an error if not implemented.
+   */
+  prepareTransaction(_: TransactionLike): Promise<Transaction> {
+    throw Error("Signer.prepareTransaction not implemented");
   }
 
-  signOnlyTransaction(_: Transaction): Promise<Transaction> {
+  /**
+   * Signs a transaction without sending it. This method is not implemented and should be overridden by subclasses.
+   *
+   * @param _ - The transaction to sign, represented as a TransactionLike object.
+   * @returns A promise that resolves to the signed Transaction object.
+   * @throws Will throw an error if not implemented.
+   */
+  signOnlyTransaction(_: TransactionLike): Promise<Transaction> {
     throw Error("Signer.signOnlyTransaction not implemented");
   }
 }
 
+/**
+ * An enumeration of signer types.
+ */
 export enum SignerType {
   EVM = "EVM",
   BTC = "BTC",
 }
 
+/**
+ * A class representing information about a signer, including its type and the signer instance.
+ */
 export class SignerInfo {
   constructor(
     public type: SignerType,
@@ -54,8 +154,10 @@ export class SignerInfo {
   ) {}
 }
 
+/**
+ * Represents a wallet with a name, icon, and an array of signer information.
+ */
 export type Wallet = {
   name: string;
   icon: string;
-  signers: SignerInfo[];
 };