@ckb-ccc/core 0.1.0-alpha.6 → 0.1.0

package/src/molecule/predefined.ts

@@ -0,0 +1,114 @@
+import { bytesFrom, bytesTo } from "../bytes/index.js";
+import * as ckb from "../ckb/index.js";
+import { Hex, hexFrom, HexLike } from "../hex/index.js";
+import {
+  byteVec,
+  Codec,
+  option,
+  struct,
+  table,
+  uint,
+  uintNumber,
+  vector,
+} from "./codec.js";
+
+export const Uint8 = uintNumber(1, true);
+export const Uint16LE = uintNumber(2, true);
+export const Uint16BE = uintNumber(2);
+export const Uint16 = Uint16LE;
+export const Uint32LE = uintNumber(4, true);
+export const Uint32BE = uintNumber(4);
+export const Uint32 = Uint32LE;
+export const Uint64LE = uint(8, true);
+export const Uint64BE = uint(8);
+export const Uint64 = Uint64LE;
+export const Uint128LE = uint(16, true);
+export const Uint128BE = uint(16);
+export const Uint128 = Uint128LE;
+export const Uint256LE = uint(32, true);
+export const Uint256BE = uint(32);
+export const Uint256 = Uint256LE;
+export const Uint512LE = uint(64, true);
+export const Uint512BE = uint(64);
+export const Uint512 = Uint512LE;
+
+export const Uint8Opt = option(Uint8);
+export const Uint16Opt = option(Uint16);
+export const Uint32Opt = option(Uint32);
+export const Uint64Opt = option(Uint64);
+export const Uint128Opt = option(Uint128);
+export const Uint256Opt = option(Uint256);
+export const Uint512Opt = option(Uint512);
+
+export const Bytes: Codec<HexLike, Hex> = byteVec({
+  encode: (value) => bytesFrom(value),
+  decode: (buffer) => hexFrom(buffer),
+});
+export const BytesOpt = option(Bytes);
+export const BytesVec = vector(Bytes);
+
+export const Byte32: Codec<HexLike, Hex> = Codec.from({
+  byteLength: 32,
+  encode: (value) => bytesFrom(value),
+  decode: (buffer) => hexFrom(buffer),
+});
+export const Byte32Opt = option(Byte32);
+export const Byte32Vec = vector(Byte32);
+
+export const String = byteVec({
+  encode: (value: string) => bytesFrom(value, "utf8"),
+  decode: (buffer) => bytesTo(buffer, "utf8"),
+});
+export const StringVec = vector(String);
+export const StringOpt = option(String);
+
+export const Hash = Byte32;
+export const HashType: Codec<ckb.HashTypeLike, ckb.HashType> = Codec.from({
+  byteLength: 1,
+  encode: ckb.hashTypeToBytes,
+  decode: ckb.hashTypeFromBytes,
+});
+export const Script: Codec<ckb.ScriptLike, ckb.Script> = table({
+  codeHash: Hash,
+  hashType: HashType,
+  args: Bytes,
+}).map({ outMap: ckb.Script.from });
+export const ScriptOpt = option(Script);
+
+export const OutPoint: Codec<ckb.OutPointLike, ckb.OutPoint> = struct({
+  txHash: Hash,
+  index: Uint32,
+}).map({ outMap: ckb.OutPoint.from });
+export const CellInput: Codec<ckb.CellInputLike, ckb.CellInput> = struct({
+  previousOutput: OutPoint,
+  since: Uint64,
+}).map({ outMap: ckb.CellInput.from });
+export const CellInputVec = vector(CellInput);
+
+export const CellOutput: Codec<ckb.CellOutputLike, ckb.CellOutput> = table({
+  capacity: Uint64,
+  lock: Script,
+  type: ScriptOpt,
+}).map({ outMap: ckb.CellOutput.from });
+export const CellOutputVec = vector(CellOutput);
+
+export const DepType: Codec<ckb.DepTypeLike, ckb.DepType> = Codec.from({
+  byteLength: 1,
+  encode: ckb.depTypeToBytes,
+  decode: ckb.depTypeFromBytes,
+});
+export const CellDep: Codec<ckb.CellDepLike, ckb.CellDep> = struct({
+  outPoint: OutPoint,
+  depType: DepType,
+}).map({ outMap: ckb.CellDep.from });
+export const CellDepVec = vector(CellDep);
+
+export const Transaction: Codec<ckb.TransactionLike, ckb.Transaction> = table({
+  version: Uint32,
+  cellDeps: CellDepVec,
+  headerDeps: Byte32Vec,
+  inputs: CellInputVec,
+  outputs: CellOutputVec,
+  outputsData: BytesVec,
+  witnesses: BytesVec,
+}).map({ outMap: ckb.Transaction.from });

package/src/signer/btc/signerBtc.ts

@@ -1,5 +1,3 @@
-import { ripemd160 } from "@noble/hashes/ripemd160";
-import { sha256 } from "@noble/hashes/sha256";
 import { Address } from "../../address/index.js";
 import { bytesConcat, bytesFrom } from "../../bytes/index.js";
 import { Transaction, TransactionLike, WitnessArgs } from "../../ckb/index.js";
@@ -7,6 +5,7 @@ import { KnownScript } from "../../client/index.js";
 import { HexLike, hexFrom } from "../../hex/index.js";
 import { numToBytes } from "../../num/index.js";
 import { Signer, SignerSignType, SignerType } from "../signer/index.js";
+import { btcEcdsaPublicKeyHash } from "./verify.js";
 
 /**
  * An abstract class extending the Signer class for Bitcoin-like signing operations.
@@ -62,7 +61,7 @@ export abstract class SignerBtc extends Signer {
    */
   async getAddressObjs(): Promise<Address[]> {
     const publicKey = await this.getBtcPublicKey();
-    const hash = ripemd160(sha256(bytesFrom(publicKey)));
+    const hash = btcEcdsaPublicKeyHash(publicKey);
 
     return [
       await Address.fromKnownScript(

package/src/signer/btc/verify.ts

@@ -1,7 +1,36 @@
 import { secp256k1 } from "@noble/curves/secp256k1";
+import { ripemd160 } from "@noble/hashes/ripemd160";
+import { sha256 } from "@noble/hashes/sha256";
 import { magicHash } from "bitcoinjs-message";
-import { BytesLike, bytesFrom } from "../../bytes/index.js";
-import { hexFrom } from "../../hex/index.js";
+import bs58check from "bs58check";
+import { Bytes, BytesLike, bytesConcat, bytesFrom } from "../../bytes/index.js";
+import { Hex, hexFrom } from "../../hex/index.js";
+
+/**
+ * @public
+ */
+export function btcEcdsaPublicKeyHash(publicKey: BytesLike): Bytes {
+  return ripemd160(sha256(bytesFrom(publicKey)));
+}
+
+/**
+ * @public
+ */
+export function btcP2pkhAddressFromPublicKey(
+  publicKey: BytesLike,
+  network: number,
+): string {
+  return bs58check.encode(
+    bytesConcat([network], btcEcdsaPublicKeyHash(publicKey)),
+  );
+}
+
+/**
+ * @public
+ */
+export function btcPublicKeyFromP2pkhAddress(address: string): Hex {
+  return hexFrom(bs58check.decode(address).slice(1));
+}
 
 /**
  * @public

package/src/signer/doge/index.ts

@@ -0,0 +1,4 @@
+export * from "./signerDoge.js";
+export * from "./signerDogeAddressReadonly.js";
+export * from "./signerDogePrivateKey.js";
+export * from "./verify.js";

package/src/signer/doge/signerDoge.ts

@@ -0,0 +1,116 @@
+import bs58check from "bs58check";
+import { Address } from "../../address/index.js";
+import { bytesConcat, bytesFrom } from "../../bytes/index.js";
+import { Transaction, TransactionLike, WitnessArgs } from "../../ckb/index.js";
+import { KnownScript } from "../../client/index.js";
+import { hexFrom } from "../../hex/index.js";
+import { numToBytes } from "../../num/index.js";
+import { Signer, SignerSignType, SignerType } from "../signer/index.js";
+
+/**
+ * An abstract class extending the Signer class for Dogecoin-like signing operations.
+ * This class provides methods to get Doge account, public key, and internal address,
+ * as well as signing transactions.
+ * @public
+ */
+export abstract class SignerDoge extends Signer {
+  get type(): SignerType {
+    return SignerType.Doge;
+  }
+
+  get signType(): SignerSignType {
+    return SignerSignType.DogeEcdsa;
+  }
+
+  /**
+   * Gets the Doge address associated with the signer.
+   *
+   * @returns A promise that resolves to a string representing the Doge account.
+   */
+  abstract getDogeAddress(): Promise<string>;
+
+  /**
+   * Gets the internal address, which is the Doge account in this case.
+   *
+   * @returns A promise that resolves to a string representing the internal address.
+   */
+  async getInternalAddress(): Promise<string> {
+    return this.getDogeAddress();
+  }
+
+  /**
+   * Gets the identity, which is the Doge address in this case.
+   *
+   * @returns A promise that resolves to a string representing the identity
+   */
+  async getIdentity(): Promise<string> {
+    return this.getDogeAddress();
+  }
+
+  /**
+   * 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 hash = bs58check.decode(await this.getDogeAddress()).slice(1);
+
+    return [
+      await Address.fromKnownScript(
+        this.client,
+        KnownScript.OmniLock,
+        hexFrom([0x05, ...hash, 0x00]),
+      ),
+    ];
+  }
+
+  /**
+   * prepare a transaction before signing. This method is not implemented and should be overridden by subclasses.
+   *
+   * @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.OmniLock);
+    await tx.prepareSighashAllWitness(script, 85, 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> {
+    const tx = Transaction.from(txLike);
+    const { script } = await this.getRecommendedAddressObj();
+    const info = await tx.getSignHashInfo(script, this.client);
+    if (!info) {
+      return tx;
+    }
+
+    const signature = bytesFrom(
+      await this.signMessageRaw(info.message.slice(2)),
+      "base64",
+    );
+    signature[0] = 31 + ((signature[0] - 27) % 4);
+
+    const witness = WitnessArgs.fromBytes(tx.witnesses[info.position]);
+    witness.lock = hexFrom(
+      bytesConcat(
+        numToBytes(5 * 4 + signature.length, 4),
+        numToBytes(4 * 4, 4),
+        numToBytes(5 * 4 + signature.length, 4),
+        numToBytes(5 * 4 + signature.length, 4),
+        numToBytes(signature.length, 4),
+        signature,
+      ),
+    );
+
+    tx.setWitnessArgsAt(info.position, witness);
+    return tx;
+  }
+}

package/src/signer/doge/signerDogeAddressReadonly.ts

@@ -0,0 +1,52 @@
+import { Client } from "../../client/index.js";
+import { SignerDoge } from "./signerDoge.js";
+
+/**
+ * A class extending SignerDoge that provides read-only access to a Doge address.
+ * This class does not support signing operations.
+ * @public
+ */
+export class SignerDogeAddressReadonly extends SignerDoge {
+  /**
+   * Creates an instance of SignerDogeAddressReadonly.
+   *
+   * @param client - The client instance used for communication.
+   * @param address - The Doge address with the signer.
+   */
+  constructor(
+    client: Client,
+    private readonly address: string,
+  ) {
+    super(client);
+  }
+
+  /**
+   * Connects to the client. This implementation does nothing as the class is read-only.
+   *
+   * @returns A promise that resolves when the connection is complete.
+   */
+  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 Doge address associated with the signer.
+   *
+   * @returns A promise that resolves to a string representing the Doge address.
+   *
+   * @example
+   * ```typescript
+   * const account = await signer.getDogeAddress(); // Outputs the Doge address
+   * ```
+   */
+  async getDogeAddress(): Promise<string> {
+    return this.address;
+  }
+}

package/src/signer/doge/signerDogePrivateKey.ts

@@ -0,0 +1,97 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { magicHash } from "bitcoinjs-message";
+import {
+  Bytes,
+  bytesConcat,
+  bytesFrom,
+  BytesLike,
+  bytesTo,
+} from "../../bytes/index.js";
+import { Client } from "../../client/index.js";
+import { Hex, hexFrom } from "../../hex/index.js";
+import { btcP2pkhAddressFromPublicKey } from "../btc/verify.js";
+import { SignerDoge } from "./signerDoge.js";
+
+/**
+ * A class extending SignerDoge that provides access to a Doge address.
+ * @public
+ */
+export class SignerDogePrivateKey extends SignerDoge {
+  private readonly privateKey: Bytes;
+
+  /**
+   * Creates an instance of SignerDogePrivateKey
+   *
+   * @param client - The client instance used for communication.
+   * @param privateKey - The Doge private key with the signer.
+   */
+  constructor(
+    client: Client,
+    privateKey: BytesLike,
+    public readonly dogeNetwork = 0x1e,
+  ) {
+    super(client);
+    this.privateKey = bytesFrom(privateKey);
+    if (this.privateKey.length !== 32) {
+      throw new Error("Private key must be 32 bytes!");
+    }
+  }
+
+  /**
+   * Connects to the client. This implementation does nothing as the class is always connected.
+   *
+   * @returns A promise that resolves when the connection is complete.
+   */
+  async connect(): Promise<void> {}
+
+  /**
+   * Check if the signer is connected.
+   *
+   * @returns A promise that resolves the connection status.
+   */
+  async isConnected(): Promise<boolean> {
+    return true;
+  }
+
+  async getDogePublicKey(): Promise<Hex> {
+    return hexFrom(secp256k1.getPublicKey(this.privateKey, true));
+  }
+
+  /**
+   * Gets the Doge address associated with the signer.
+   *
+   * @returns A promise that resolves to a string representing the Doge address.
+   *
+   * @example
+   * ```typescript
+   * const account = await signer.getDogeAddress(); // Outputs the Doge address
+   * ```
+   */
+  async getDogeAddress(): Promise<string> {
+    return btcP2pkhAddressFromPublicKey(
+      await this.getDogePublicKey(),
+      this.dogeNetwork,
+    );
+  }
+
+  /**
+   * Signs a message and returns signature only.
+   *
+   * @param msg - The message to sign, as a string or BytesLike object.
+   * @returns A promise that resolves to the signature as a string.
+   * @throws Will throw an error if not implemented.
+   */
+  async signMessageRaw(msg: string | BytesLike): Promise<string> {
+    const challenge = typeof msg === "string" ? msg : hexFrom(msg).slice(2);
+
+    const signature = secp256k1.sign(
+      magicHash(challenge, "\x19Dogecoin Signed Message:\n"),
+      this.privateKey,
+    );
+
+    return bytesTo(
+      bytesConcat([31 + signature.recovery], signature.toCompactRawBytes()),
+      "base64",
+    );
+  }
+}

package/src/signer/doge/verify.ts

@@ -0,0 +1,38 @@
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { magicHash } from "bitcoinjs-message";
+import { bytesFrom, BytesLike } from "../../bytes/index.js";
+import { hexFrom } from "../../hex/index.js";
+import {
+  btcEcdsaPublicKeyHash,
+  btcPublicKeyFromP2pkhAddress,
+} from "../btc/verify.js";
+
+/**
+ * @public
+ */
+export function verifyMessageDogeEcdsa(
+  message: string | BytesLike,
+  signature: string,
+  address: string,
+): boolean {
+  const challenge =
+    typeof message === "string" ? message : hexFrom(message).slice(2);
+  const [recoveryBit, ...rawSign] = bytesFrom(signature, "base64");
+
+  const sig = secp256k1.Signature.fromCompact(
+    hexFrom(rawSign).slice(2),
+  ).addRecoveryBit(recoveryBit - 31);
+
+  return (
+    btcPublicKeyFromP2pkhAddress(address) ===
+    hexFrom(
+      btcEcdsaPublicKeyHash(
+        sig
+          .recoverPublicKey(
+            magicHash(challenge, "\x19Dogecoin Signed Message:\n"),
+          )
+          .toHex(),
+      ),
+    )
+  );
+}

package/src/signer/index.ts

@@ -1,5 +1,6 @@
 export * from "./btc/index.js";
 export * from "./ckb/index.js";
+export * from "./doge/index.js";
 export * from "./dummy/index.js";
 export * from "./evm/index.js";
 export * from "./nostr/index.js";

package/src/signer/nostr/index.ts

@@ -1 +1,2 @@
 export * from "./signerNostr.js";
+export * from "./verify.js";

package/src/signer/signer/index.ts

@@ -12,6 +12,7 @@ import { Num } from "../../num/index.js";
 import { verifyMessageBtcEcdsa } from "../btc/index.js";
 import { verifyMessageCkbSecp256k1 } from "../ckb/verifyCkbSecp256k1.js";
 import { verifyMessageJoyId } from "../ckb/verifyJoyId.js";
+import { verifyMessageDogeEcdsa } from "../doge/verify.js";
 import { verifyMessageEvmPersonal } from "../evm/verify.js";
 import { verifyMessageNostrEvent } from "../nostr/verify.js";
 
@@ -25,6 +26,7 @@ export enum SignerSignType {
   JoyId = "JoyId",
   NostrEvent = "NostrEvent",
   CkbSecp256k1 = "CkbSecp256k1",
+  DogeEcdsa = "DogeEcdsa",
 }
 
 /**
@@ -36,6 +38,7 @@ export enum SignerType {
   BTC = "BTC",
   CKB = "CKB",
   Nostr = "Nostr",
+  Doge = "Doge",
 }
 
 /**
@@ -141,6 +144,12 @@ export abstract class Signer {
           signature.signature,
           signature.identity,
         );
+      case SignerSignType.DogeEcdsa:
+        return verifyMessageDogeEcdsa(
+          message,
+          signature.signature,
+          signature.identity,
+        );
       case SignerSignType.Unknown:
         throw new Error("Unknown signer sign type");
     }