@ckb-ccc/joy-id 0.0.5-alpha.0

package/src/btc/index.ts

@@ -0,0 +1,102 @@
+import { ccc } from "@ckb-ccc/core";
+import { authWithPopup, signMessageWithPopup } from "@joyid/common";
+import {
+  Connection,
+  ConnectionsRepo,
+  ConnectionsRepoLocalStorage,
+} from "../connectionsStorage";
+
+export class BitcoinSigner extends ccc.SignerBtc {
+  private connection?: Connection;
+
+  private assertConnection() {
+    if (!this.isConnected() || !this.connection) {
+      throw new Error("Not connected");
+    }
+
+    return this.connection;
+  }
+
+  constructor(
+    client: ccc.Client,
+    private readonly addressType: "auto" | "p2wpkh" | "p2tr" = "auto",
+    private readonly uri = "https://app.joy.id",
+    private readonly connectionsRepo: ConnectionsRepo = new ConnectionsRepoLocalStorage(),
+  ) {
+    super(client);
+  }
+
+  async replaceClient(client: ccc.Client): Promise<BitcoinSigner> {
+    return new BitcoinSigner(client, this.addressType, this.uri);
+  }
+
+  async getBtcAccount(): Promise<string> {
+    const { address } = this.assertConnection();
+    return address;
+  }
+
+  async getBtcPublicKey(): Promise<ccc.Hex> {
+    const { publicKey } = this.assertConnection();
+    return publicKey;
+  }
+
+  async connect(): Promise<void> {
+    const res = await authWithPopup({
+      joyidAppURL: this.uri,
+      redirectURL: location.href,
+      requestNetwork: `btc-${this.addressType}`,
+    });
+
+    const { address, pubkey } = (() => {
+      if (this.addressType === "auto") {
+        return res.btcAddressType === "p2wpkh" ? res.nativeSegwit : res.taproot;
+      }
+      return res.btcAddressType === "p2wpkh" ? res.nativeSegwit : res.taproot;
+    })();
+
+    this.connection = {
+      address,
+      publicKey: ccc.hexFrom(pubkey),
+      keyType: res.keyType,
+    };
+    await Promise.all([
+      this.connectionsRepo.set(
+        { uri: this.uri, addressType: `btc-${res.btcAddressType}` },
+        this.connection,
+      ),
+      this.connectionsRepo.set(
+        { uri: this.uri, addressType: "btc-auto" },
+        this.connection,
+      ),
+    ]);
+  }
+
+  async isConnected(): Promise<boolean> {
+    if (this.connection) {
+      return true;
+    }
+
+    this.connection = await this.connectionsRepo.get({
+      uri: this.uri,
+      addressType: `btc-${this.addressType}`,
+    });
+    return this.connection !== undefined;
+  }
+
+  async signMessage(message: string | ccc.BytesLike): Promise<string> {
+    const { address } = this.assertConnection();
+
+    const challenge =
+      typeof message === "string" ? message : ccc.hexFrom(message).slice(2);
+
+    const { signature } = await signMessageWithPopup({
+      joyidAppURL: this.uri,
+      requestNetwork: `btc-${this.addressType}`,
+      challenge,
+      address,
+      signMessageType: "ecdsa",
+      redirectURL: location.href,
+    });
+    return signature;
+  }
+}

package/src/ckb/index.ts

@@ -0,0 +1,208 @@
+import { ccc } from "@ckb-ccc/core";
+import { Aggregator } from "@joyid/ckb";
+import {
+  DappRequestType,
+  authWithPopup,
+  buildJoyIDURL,
+  createBlockDialog,
+  openPopup,
+  runPopup,
+} from "@joyid/common";
+import {
+  Connection,
+  ConnectionsRepo,
+  ConnectionsRepoLocalStorage,
+} from "../connectionsStorage";
+
+export class CkbSigner extends ccc.Signer {
+  private connection?: Connection;
+
+  private async assertConnection(): Promise<Connection> {
+    if (!(await this.isConnected()) || !this.connection) {
+      throw new Error("Not connected");
+    }
+
+    return this.connection;
+  }
+
+  constructor(
+    client: ccc.Client,
+    private readonly _uri?: string,
+    private readonly _aggregatorUri?: string,
+    private readonly connectionsRepo: ConnectionsRepo = new ConnectionsRepoLocalStorage(),
+  ) {
+    super(client);
+  }
+
+  async replaceClient(client: ccc.Client): Promise<CkbSigner> {
+    return new CkbSigner(client, this._uri);
+  }
+
+  private async getUri(): Promise<string> {
+    if (this._uri) {
+      return this._uri;
+    }
+
+    return (await this.client.getAddressPrefix()) === "ckb"
+      ? "https://app.joy.id"
+      : "https://testnet.joyid.dev";
+  }
+
+  private async getAggregatorUri(): Promise<string> {
+    if (this._aggregatorUri) {
+      return this._aggregatorUri;
+    }
+
+    return (await this.client.getAddressPrefix()) === "ckb"
+      ? "https://cota.nervina.dev/mainnet-aggregator"
+      : "https://cota.nervina.dev/aggregator";
+  }
+
+  async connect(): Promise<void> {
+    const uri = await this.getUri();
+    const res = await authWithPopup({
+      joyidAppURL: uri,
+      redirectURL: location.href,
+    });
+
+    this.connection = {
+      address: res.address,
+      publicKey: ccc.hexFrom(res.pubkey),
+      keyType: res.keyType,
+    };
+    await this.saveConnection();
+  }
+
+  async disconnect(): Promise<void> {
+    this.connection = undefined;
+    await this.saveConnection();
+  }
+
+  async isConnected(): Promise<boolean> {
+    if (this.connection) {
+      return true;
+    }
+    await this.restoreConnection();
+    return this.connection !== undefined;
+  }
+
+  async getInternalAddress(): Promise<string> {
+    return (await this.assertConnection()).address;
+  }
+
+  async getAddressObj(): Promise<ccc.Address> {
+    return await ccc.Address.fromString(
+      await this.getInternalAddress(),
+      this.client,
+    );
+  }
+
+  async getAddressObjs(): Promise<ccc.Address[]> {
+    return [await this.getAddressObj()];
+  }
+
+  async prepareTransaction(
+    txLike: ccc.TransactionLike,
+  ): Promise<ccc.Transaction> {
+    const tx = ccc.Transaction.from(txLike);
+    const position = await tx.findInputIndexByLock(
+      (await this.getAddressObj()).script,
+      this.client,
+    );
+    if (position === undefined) {
+      return tx;
+    }
+
+    const witness = tx.getWitnessArgsAt(position) ?? ccc.WitnessArgs.from({});
+    witness.lock = "0x";
+    await this.prepareTransactionForSubKey(tx, witness);
+    return tx.setWitnessArgsAt(position, witness);
+  }
+
+  private async prepareTransactionForSubKey(
+    tx: ccc.Transaction,
+    witness: ccc.WitnessArgs,
+  ) {
+    if (this.connection?.keyType !== "sub_key") {
+      return [];
+    }
+
+    const pubkeyHash = ccc.ckbHash(this.connection.publicKey).substring(0, 42);
+    const lock = (await this.getAddressObj()).script;
+    const aggregator = new Aggregator(await this.getAggregatorUri());
+    const { unlock_entry: unlockEntry } =
+      await aggregator.generateSubkeyUnlockSmt({
+        alg_index: 1,
+        pubkey_hash: pubkeyHash,
+        lock_script: ccc.hexFrom(lock.toBytes()),
+      });
+    witness.outputType = ccc.hexFrom(unlockEntry);
+
+    const cotaDeps: ccc.CellDep[] = [];
+    for await (const cell of this.client.findCellsByLockAndType(lock, {
+      ...(await this.client.getKnownScript(ccc.KnownScript.COTA)),
+      args: "0x",
+    })) {
+      cotaDeps.push(
+        ccc.CellDep.from({
+          depType: "code",
+          outPoint: cell.outPoint,
+        }),
+      );
+    }
+
+    if (cotaDeps.length === 0) {
+      throw new Error("No COTA cells for sub key wallet");
+    }
+
+    tx.cellDeps.unshift(...cotaDeps);
+  }
+
+  async signOnlyTransaction(
+    txLike: ccc.TransactionLike,
+  ): Promise<ccc.Transaction> {
+    const popup = openPopup("");
+    if (!popup) {
+      return createBlockDialog(async () => this.signOnlyTransaction(txLike));
+    }
+    const tx = ccc.Transaction.from(txLike);
+    const { script } = await this.getAddressObj();
+
+    popup.location.href = buildJoyIDURL(
+      {
+        joyidAppURL: await this.getUri(),
+        tx: JSON.parse(tx.stringify()),
+        signerAddress: (await this.assertConnection()).address,
+        redirectURL: location.href,
+        witnessIndex: await tx.findInputIndexByLock(script, this.client),
+      },
+      "popup",
+      "/sign-ckb-raw-tx",
+    );
+
+    const res = await runPopup({
+      timeoutInSeconds: 3600,
+      popup,
+      type: DappRequestType.SignCkbRawTx,
+    });
+
+    return ccc.Transaction.from(res.tx);
+  }
+
+  private async saveConnection() {
+    return this.connectionsRepo.set(
+      {
+        uri: await this.getUri(),
+        addressType: "ckb",
+      },
+      this.connection,
+    );
+  }
+
+  private async restoreConnection() {
+    this.connection = await this.connectionsRepo.get({
+      uri: await this.getUri(),
+      addressType: "ckb",
+    });
+  }
+}

package/src/connectionsStorage/index.ts

@@ -0,0 +1,57 @@
+import { ccc } from "@ckb-ccc/core";
+
+export type AccountSelector = {
+  uri: string;
+  addressType: string;
+};
+
+export function isSelectorEq(a: AccountSelector, b: AccountSelector) {
+  return a.uri === b.uri && a.addressType === b.addressType;
+}
+
+export type Connection = {
+  readonly address: string;
+  readonly publicKey: ccc.Hex;
+  readonly keyType: string;
+};
+
+export interface ConnectionsRepo {
+  get(selector: AccountSelector): Promise<Connection | undefined>;
+  set(
+    selector: AccountSelector,
+    connection: Connection | undefined,
+  ): Promise<void>;
+}
+
+export class ConnectionsRepoLocalStorage implements ConnectionsRepo {
+  constructor(private readonly storageKey = "ccc-joy-id-signer") {}
+
+  async readConnections(): Promise<[AccountSelector, Connection][]> {
+    return JSON.parse(window.localStorage.getItem(this.storageKey) ?? "[]");
+  }
+
+  async get(selector: AccountSelector): Promise<Connection | undefined> {
+    return (await this.readConnections()).find(([s]) =>
+      isSelectorEq(selector, s),
+    )?.[1];
+  }
+
+  async set(selector: AccountSelector, connection: Connection | undefined) {
+    const connections = await this.readConnections();
+
+    if (connection) {
+      const existed = connections.find(([s]) => isSelectorEq(s, selector));
+      if (existed) {
+        existed[1] = connection;
+      } else {
+        connections.push([selector, connection]);
+      }
+      window.localStorage.setItem(this.storageKey, JSON.stringify(connections));
+    } else {
+      window.localStorage.setItem(
+        this.storageKey,
+        JSON.stringify(connections.filter(([s]) => !isSelectorEq(s, selector))),
+      );
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * as JoyId from "./barrel";

package/src/signerFactory/index.ts

@@ -0,0 +1,28 @@
+import { ccc } from "@ckb-ccc/core";
+import { BitcoinSigner } from "../btc";
+import { CkbSigner } from "../ckb";
+
+export function getJoyIdSigners(client: ccc.Client): ccc.SignerInfo[] {
+  return [
+    {
+      type: ccc.SignerType.CKB,
+      name: "CKB",
+      signer: new CkbSigner(client),
+    },
+    {
+      type: ccc.SignerType.BTC,
+      name: "BTC",
+      signer: new BitcoinSigner(client),
+    },
+    {
+      type: ccc.SignerType.BTC,
+      name: "BTC (P2WPKH)",
+      signer: new BitcoinSigner(client, "p2wpkh"),
+    },
+    {
+      type: ccc.SignerType.BTC,
+      name: "BTC (P2TR)",
+      signer: new BitcoinSigner(client, "p2tr"),
+    },
+  ];
+}