@ckb-ccc/core 0.0.8-alpha.3 → 0.0.9-alpha.0

package/src/client/client.ts

@@ -34,6 +34,7 @@ export enum KnownScript {
   COTA = "COTA",
   OmniLock = "OmniLock",
   NostrLock = "NostrLock",
+  UniqueType = "UniqueType",
   SingleUseLock = "SingleUseLock",
   OutputTypeProxyLock = "OutputTypeProxyLock",
 }

package/src/client/clientPublicMainnet.advanced.ts

@@ -147,7 +147,46 @@ export const MAINNET_SCRIPTS: Record<
       },
     ],
   },
-  [KnownScript.NostrLock]: undefined,
+  [KnownScript.NostrLock]: {
+    codeHash:
+      "0x641a89ad2f77721b803cd50d01351c1f308444072d5fa20088567196c0574c68",
+    hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x1911208b136957d5f7c1708a8835edfe8ae1d02700d5cb2c3a6aacf4d5906306",
+            index: 0,
+          },
+          depType: "code",
+        },
+        type: {
+          codeHash:
+            "0x00000000000000000000000000000000000000000000000000545950455f4944",
+          hashType: "type",
+          args: "0xfad8cb75eb0bb01718e2336002064568bc05887af107f74ed5dd501829e192f8",
+        },
+      },
+    ],
+  },
+  [KnownScript.UniqueType]: {
+    codeHash:
+      "0x2c8c11c985da60b0a330c61a85507416d6382c130ba67f0c47ab071e00aec628",
+    hashType: "data1",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0x67524c01c0cb5492e499c7c7e406f2f9d823e162d6b0cf432eacde0c9808c2ad",
+            index: 0,
+          },
+          depType: "code",
+        },
+      },
+    ],
+  },
   [KnownScript.SingleUseLock]: undefined,
   [KnownScript.OutputTypeProxyLock]: undefined,
 };

package/src/client/clientPublicTestnet.advanced.ts

@@ -175,6 +175,29 @@ export const TESTNET_SCRIPTS: Record<
       },
     ],
   },
+  [KnownScript.UniqueType]: {
+    codeHash:
+      "0x8e341bcfec6393dcd41e635733ff2dca00a6af546949f70c57a706c0f344df8b",
+    hashType: "type",
+    cellDeps: [
+      {
+        cellDep: {
+          outPoint: {
+            txHash:
+              "0xff91b063c78ed06f10a1ed436122bd7d671f9a72ef5f5fa28d05252c17cf4cef",
+            index: 0,
+          },
+          depType: "code",
+        },
+        type: {
+          codeHash:
+            "0x00000000000000000000000000000000000000000000000000545950455f4944",
+          hashType: "type",
+          args: "0xe04976b67600fd25ac50305f77b33aee2c12e3c18e63ece9119e5b32117884b5",
+        },
+      },
+    ],
+  },
   [KnownScript.SingleUseLock]: {
     codeHash:
       "0x8290467a512e5b9a6b816469b0edabba1f4ac474e28ffdd604c2a7c76446bbaf",

package/src/hasher/index.ts

@@ -1,6 +1,8 @@
 import blake2b, { Blake2b } from "blake2b";
 import { BytesLike, bytesFrom } from "../bytes";
+import { CellInput, CellInputLike } from "../ckb";
 import { Hex } from "../hex";
+import { NumLike, numLeToBytes } from "../num";
 import { CKB_BLAKE2B_PERSONAL } from "./advanced";
 
 export class Hasher {
@@ -67,12 +69,35 @@ export class Hasher {
  *
  * @example
  * ```typescript
- * const hash = ckbHash("some data"); // Outputs something like "0x..."
+ * const hash = hashCkb("some data"); // Outputs something like "0x..."
  * ```
  */
 
-export function ckbHash(...data: BytesLike[]): Hex {
+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),
+  );
+}

package/src/signer/nostr/signerNostr.ts

@@ -3,7 +3,7 @@ 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 { hashCkb } from "../../hasher";
 import { Hex, hexFrom } from "../../hex";
 import { Signer, SignerSignType, SignerType } from "../signer";
 import { buildNostrEventFromMessage } from "./verify";
@@ -80,7 +80,7 @@ export abstract class SignerNostr extends Signer {
       await Address.fromKnownScript(
         this.client,
         KnownScript.NostrLock,
-        hexFrom(bytesConcat([0x00], ckbHash(publicKey).slice(0, 42))),
+        hexFrom(bytesConcat([0x00], hashCkb(publicKey).slice(0, 42))),
       ),
     ];
   }

package/src/signer/signer/index.ts

@@ -27,6 +27,23 @@ export enum SignerType {
   Nostr = "Nostr",
 }
 
+export type NetworkPreference = {
+  addressPrefix: string;
+  signerType: SignerType;
+  network: string;
+  /*
+    Wallet signers should check if the wallet is using preferred networks.
+    If not, try to switch to the first preferred network.
+    If non preferred, let users choose what they want.
+
+    BTC: // They made a mess...
+      btc
+      btcTestnet
+      btcSignet // OKX
+      fractalBtc // UniSat
+  */
+};
+
 export class Signature {
   constructor(
     public signature: string,
@@ -49,6 +66,27 @@ export abstract class Signer {
     return this.client_;
   }
 
+  // Returns the preference if we need to switch network
+  // undefined otherwise
+  matchNetworkPreference(
+    preferences: NetworkPreference[],
+    currentNetwork: string,
+  ) {
+    if (
+      preferences.some(({ signerType, addressPrefix, network }) => {
+        signerType === this.type &&
+          addressPrefix === this.client.addressPrefix &&
+          network === currentNetwork;
+      })
+    ) {
+      return;
+    }
+    return preferences.find(
+      ({ signerType, addressPrefix }) =>
+        signerType === this.type && addressPrefix === this.client.addressPrefix,
+    );
+  }
+
   static async verifyMessage(
     message: string | BytesLike,
     signature: Signature,
@@ -99,6 +137,13 @@ export abstract class Signer {
    */
   abstract connect(): Promise<void>;
 
+  /**
+   * Disconnects to the signer.
+   *
+   * @returns A promise that resolves when the signer is disconnected.
+   */
+  async disconnect(): Promise<void> {}
+
   /**
    * Check if the signer is connected.
    *