@ckb-ccc/core 1.19.1 → 1.20.1

package/src/molecule/codec.ts

@@ -85,7 +85,7 @@ export function fixedItemVec<Encodable, Decoded>(
           `fixedItemVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`,
         );
       }
-      const itemCount = uint32From(value.slice(0, 4));
+      const itemCount = uint32From(value.subarray(0, 4));
       const byteLength = 4 + itemCount * itemByteLength;
       if (value.byteLength !== byteLength) {
         throw new Error(
@@ -98,7 +98,7 @@ export function fixedItemVec<Encodable, Decoded>(
         for (let offset = 4; offset < byteLength; offset += itemByteLength) {
           decodedArray.push(
             itemCodec.decode(
-              value.slice(offset, offset + itemByteLength),
+              value.subarray(offset, offset + itemByteLength),
               config,
             ),
           );
@@ -145,7 +145,7 @@ export function dynItemVec<Encodable, Decoded>(
           `dynItemVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`,
         );
       }
-      const byteLength = uint32From(value.slice(0, 4));
+      const byteLength = uint32From(value.subarray(0, 4));
       if (byteLength !== value.byteLength) {
         throw new Error(
           `dynItemVec: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`,
@@ -156,10 +156,10 @@ export function dynItemVec<Encodable, Decoded>(
         return [];
       }
 
-      const offset = uint32From(value.slice(4, 8));
+      const offset = uint32From(value.subarray(4, 8));
       const itemCount = (offset - 4) / 4;
       const offsets = Array.from(new Array(itemCount), (_, index) =>
-        uint32From(value.slice(4 + index * 4, 8 + index * 4)),
+        uint32From(value.subarray(4 + index * 4, 8 + index * 4)),
       );
       offsets.push(byteLength);
       try {
@@ -167,7 +167,7 @@ export function dynItemVec<Encodable, Decoded>(
         for (let index = 0; index < offsets.length - 1; index++) {
           const start = offsets[index];
           const end = offsets[index + 1];
-          const itemBuffer = value.slice(start, end);
+          const itemBuffer = value.subarray(start, end);
           decodedArray.push(itemCodec.decode(itemBuffer, config));
         }
         return decodedArray;
@@ -250,14 +250,14 @@ export function byteVec<Encodable, Decoded>(
           `byteVec: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`,
         );
       }
-      const byteLength = uint32From(value.slice(0, 4));
+      const byteLength = uint32From(value.subarray(0, 4));
       if (byteLength !== value.byteLength - 4) {
         throw new Error(
           `byteVec: invalid buffer size, expected ${byteLength}, but got ${value.byteLength}`,
         );
       }
       try {
-        return codec.decode(value.slice(4), config);
+        return codec.decode(value.subarray(4), config);
       } catch (e: unknown) {
         throw new Error(`byteVec - ${getMessage(e)}`, { cause: e });
       }
@@ -331,8 +331,8 @@ export function table<
           `table: too short buffer, expected at least 4 bytes, but got ${value.byteLength}`,
         );
       }
-      const byteLength = uint32From(value.slice(0, 4));
-      const headerLength = uint32From(value.slice(4, 8));
+      const byteLength = uint32From(value.subarray(0, 4));
+      const headerLength = uint32From(value.subarray(4, 8));
       const actualFieldCount = (headerLength - 4) / 4;
 
       if (byteLength !== value.byteLength) {
@@ -353,12 +353,12 @@ export function table<
         );
       }
       const offsets = keys.map((_, index) =>
-        uint32From(value.slice(4 + index * 4, 8 + index * 4)),
+        uint32From(value.subarray(4 + index * 4, 8 + index * 4)),
       );
       // If there are extra fields, add the last offset to the offsets array
       if (actualFieldCount > keys.length) {
         offsets.push(
-          uint32From(value.slice(4 + keys.length * 4, 8 + keys.length * 4)),
+          uint32From(value.subarray(4 + keys.length * 4, 8 + keys.length * 4)),
         );
       } else {
         // If there are no extra fields, add the byte length to the offsets array
@@ -370,7 +370,7 @@ export function table<
         const end = offsets[i + 1];
         const field = keys[i];
         const codec = codecLayout[field];
-        const payload = value.slice(start, end);
+        const payload = value.subarray(start, end);
         try {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           Object.assign(object, { [field]: codec.decode(payload, config) });
@@ -501,7 +501,7 @@ export function union<T extends Record<string, CodecLike<any, any>>>(
     },
     decode(buffer, config) {
       const value = bytesFrom(buffer);
-      const fieldIndex = uint32From(value.slice(0, 4));
+      const fieldIndex = uint32From(value.subarray(0, 4));
       const keys = Object.keys(codecLayout);
 
       const field = (() => {
@@ -529,7 +529,7 @@ export function union<T extends Record<string, CodecLike<any, any>>>(
       return {
         type: field,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        value: codecLayout[field].decode(value.slice(4), config),
+        value: codecLayout[field].decode(value.subarray(4), config),
       } as UnionDecoded<T>;
     },
   });
@@ -573,7 +573,7 @@ export function struct<
       const object = {};
       let offset = 0;
       Object.entries(codecLayout).forEach(([key, codec]) => {
-        const payload = value.slice(offset, offset + codec.byteLength!);
+        const payload = value.subarray(offset, offset + codec.byteLength!);
         try {
           // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           Object.assign(object, { [key]: codec.decode(payload, config) });
@@ -627,7 +627,10 @@ export function array<Encodable, Decoded>(
         const result: Array<Decoded> = [];
         for (let i = 0; i < value.byteLength; i += itemCodec.byteLength!) {
           result.push(
-            itemCodec.decode(value.slice(i, i + itemCodec.byteLength!), config),
+            itemCodec.decode(
+              value.subarray(i, i + itemCodec.byteLength!),
+              config,
+            ),
           );
         }
         return result;

package/src/signer/advanced.ts

@@ -0,0 +1 @@
+export * from "./jsonRpc/transformers.js";

package/src/signer/btc/verify.ts

@@ -78,7 +78,7 @@ export function btcP2pkhAddressFromPublicKey(
  * @public
  */
 export function btcPublicKeyFromP2pkhAddress(address: string): Hex {
-  return hexFrom(bs58check.decode(address).slice(1));
+  return hexFrom(bs58check.decode(address).subarray(1));
 }
 
 /**
@@ -92,7 +92,7 @@ export function verifyMessageBtcEcdsa(
   const challenge =
     typeof message === "string" ? message : hexFrom(message).slice(2);
 
-  const rawSign = bytesFrom(signature, "base64").slice(1);
+  const rawSign = bytesFrom(signature, "base64").subarray(1);
 
   return secp256k1.verify(
     bytesFrom(rawSign),

package/src/signer/ckb/secp256k1Signing.ts

@@ -21,7 +21,7 @@ export function signMessageSecp256k1(
     format: "recovered",
     prehash: false,
   });
-  return hexFrom(bytesConcat(signature.slice(1), signature.slice(0, 1)));
+  return hexFrom(bytesConcat(signature.subarray(1), signature.subarray(0, 1)));
 }
 
 /**
@@ -40,7 +40,7 @@ export function verifyMessageSecp256k1(
 ): boolean {
   const signatureBytes = bytesFrom(signature);
   return secp256k1.verify(
-    bytesConcat(signatureBytes.slice(64), signatureBytes.slice(0, 64)),
+    bytesConcat(signatureBytes.subarray(64), signatureBytes.subarray(0, 64)),
     bytesFrom(message),
     bytesFrom(publicKey),
     { format: "recovered", prehash: false },
@@ -62,7 +62,7 @@ export function recoverMessageSecp256k1(
   const signatureBytes = bytesFrom(signature);
   return hexFrom(
     secp256k1.recoverPublicKey(
-      bytesConcat(signatureBytes.slice(64), signatureBytes.slice(0, 64)),
+      bytesConcat(signatureBytes.subarray(64), signatureBytes.subarray(0, 64)),
       bytesFrom(message),
       { prehash: false },
     ),

package/src/signer/doge/signerDoge.ts

@@ -53,7 +53,7 @@ export abstract class SignerDoge extends 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);
+    const hash = bs58check.decode(await this.getDogeAddress()).subarray(1);
 
     return [
       await Address.fromKnownScript(

package/src/signer/doge/signerDogePrivateKey.ts

@@ -93,7 +93,7 @@ export class SignerDogePrivateKey extends SignerDoge {
       },
     );
     return bytesTo(
-      bytesConcat([31 + Number(signature[0])], signature.slice(1)),
+      bytesConcat([31 + Number(signature[0])], signature.subarray(1)),
       "base64",
     );
   }

package/src/signer/index.ts

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

package/src/signer/jsonRpc/handler.ts

@@ -0,0 +1,217 @@
+import type { Transaction } from "../../ckb/index.js";
+import { JsonRpcTransformers } from "../../client/jsonRpc/advanced.js";
+import { JsonRpcError, type JsonRpcPayload } from "../../jsonRpc/index.js";
+import type { Signer } from "../signer/index.js";
+import { signerJsonRpcNetworkIdFromAddressPrefix } from "./network.js";
+import {
+  SignerJsonRpcTransformers,
+  type SignerJsonRpcInfo,
+  type SignerJsonRpcMessageToSign,
+} from "./transformers.js";
+
+export type SignerJsonRpcConfirmation =
+  | { method: "connect"; networkId: string }
+  | { method: "sign_message"; message: SignerJsonRpcMessageToSign }
+  | { method: "sign_transaction"; transaction: Transaction };
+
+export type SignerJsonRpcHandlerConfig = {
+  getSigner: () => Signer | undefined;
+  getSignerMetadata?: () => Pick<SignerJsonRpcInfo, "name" | "icon">;
+  /** Connects the requested network and returns its connected Signer. */
+  connect: (networkId: string) => Promise<Signer>;
+  confirmRequest: (request: SignerJsonRpcConfirmation) => Promise<boolean>;
+};
+
+export type SignerJsonRpcHandler = (payload: JsonRpcPayload) => unknown;
+
+export function buildSignerJsonRpcHandler({
+  connect,
+  confirmRequest,
+  getSigner,
+  getSignerMetadata = () => ({}),
+}: SignerJsonRpcHandlerConfig): SignerJsonRpcHandler {
+  const requireSigner = () => {
+    const signer = getSigner();
+    if (!signer) {
+      throw new JsonRpcError({
+        code: -32000,
+        message: "No signer is connected",
+      });
+    }
+
+    return signer;
+  };
+
+  const handlers = new Map<string, SignerJsonRpcHandler>([
+    [
+      "get_info",
+      (payload) => {
+        requireParams(payload, 0);
+        return buildSignerInfo(requireSigner(), getSignerMetadata());
+      },
+    ],
+    [
+      "connect",
+      async (payload) => {
+        const [networkId] = requireParams(payload, 1);
+        if (typeof networkId !== "string" || !networkId) {
+          throw new JsonRpcError({
+            code: -32602,
+            message: "Invalid network ID",
+          });
+        }
+
+        await requireConfirmation(confirmRequest, {
+          method: "connect",
+          networkId,
+        });
+
+        const signer = await connect(networkId);
+        const actualNetworkId = signerJsonRpcNetworkIdFromAddressPrefix(
+          signer.client.addressPrefix,
+        );
+        if (actualNetworkId !== networkId) {
+          throw new JsonRpcError({
+            code: -32002,
+            message: `Signer uses ${actualNetworkId}, expected ${networkId}`,
+          });
+        }
+
+        return null;
+      },
+    ],
+    [
+      "get_scripts",
+      async (payload) => {
+        requireParams(payload, 0);
+        return (await requireSigner().getAddressObjs()).map(({ script }) =>
+          JsonRpcTransformers.scriptFrom(script),
+        );
+      },
+    ],
+    [
+      "get_native_address",
+      (payload) => {
+        requireParams(payload, 0);
+        return requireSigner().getInternalAddress();
+      },
+    ],
+    [
+      "get_identity",
+      (payload) => {
+        requireParams(payload, 0);
+        return requireSigner().getIdentity();
+      },
+    ],
+    [
+      "sign_message",
+      async (payload) => {
+        const [message] = requireParams(payload, 1);
+        const parsedMessage = parseMessageParam(message);
+        await requireConfirmation(confirmRequest, {
+          method: "sign_message",
+          message: SignerJsonRpcTransformers.messageFrom(parsedMessage),
+        });
+        return requireSigner().signMessageRaw(parsedMessage);
+      },
+    ],
+    [
+      "prepare_transaction",
+      async (payload) => {
+        const [transaction] = requireParams(payload, 1);
+        return JsonRpcTransformers.transactionFrom(
+          await requireSigner().prepareTransaction(
+            parseTransactionParam(transaction),
+          ),
+        );
+      },
+    ],
+    [
+      "sign_transaction",
+      async (payload) => {
+        const [transaction] = requireParams(payload, 1);
+        const parsedTransaction = parseTransactionParam(transaction);
+        await requireConfirmation(confirmRequest, {
+          method: "sign_transaction",
+          transaction: parsedTransaction,
+        });
+        return JsonRpcTransformers.transactionFrom(
+          await requireSigner().signOnlyTransaction(parsedTransaction),
+        );
+      },
+    ],
+  ]);
+
+  return (payload: JsonRpcPayload) => {
+    const handler = handlers.get(payload.method);
+    if (!handler) {
+      throw new JsonRpcError({
+        code: -32601,
+        message: `Unsupported method: ${payload.method}`,
+      });
+    }
+
+    return handler(payload);
+  };
+}
+
+async function requireConfirmation(
+  confirmRequest: SignerJsonRpcHandlerConfig["confirmRequest"],
+  request: SignerJsonRpcConfirmation,
+) {
+  if (!(await confirmRequest(request))) {
+    throw new JsonRpcError({
+      code: -32003,
+      message: "User rejected request",
+    });
+  }
+}
+
+function parseMessageParam(message: unknown) {
+  try {
+    return SignerJsonRpcTransformers.messageTo(message);
+  } catch (cause) {
+    throw new JsonRpcError({
+      code: -32602,
+      message:
+        cause instanceof Error ? cause.message : "Invalid signer message",
+    });
+  }
+}
+
+function parseTransactionParam(transaction: unknown) {
+  try {
+    return JsonRpcTransformers.transactionTo(
+      transaction as Parameters<typeof JsonRpcTransformers.transactionTo>[0],
+    );
+  } catch (cause) {
+    throw new JsonRpcError({
+      code: -32602,
+      message:
+        cause instanceof Error ? cause.message : "Invalid signer transaction",
+    });
+  }
+}
+
+function requireParams(payload: JsonRpcPayload, count: number) {
+  if (!Array.isArray(payload.params) || payload.params.length !== count) {
+    throw new JsonRpcError({
+      code: -32602,
+      message: `${payload.method} expects ${count} parameter${count === 1 ? "" : "s"}`,
+    });
+  }
+
+  return payload.params;
+}
+
+function buildSignerInfo(
+  signer: Signer,
+  metadata: Pick<SignerJsonRpcInfo, "name" | "icon">,
+) {
+  return SignerJsonRpcTransformers.infoFrom({
+    type: signer.type,
+    signType: signer.signType,
+    name: metadata.name,
+    icon: metadata.icon,
+  });
+}

package/src/signer/jsonRpc/index.ts

@@ -0,0 +1,2 @@
+export * from "./handler.js";
+export * from "./signer.js";

package/src/signer/jsonRpc/network.ts

@@ -0,0 +1,15 @@
+const CKB_MAINNET_NETWORK_ID = "ckb-mainnet";
+const CKB_TESTNET_NETWORK_ID = "ckb-testnet";
+
+// TODO: In the next major version, read the network ID directly from Client
+// instead of inferring it from addressPrefix.
+export function signerJsonRpcNetworkIdFromAddressPrefix(addressPrefix: string) {
+  if (addressPrefix === "ckb") {
+    return CKB_MAINNET_NETWORK_ID;
+  }
+  if (addressPrefix === "ckt") {
+    return CKB_TESTNET_NETWORK_ID;
+  }
+
+  throw new Error(`Unsupported address prefix: ${addressPrefix}`);
+}

package/src/signer/jsonRpc/signer.ts

@@ -0,0 +1,234 @@
+import { Address } from "../../address/index.js";
+import { Script } from "../../ckb/index.js";
+import { Client } from "../../client/index.js";
+import {
+  JsonRpcScript,
+  JsonRpcTransformers,
+} from "../../client/jsonRpc/advanced.js";
+import { RequestorJsonRpc } from "../../jsonRpc/index.js";
+import { Signer } from "../signer/index.js";
+import { signerJsonRpcNetworkIdFromAddressPrefix } from "./network.js";
+import {
+  SignerJsonRpcInfo,
+  SignerJsonRpcTransformers,
+} from "./transformers.js";
+
+export type SignerJsonRpcConfig = Omit<
+  Parameters<typeof RequestorJsonRpc.new>[0],
+  "onError"
+> & {
+  /** Cleans up integration-owned resources before replacement is announced. */
+  disconnectHandler?: () => PromiseLike<void> | void;
+};
+
+export class SignerJsonRpc extends Signer {
+  private connecting?: Promise<void>;
+  private disconnecting?: Promise<void>;
+  private scriptsPromise?: Promise<Script[]>;
+  private internalAddressPromise?: Promise<string>;
+  private identityPromise?: Promise<string>;
+  private readonly replacedListeners = new Set<() => void>();
+
+  private constructor(
+    client: Client,
+    readonly requestor: RequestorJsonRpc,
+    private info: SignerJsonRpcInfo,
+    private readonly disconnectHandler?: () => PromiseLike<void> | void,
+  ) {
+    super(client);
+  }
+
+  /** Creates a Signer that borrows an existing Transport. */
+  static async new(client: Client, config: SignerJsonRpcConfig) {
+    const { disconnectHandler, ...requestorConfig } = config;
+    const requestor = RequestorJsonRpc.new(requestorConfig);
+    const info = (await requestor.request(
+      "get_info",
+      [],
+      [],
+      SignerJsonRpcTransformers.infoTo,
+    )) as SignerJsonRpcInfo;
+
+    return new SignerJsonRpc(client, requestor, info, disconnectHandler);
+  }
+
+  get type() {
+    return this.info.type;
+  }
+
+  get signType() {
+    return this.info.signType;
+  }
+
+  get url() {
+    return this.requestor.url;
+  }
+
+  get name() {
+    return this.info.name;
+  }
+
+  get icon() {
+    return this.info.icon;
+  }
+
+  connect(): Promise<void> {
+    if (this.disconnecting) {
+      return this.disconnecting.then(() => this.connect());
+    }
+    if (this.connecting) {
+      return this.connecting;
+    }
+
+    const connecting = this.requestConnect(
+      signerJsonRpcNetworkIdFromAddressPrefix(this.client.addressPrefix),
+    ).catch((cause: unknown) => {
+      if (this.connecting === connecting) {
+        this.connecting = undefined;
+      }
+      throw cause;
+    });
+    this.connecting = connecting;
+    return connecting;
+  }
+
+  disconnect(): Promise<void> {
+    this.clearReadCache();
+    if (this.disconnecting) {
+      return this.disconnecting;
+    }
+    if (!this.connecting) {
+      return Promise.resolve();
+    }
+
+    this.connecting = undefined;
+    this.disconnecting = Promise.resolve()
+      .then(() => this.disconnectHandler?.())
+      .finally(() => {
+        this.replace();
+        this.disconnecting = undefined;
+      });
+    return this.disconnecting;
+  }
+
+  onReplaced(listener: () => void) {
+    this.replacedListeners.add(listener);
+    return () => this.replacedListeners.delete(listener);
+  }
+
+  replace() {
+    this.connecting = undefined;
+    this.clearReadCache();
+    const listeners = [...this.replacedListeners];
+    this.replacedListeners.clear();
+    listeners.forEach((listener) => listener());
+  }
+
+  async isConnected() {
+    return (
+      this.connecting?.then(
+        () => true,
+        () => false,
+      ) ?? false
+    );
+  }
+
+  getScripts(): Promise<Script[]> {
+    if (this.scriptsPromise) {
+      return this.scriptsPromise.then((scripts) => [...scripts]);
+    }
+
+    const pending = this.requestor
+      .request("get_scripts", [], [], (scripts: JsonRpcScript[]) =>
+        scripts.map((script) => JsonRpcTransformers.scriptTo(script)),
+      )
+      .catch((cause: unknown) => {
+        if (this.scriptsPromise === pending) {
+          this.scriptsPromise = undefined;
+        }
+        throw cause;
+      }) as Promise<Script[]>;
+    this.scriptsPromise = pending;
+    return pending.then((scripts) => [...scripts]);
+  }
+
+  async getAddressObjs() {
+    return (await this.getScripts()).map((script) =>
+      Address.fromScript(script, this.client),
+    );
+  }
+
+  getInternalAddress(): Promise<string> {
+    if (this.internalAddressPromise) {
+      return this.internalAddressPromise;
+    }
+
+    const pending = this.requestor
+      .request("get_native_address", [], [])
+      .catch((cause: unknown) => {
+        if (this.internalAddressPromise === pending) {
+          this.internalAddressPromise = undefined;
+        }
+        throw cause;
+      }) as Promise<string>;
+    this.internalAddressPromise = pending;
+    return pending;
+  }
+
+  getIdentity(): Promise<string> {
+    if (this.identityPromise) {
+      return this.identityPromise;
+    }
+
+    const pending = this.requestor
+      .request("get_identity", [], [])
+      .catch((cause: unknown) => {
+        if (this.identityPromise === pending) {
+          this.identityPromise = undefined;
+        }
+        throw cause;
+      }) as Promise<string>;
+    this.identityPromise = pending;
+    return pending;
+  }
+
+  signMessageRaw = this.buildSender("sign_message", [
+    SignerJsonRpcTransformers.messageFrom,
+  ]) as Signer["signMessageRaw"];
+
+  prepareTransaction = this.buildSender(
+    "prepare_transaction",
+    [JsonRpcTransformers.transactionFrom],
+    JsonRpcTransformers.transactionTo,
+  ) as Signer["prepareTransaction"];
+
+  signOnlyTransaction = this.buildSender(
+    "sign_transaction",
+    [JsonRpcTransformers.transactionFrom],
+    JsonRpcTransformers.transactionTo,
+  ) as Signer["signOnlyTransaction"];
+
+  buildSender(
+    rpcMethod: Parameters<RequestorJsonRpc["request"]>[0],
+    inTransformers?: Parameters<RequestorJsonRpc["request"]>[2],
+    outTransformer?: Parameters<RequestorJsonRpc["request"]>[3],
+  ): (...request: unknown[]) => Promise<unknown> {
+    return async (...request: unknown[]) =>
+      this.requestor.request(
+        rpcMethod,
+        request,
+        inTransformers,
+        outTransformer,
+      );
+  }
+
+  private clearReadCache() {
+    this.scriptsPromise = undefined;
+    this.internalAddressPromise = undefined;
+    this.identityPromise = undefined;
+  }
+
+  private requestConnect = this.buildSender("connect", []) as (
+    networkId: string,
+  ) => Promise<void>;
+}