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

package/src/signer/evm/signerEvmAddressReadonly.ts

@@ -21,15 +21,6 @@ export 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.
    *

package/src/signer/index.ts

@@ -2,4 +2,5 @@ export * from "./btc";
 export * from "./ckb";
 export * from "./dummy";
 export * from "./evm";
+export * from "./nostr";
 export * from "./signer";

package/src/signer/nostr/index.ts

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

package/src/signer/nostr/signerNostr.ts

@@ -0,0 +1,135 @@
+import { bech32 } from "bech32";
+import { Address } from "../../address";
+import { BytesLike, bytesConcat, bytesFrom } from "../../bytes";
+import { Transaction, TransactionLike, WitnessArgs } from "../../ckb";
+import { KnownScript } from "../../client";
+import { ckbHash } from "../../hasher";
+import { Hex, hexFrom } from "../../hex";
+import { Signer, SignerSignType, SignerType } from "../signer";
+import { buildNostrEventFromMessage } from "./verify";
+
+export interface NostrEvent {
+  id?: string;
+  pubkey?: string;
+  sig?: string;
+  created_at: number;
+  kind: number;
+  tags: string[][];
+  content: string;
+}
+
+export abstract class SignerNostr extends Signer {
+  static CKB_SIG_HASH_ALL_TAG = "ckb_sighash_all";
+  static CKB_UNLOCK_EVENT_KIND = 23334;
+  static CKB_UNLOCK_EVENT_CONTENT =
+    "Signing a CKB transaction\n\nIMPORTANT: Please verify the integrity and authenticity of connected Nostr client before signing this message\n";
+
+  get type(): SignerType {
+    return SignerType.Nostr;
+  }
+
+  get signType(): SignerSignType {
+    return SignerSignType.NostrEvent;
+  }
+
+  /**
+   * Gets the Nostr public key associated with the signer.
+   *
+   * @returns A promise that resolves to a string representing the Nostr public key.
+   */
+  abstract getNostrPublicKey(): Promise<Hex>;
+
+  /**
+   * Sign a nostr event.
+   *
+   * @returns A promise that resolves to the signed event.
+   */
+  abstract signNostrEvent(event: NostrEvent): Promise<Required<NostrEvent>>;
+
+  /**
+   * Sign a message.
+   *
+   * @returns A promise that resolves to the signature.
+   */
+  async signMessageRaw(message: string | BytesLike): Promise<Hex> {
+    return hexFrom(
+      (await this.signNostrEvent(buildNostrEventFromMessage(message))).sig,
+    );
+  }
+
+  /**
+   * Gets the internal address, which is the EVM account in this case.
+   *
+   * @returns A promise that resolves to a string representing the internal address.
+   */
+  async getInternalAddress(): Promise<string> {
+    return bech32.encode(
+      "npub",
+      bech32.toWords(bytesFrom(await this.getNostrPublicKey())),
+    );
+  }
+
+  /**
+   * Gets an array of Address objects representing the known script addresses for the signer.
+   *
+   * @returns A promise that resolves to an array of Address objects.
+   */
+  async getAddressObjs(): Promise<Address[]> {
+    const publicKey = await this.getNostrPublicKey();
+    return [
+      await Address.fromKnownScript(
+        this.client,
+        KnownScript.NostrLock,
+        hexFrom(bytesConcat([0x00], ckbHash(publicKey).slice(0, 42))),
+      ),
+    ];
+  }
+
+  /**
+   * prepare a transaction before signing.
+   *
+   * @param txLike - The transaction to prepare, represented as a TransactionLike object.
+   * @returns A promise that resolves to the prepared Transaction object.
+   */
+  async prepareTransaction(txLike: TransactionLike): Promise<Transaction> {
+    const tx = Transaction.from(txLike);
+    const { script } = await this.getRecommendedAddressObj();
+    await tx.addCellDepsOfKnownScripts(this.client, KnownScript.NostrLock);
+    await tx.prepareSighashAllWitness(script, 572, this.client);
+    return tx;
+  }
+
+  /**
+   * Signs a transaction without modifying it.
+   *
+   * @param txLike - The transaction to sign, represented as a TransactionLike object.
+   * @returns A promise that resolves to a signed Transaction object.
+   */
+  async signOnlyTransaction(txLike: TransactionLike): Promise<Transaction> {
+    let tx = Transaction.from(txLike);
+    const { script } = await this.getRecommendedAddressObj();
+    const info = await tx.getSignHashInfo(script, this.client);
+    if (!info) {
+      return tx;
+    }
+
+    const signedEvent = bytesFrom(
+      JSON.stringify(
+        await this.signNostrEvent({
+          pubkey: (await this.getNostrPublicKey()).slice(2),
+          tags: [[SignerNostr.CKB_SIG_HASH_ALL_TAG, info.message.slice(2)]],
+          created_at: Math.floor(Date.now() / 1000),
+          kind: SignerNostr.CKB_UNLOCK_EVENT_KIND,
+          content: SignerNostr.CKB_UNLOCK_EVENT_CONTENT,
+        }),
+      ),
+      "utf8",
+    );
+
+    const witness = WitnessArgs.fromBytes(tx.witnesses[info.position]);
+    witness.lock = hexFrom(signedEvent);
+    tx.setWitnessArgsAt(info.position, witness);
+
+    return tx;
+  }
+}

package/src/signer/nostr/verify.ts

@@ -0,0 +1,63 @@
+import { schnorr } from "@noble/curves/secp256k1";
+import { sha256 } from "@noble/hashes/sha256";
+import { bech32 } from "bech32";
+import { BytesLike, bytesFrom } from "../../bytes";
+import { hexFrom } from "../../hex";
+import { NostrEvent } from "./signerNostr";
+
+export function buildNostrEventFromMessage(
+  message: string | BytesLike,
+): NostrEvent {
+  if (typeof message === "string") {
+    try {
+      const event = JSON.parse(message);
+      if (
+        typeof event === "object" &&
+        typeof event.created_at === "number" &&
+        typeof event.kind === "number" &&
+        typeof event.content === "string" &&
+        Array.isArray(event.args) &&
+        (event.args as unknown[]).every(
+          (tag) =>
+            Array.isArray(tag) &&
+            (tag as unknown[]).every((v) => typeof v === "string"),
+        )
+      ) {
+        return event;
+      }
+    } catch (_) {}
+  }
+
+  return {
+    kind: 23335,
+    created_at: 0,
+    content: typeof message === "string" ? message : hexFrom(message),
+    tags: [],
+  };
+}
+
+export function verifyMessageNostrEvent(
+  message: string | BytesLike,
+  signature: string,
+  address: string,
+): boolean {
+  const { words } = bech32.decode(address);
+  const publicKey = hexFrom(bech32.fromWords(words)).slice(2);
+
+  const event = buildNostrEventFromMessage(message);
+  const serialized = JSON.stringify([
+    0,
+    publicKey,
+    event.created_at,
+    event.kind,
+    event.tags,
+    event.content,
+  ]);
+  const eventHash = hexFrom(sha256(bytesFrom(serialized, "utf8")));
+
+  try {
+    return schnorr.verify(signature.slice(2), eventHash.slice(2), publicKey);
+  } catch (_) {
+    return false;
+  }
+}

package/src/signer/signer/index.ts

@@ -7,12 +7,14 @@ import { Num } from "../../num";
 import { verifyMessageBtcEcdsa } from "../btc";
 import { verifyMessageJoyId } from "../ckb/verifyJoyId";
 import { verifyMessageEvmPersonal } from "../evm/verify";
+import { verifyMessageNostrEvent } from "../nostr/verify";
 
 export enum SignerSignType {
   Unknown = "Unknown",
   BtcEcdsa = "BtcEcdsa",
   EvmPersonal = "EvmPersonal",
   JoyId = "JoyId",
+  NostrEvent = "NostrEvent",
 }
 
 /**
@@ -22,6 +24,7 @@ export enum SignerType {
   EVM = "EVM",
   BTC = "BTC",
   CKB = "CKB",
+  Nostr = "Nostr",
 }
 
 export class Signature {
@@ -69,17 +72,25 @@ export abstract class Signer {
           signature.signature,
           signature.identity,
         );
+      case SignerSignType.NostrEvent:
+        return verifyMessageNostrEvent(
+          message,
+          signature.signature,
+          signature.identity,
+        );
       case SignerSignType.Unknown:
         throw new Error("Unknown signer sign type");
     }
   }
 
   /**
-   * Construct a new signer with the client replaced.
-   *
-   * @returns A promise that resolves the new Signer.
+   * Replace the current client.
+   * returns false if the new client is invalid for this signer.
    */
-  abstract replaceClient(client: Client): Promise<Signer>;
+  async replaceClient(client: Client): Promise<boolean> {
+    this.client_ = client;
+    return true;
+  }
 
   /**
    * Connects to the signer.
@@ -88,13 +99,6 @@ export abstract class Signer {
    */
   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.
    *

package/src/utils/index.ts

@@ -1,21 +1,70 @@
+/**
+ * A type safe way to apply a transformer on a value if it's not empty.
+ *
+ * @param transformer - The transformer.
+ * @param value - The value to be transformed.
+ * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ */
 export function apply<T, R>(
   transformer: (val: T) => R,
   value: undefined,
 ): undefined;
+/**
+ * A type safe way to apply a transformer on a value if it's not empty.
+ *
+ * @param transformer - The transformer.
+ * @param value - The value to be transformed.
+ * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ */
 export function apply<T, R>(transformer: (val: T) => R, value: null): null;
+/**
+ * A type safe way to apply a transformer on a value if it's not empty.
+ *
+ * @param transformer - The transformer.
+ * @param value - The value to be transformed.
+ * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ */
 export function apply<T, R>(transformer: (val: T) => R, value: T): R;
+/**
+ * A type safe way to apply a transformer on a value if it's not empty.
+ *
+ * @param transformer - The transformer.
+ * @param value - The value to be transformed.
+ * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ */
 export function apply<T, R>(
   transformer: (val: T) => R,
   value: T | undefined,
 ): R | undefined;
+/**
+ * A type safe way to apply a transformer on a value if it's not empty.
+ *
+ * @param transformer - The transformer.
+ * @param value - The value to be transformed.
+ * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ */
 export function apply<T, R>(
   transformer: (val: T) => R,
   value: T | null,
 ): R | null;
+/**
+ * A type safe way to apply a transformer on a value if it's not empty.
+ *
+ * @param transformer - The transformer.
+ * @param value - The value to be transformed.
+ * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ */
 export function apply<T, R>(
   transformer: (val: T) => R,
   value: undefined | null,
 ): undefined | null;
+/**
+ * A type safe way to apply a transformer on a value if it's not empty.
+ *
+ * @param transformer - The transformer.
+ * @param value - The value to be transformed.
+ * @returns If the value is empty, it remains its type. Otherwise it will be transformed.
+ */
 export function apply<T, R>(
   transformer: (val: T) => R,
   value: T | undefined | null,
@@ -27,6 +76,65 @@ export function apply<T, R>(
   return transformer(value);
 }
 
+/**
+ * Similar to Array.reduce, but the accumulator can returns Promise.
+ *
+ * @param values - The array to be reduced.
+ * @param accumulator - A callback to be called for each value. If it returns null, the previous result will be kept.
+ * @returns The accumulated result.
+ */
+export async function reduceAsync<T, V>(
+  values: T[],
+  accumulator: (
+    a: T,
+    b: T,
+  ) => Promise<T | undefined | null | void> | T | undefined | null | void,
+): Promise<T>;
+/**
+ * Similar to Array.reduce, but the accumulator can returns Promise.
+ *
+ * @param values - The array to be reduced.
+ * @param accumulator - A callback to be called for each value. If it returns null, the previous result will be kept.
+ * @param init - The initial value.
+ * @returns The accumulated result.
+ */
+export async function reduceAsync<T, V>(
+  values: V[],
+  accumulator: (
+    a: T,
+    b: V,
+    i: number,
+    values: V[],
+  ) => Promise<T | undefined | null | void> | T | undefined | null | void,
+  init: T,
+): Promise<T>;
+export async function reduceAsync<T, V>(
+  values: (V | T)[],
+  accumulator: (
+    a: T,
+    b: T | V,
+    i: number,
+    values: (V | T)[],
+  ) => Promise<T | undefined | null | void> | T | undefined | null | void,
+  init?: T,
+): Promise<T> {
+  if (init === undefined) {
+    if (values.length === 0) {
+      throw new TypeError("Reduce of empty array with no initial value");
+    }
+    init = values[0] as T;
+    values = values.slice(1);
+  }
+
+  return values.reduce(
+    (current: Promise<T>, b: T | V, i, array) =>
+      current.then((v) =>
+        Promise.resolve(accumulator(v, b, i, array)).then((r) => r ?? v),
+      ),
+    Promise.resolve(init),
+  );
+}
+
 export function isWebview(userAgent: string): boolean {
   return /webview|wv|ip((?!.*Safari)|(?=.*like Safari))/i.test(userAgent);
 }