@ckb-ccc/xverse 0.0.15-alpha.0

package/src/signer.ts

@@ -0,0 +1,170 @@
+import { ccc } from "@ckb-ccc/core";
+import * as v from "valibot";
+import {
+  Address,
+  AddressPurpose,
+  BtcProvider,
+  MessageSigningProtocols,
+  Requests,
+  Return,
+  RpcErrorCode,
+  RpcResponse,
+  rpcErrorResponseMessageSchema,
+  rpcSuccessResponseMessageSchema,
+} from "./advancedBarrel.js";
+
+async function checkResponse<T extends keyof Requests>(
+  response: Promise<RpcResponse<T>>,
+): Promise<Return<T>> {
+  const res = await response;
+  if (v.is(rpcErrorResponseMessageSchema, res)) {
+    throw res.error;
+  }
+
+  if (v.is(rpcSuccessResponseMessageSchema, res)) {
+    return res.result as Return<T>;
+  }
+
+  throw {
+    code: RpcErrorCode.INTERNAL_ERROR,
+    message: "Received unknown response from provider.",
+    data: res,
+  };
+}
+
+/**
+ * Class representing a Bitcoin signer that extends SignerBtc
+ * @public
+ */
+export class Signer extends ccc.SignerBtc {
+  private addressCache: Promise<Address | undefined> | undefined;
+
+  /**
+   * Creates an instance of Signer.
+   * @param client - The client instance.
+   * @param provider - The provider instance.
+   */
+  constructor(
+    client: ccc.Client,
+    public readonly provider: BtcProvider,
+    private readonly preferredNetworks: ccc.NetworkPreference[] = [
+      {
+        addressPrefix: "ckb",
+        signerType: ccc.SignerType.BTC,
+        network: "btc",
+      },
+      {
+        addressPrefix: "ckt",
+        signerType: ccc.SignerType.BTC,
+        network: "btcTestnet",
+      },
+    ],
+  ) {
+    super(client);
+  }
+
+  async assertAddress(): Promise<Address> {
+    this.addressCache =
+      this.addressCache ??
+      (async () => {
+        if (!(await this.isConnected())) {
+          return;
+        }
+
+        return (
+          await checkResponse(
+            this.provider.request("getAddresses", {
+              purposes: [AddressPurpose.Payment],
+            }),
+          )
+        ).addresses[0];
+      })();
+    const address = await this.addressCache;
+
+    if (address) {
+      return address;
+    }
+    throw Error("Not connected");
+  }
+
+  /**
+   * Gets the Bitcoin account address.
+   * @returns A promise that resolves to the Bitcoin account address.
+   */
+  async getBtcAccount(): Promise<string> {
+    return (await this.assertAddress()).address;
+  }
+
+  /**
+   * Gets the Bitcoin public key.
+   * @returns A promise that resolves to the Bitcoin public key.
+   */
+  async getBtcPublicKey(): Promise<ccc.Hex> {
+    return ccc.hexFrom((await this.assertAddress()).publicKey);
+  }
+
+  /**
+   * Connects to the provider by requesting accounts.
+   * @returns A promise that resolves when the connection is established.
+   */
+  async connect(): Promise<void> {
+    if (await this.isConnected()) {
+      return;
+    }
+
+    await checkResponse(
+      this.provider.request("wallet_requestPermissions", undefined),
+    );
+  }
+
+  async disconnect(): Promise<void> {
+    this.addressCache = undefined;
+  }
+
+  onReplaced(listener: () => void): () => void {
+    const stop: (() => void)[] = [];
+    const replacer = async () => {
+      listener();
+      stop[0]?.();
+    };
+    stop.push(
+      this.provider.addListener("accountChange", replacer),
+      this.provider.addListener("networkChange", replacer),
+    );
+
+    return stop[0];
+  }
+
+  /**
+   * Checks if the signer is connected.
+   * @returns A promise that resolves to true if connected, false otherwise.
+   */
+  async isConnected(): Promise<boolean> {
+    try {
+      await checkResponse(this.provider.request("getBalance", undefined));
+      return true;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Signs a raw message with the Bitcoin account.
+   * @param message - The message to sign.
+   * @returns A promise that resolves to the signed message.
+   */
+  async signMessageRaw(message: string | ccc.BytesLike): Promise<string> {
+    const challenge =
+      typeof message === "string" ? message : ccc.hexFrom(message).slice(2);
+
+    return (
+      await checkResponse(
+        this.provider.request("signMessage", {
+          message: challenge,
+          address: (await this.assertAddress()).address,
+          protocol: MessageSigningProtocols.ECDSA,
+        }),
+      )
+    ).signature;
+  }
+}

package/src/signersFactory.ts

@@ -0,0 +1,50 @@
+import { ccc } from "@ckb-ccc/core";
+import { BtcProvider, Provider } from "./advancedBarrel.js";
+import { Signer } from "./signer.js";
+
+function getProviderById(providerId: string) {
+  return providerId?.split(".").reduce((acc: any, part) => acc?.[part], window);
+}
+
+/**
+ * Retrieves the Xverse signer if available.
+ * @public
+ *
+ * @param client - The client instance.
+ * @returns All Xverse Signer instances
+ */
+export function getXverseSigners(
+  client: ccc.Client,
+  preferredNetworks?: ccc.NetworkPreference[],
+): { wallet: ccc.Wallet; signerInfo: ccc.SignerInfo }[] {
+  const windowRef = window as {
+    BitcoinProvider?: BtcProvider;
+    XverseProviders?: {
+      BitcoinProvider?: BtcProvider;
+    };
+    btc_providers?: Provider[];
+  };
+
+  const signers = (() => {
+    if (windowRef.btc_providers) {
+      return windowRef.btc_providers.map((provider) => ({
+        wallet: {
+          name: provider.name,
+          icon: provider.icon,
+        },
+        signerInfo: {
+          name: "BTC",
+          signer: new Signer(
+            client,
+            getProviderById(provider.id),
+            preferredNetworks,
+          ),
+        },
+      }));
+    }
+
+    return [];
+  })();
+
+  return signers;
+}

package/typedoc.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["./src/index.ts", "./src/advanced.ts"],
+  "extends": ["../../typedoc.base.json"],
+  "name": "@ckb-ccc xverse"
+}