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

package/src/btc/index.ts

@@ -1,5 +1,6 @@
 import { ccc } from "@ckb-ccc/core";
-import { authWithPopup, signMessageWithPopup } from "@joyid/common";
+import { DappRequestType, buildJoyIDURL } from "@joyid/common";
+import { createPopup } from "../common";
 import {
   Connection,
   ConnectionsRepo,
@@ -19,15 +20,34 @@ export class BitcoinSigner extends ccc.SignerBtc {
 
   constructor(
     client: ccc.Client,
+    private readonly name: string,
+    private readonly icon: string,
     private readonly addressType: "auto" | "p2wpkh" | "p2tr" = "auto",
-    private readonly uri = "https://app.joy.id",
+    private readonly appUri = "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);
+    return new BitcoinSigner(
+      client,
+      this.name,
+      this.icon,
+      this.addressType,
+      this.appUri,
+      this.connectionsRepo,
+    );
+  }
+
+  private getConfig() {
+    return {
+      redirectURL: location.href,
+      joyidAppURL: this.appUri,
+      requestNetwork: `btc-${this.addressType}`,
+      name: this.name,
+      logo: this.icon,
+    };
   }
 
   async getBtcAccount(): Promise<string> {
@@ -41,10 +61,10 @@ export class BitcoinSigner extends ccc.SignerBtc {
   }
 
   async connect(): Promise<void> {
-    const res = await authWithPopup({
-      joyidAppURL: this.uri,
-      redirectURL: location.href,
-      requestNetwork: `btc-${this.addressType}`,
+    const config = this.getConfig();
+    const res = await createPopup(buildJoyIDURL(config, "popup", "/auth"), {
+      ...config,
+      type: DappRequestType.Auth,
     });
 
     const { address, pubkey } = (() => {
@@ -61,11 +81,11 @@ export class BitcoinSigner extends ccc.SignerBtc {
     };
     await Promise.all([
       this.connectionsRepo.set(
-        { uri: this.uri, addressType: `btc-${res.btcAddressType}` },
+        { uri: this.appUri, addressType: `btc-${res.btcAddressType}` },
         this.connection,
       ),
       this.connectionsRepo.set(
-        { uri: this.uri, addressType: "btc-auto" },
+        { uri: this.appUri, addressType: "btc-auto" },
         this.connection,
       ),
     ]);
@@ -77,26 +97,32 @@ export class BitcoinSigner extends ccc.SignerBtc {
     }
 
     this.connection = await this.connectionsRepo.get({
-      uri: this.uri,
+      uri: this.appUri,
       addressType: `btc-${this.addressType}`,
     });
     return this.connection !== undefined;
   }
 
-  async signMessage(message: string | ccc.BytesLike): Promise<string> {
+  async signMessageRaw(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,
-    });
+    const config = this.getConfig();
+    const { signature } = await createPopup(
+      buildJoyIDURL(
+        {
+          ...config,
+          challenge,
+          address,
+          signMessageType: "ecdsa",
+        },
+        "popup",
+        "/sign-message",
+      ),
+      { ...config, type: DappRequestType.SignMessage },
+    );
     return signature;
   }
 }

package/src/ckb/index.ts

@@ -1,13 +1,7 @@
 import { ccc } from "@ckb-ccc/core";
 import { Aggregator } from "@joyid/ckb";
-import {
-  DappRequestType,
-  authWithPopup,
-  buildJoyIDURL,
-  createBlockDialog,
-  openPopup,
-  runPopup,
-} from "@joyid/common";
+import { DappRequestType, buildJoyIDURL } from "@joyid/common";
+import { createPopup } from "../common";
 import {
   Connection,
   ConnectionsRepo,
@@ -15,6 +9,14 @@ import {
 } from "../connectionsStorage";
 
 export class CkbSigner extends ccc.Signer {
+  get type(): ccc.SignerType {
+    return ccc.SignerType.CKB;
+  }
+
+  get signType(): ccc.SignerSignType {
+    return ccc.SignerSignType.JoyId;
+  }
+
   private connection?: Connection;
 
   private async assertConnection(): Promise<Connection> {
@@ -27,7 +29,9 @@ export class CkbSigner extends ccc.Signer {
 
   constructor(
     client: ccc.Client,
-    private readonly _uri?: string,
+    private readonly name: string,
+    private readonly icon: string,
+    private readonly _appUri?: string,
     private readonly _aggregatorUri?: string,
     private readonly connectionsRepo: ConnectionsRepo = new ConnectionsRepoLocalStorage(),
   ) {
@@ -35,34 +39,44 @@ export class CkbSigner extends ccc.Signer {
   }
 
   async replaceClient(client: ccc.Client): Promise<CkbSigner> {
-    return new CkbSigner(client, this._uri);
+    return new CkbSigner(
+      client,
+      this.name,
+      this.icon,
+      this._appUri,
+      this._aggregatorUri,
+      this.connectionsRepo,
+    );
   }
 
-  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 getConfig() {
+    return {
+      redirectURL: location.href,
+      joyidAppURL:
+        this._appUri ?? this.client.addressPrefix === "ckb"
+          ? "https://app.joy.id"
+          : "https://testnet.joyid.dev",
+      name: this.name,
+      logo: this.icon,
+    };
   }
 
-  private async getAggregatorUri(): Promise<string> {
+  private getAggregatorUri(): string {
     if (this._aggregatorUri) {
       return this._aggregatorUri;
     }
 
-    return (await this.client.getAddressPrefix()) === "ckb"
+    return this.client.addressPrefix === "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,
+    const config = this.getConfig();
+
+    const res = await createPopup(buildJoyIDURL(config, "popup", "/auth"), {
+      ...config,
+      type: DappRequestType.Auth,
     });
 
     this.connection = {
@@ -90,6 +104,14 @@ export class CkbSigner extends ccc.Signer {
     return (await this.assertConnection()).address;
   }
 
+  async getIdentity(): Promise<string> {
+    const connection = await this.assertConnection();
+    return JSON.stringify({
+      keyType: connection.keyType,
+      publicKey: connection.publicKey.slice(2),
+    });
+  }
+
   async getAddressObj(): Promise<ccc.Address> {
     return await ccc.Address.fromString(
       await this.getInternalAddress(),
@@ -161,38 +183,61 @@ export class CkbSigner extends ccc.Signer {
   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(
+    const config = this.getConfig();
+    const res = await createPopup(
+      buildJoyIDURL(
+        {
+          ...config,
+          tx: JSON.parse(tx.stringify()),
+          signerAddress: (await this.assertConnection()).address,
+          witnessIndex: await tx.findInputIndexByLock(script, this.client),
+        },
+        "popup",
+        "/sign-ckb-raw-tx",
+      ),
       {
-        joyidAppURL: await this.getUri(),
-        tx: JSON.parse(tx.stringify()),
-        signerAddress: (await this.assertConnection()).address,
-        redirectURL: location.href,
-        witnessIndex: await tx.findInputIndexByLock(script, this.client),
+        ...config,
+        type: DappRequestType.SignCkbRawTx,
       },
-      "popup",
-      "/sign-ckb-raw-tx",
     );
 
-    const res = await runPopup({
-      timeoutInSeconds: 3600,
-      popup,
-      type: DappRequestType.SignCkbRawTx,
-    });
-
     return ccc.Transaction.from(res.tx);
   }
 
+  async signMessageRaw(message: string | ccc.BytesLike): Promise<string> {
+    const { address } = await this.assertConnection();
+
+    const challenge =
+      typeof message === "string" ? message : ccc.hexFrom(message).slice(2);
+
+    const config = this.getConfig();
+    const res = await createPopup(
+      buildJoyIDURL(
+        {
+          ...config,
+          challenge,
+          isData: typeof message !== "string",
+          address,
+        },
+        "popup",
+        "/sign-message",
+      ),
+      { ...config, type: DappRequestType.SignMessage },
+    );
+    return JSON.stringify({
+      signature: res.signature,
+      alg: res.alg,
+      message: res.message,
+    });
+  }
+
   private async saveConnection() {
     return this.connectionsRepo.set(
       {
-        uri: await this.getUri(),
+        uri: this.getConfig().joyidAppURL,
         addressType: "ckb",
       },
       this.connection,
@@ -201,7 +246,7 @@ export class CkbSigner extends ccc.Signer {
 
   private async restoreConnection() {
     this.connection = await this.connectionsRepo.get({
-      uri: await this.getUri(),
+      uri: this.getConfig().joyidAppURL,
       addressType: "ckb",
     });
   }

package/src/common/index.ts

@@ -0,0 +1,100 @@
+import {
+  AuthResponseData,
+  DappRequestType,
+  EvmWeb2LoginResponse,
+  PopupCancelledError,
+  PopupConfigOptions,
+  PopupNotSupportedError,
+  PopupTimeoutError,
+  SignCkbTxResponseData,
+  SignCotaNFTResponseData,
+  SignEvmTxResponseData,
+  SignMessageResponseData,
+  SignNostrEventData,
+  createBlockDialog,
+  isStandaloneBrowser,
+  openPopup,
+} from "@joyid/common";
+
+export interface PopupReturnType {
+  [DappRequestType.Auth]: AuthResponseData;
+  [DappRequestType.SignMessage]: SignMessageResponseData;
+  [DappRequestType.SignEvm]: SignEvmTxResponseData;
+  [DappRequestType.SignPsbt]: SignEvmTxResponseData;
+  [DappRequestType.BatchSignPsbt]: {
+    psbts: string[];
+  };
+  [DappRequestType.SignCkbTx]: SignCkbTxResponseData;
+  [DappRequestType.SignCotaNFT]: SignCotaNFTResponseData;
+  [DappRequestType.SignCkbRawTx]: SignCkbTxResponseData;
+  [DappRequestType.SignNostrEvent]: SignNostrEventData;
+  [DappRequestType.EncryptNostrMessage]: any;
+  [DappRequestType.DecryptNostrMessage]: any;
+  [DappRequestType.AuthMiniApp]: any;
+  [DappRequestType.SignMiniAppEvm]: any;
+  [DappRequestType.SignMiniAppMessage]: any;
+  [DappRequestType.EvmWeb2Login]: EvmWeb2LoginResponse;
+}
+
+export async function createPopup<T extends DappRequestType>(
+  url: string,
+  config: PopupConfigOptions<T> & { joyidAppURL: string },
+): Promise<PopupReturnType[T]> {
+  if (config.popup == null) {
+    config.popup = openPopup("");
+
+    if (config.popup == null) {
+      return createBlockDialog(async () => createPopup(url, config));
+    }
+  }
+
+  config.popup.location.href = url;
+
+  return new Promise((resolve, reject) => {
+    if (isStandaloneBrowser()) {
+      reject(new PopupNotSupportedError(config.popup));
+    }
+    let popupEventListener: (e: MessageEvent) => void;
+    let timeoutId: undefined | ReturnType<typeof setTimeout>;
+    // Check each second if the popup is closed triggering a PopupCancelledError
+    const popupTimer = setInterval(() => {
+      if (config.popup?.closed) {
+        clearInterval(popupTimer);
+        clearTimeout(timeoutId);
+        window.removeEventListener("message", popupEventListener, false);
+        reject(new PopupCancelledError(config.popup));
+      }
+    }, 1000);
+
+    timeoutId = setTimeout(
+      () => {
+        clearInterval(popupTimer);
+        reject(new PopupTimeoutError(config.popup));
+        window.removeEventListener("message", popupEventListener, false);
+      },
+      (config.timeoutInSeconds ?? 3000) * 1000,
+    );
+
+    popupEventListener = (e: MessageEvent) => {
+      const { joyidAppURL } = config;
+      const appURL = new URL(joyidAppURL);
+      if (e.origin !== appURL.origin) {
+        return;
+      }
+      if (!e.data || e.data?.type !== config.type) {
+        return;
+      }
+
+      clearTimeout(timeoutId);
+      clearInterval(popupTimer);
+      window.removeEventListener("message", popupEventListener, false);
+      config.popup.close();
+      if (e.data.error) {
+        reject(new Error(e.data.error));
+      }
+      resolve(e.data.data);
+    };
+
+    window.addEventListener("message", popupEventListener);
+  });
+}

package/src/evm/index.ts

@@ -0,0 +1,118 @@
+import { ccc } from "@ckb-ccc/core";
+import { DappRequestType, buildJoyIDURL } from "@joyid/common";
+import { createPopup } from "../common";
+import {
+  Connection,
+  ConnectionsRepo,
+  ConnectionsRepoLocalStorage,
+} from "../connectionsStorage";
+
+export class EvmSigner extends ccc.SignerEvm {
+  private connection?: Connection;
+
+  private assertConnection() {
+    if (!this.isConnected() || !this.connection) {
+      throw new Error("Not connected");
+    }
+
+    return this.connection;
+  }
+
+  constructor(
+    client: ccc.Client,
+    private readonly name: string,
+    private readonly icon: string,
+    private readonly appUri = "https://app.joy.id",
+    private readonly connectionsRepo: ConnectionsRepo = new ConnectionsRepoLocalStorage(),
+  ) {
+    super(client);
+  }
+
+  async replaceClient(client: ccc.Client): Promise<EvmSigner> {
+    return new EvmSigner(
+      client,
+      this.name,
+      this.icon,
+      this.appUri,
+      this.connectionsRepo,
+    );
+  }
+
+  private getConfig() {
+    return {
+      redirectURL: location.href,
+      joyidAppURL: this.appUri,
+      requestNetwork: `ethereum`,
+      name: this.name,
+      logo: this.icon,
+    };
+  }
+
+  async getEvmAccount() {
+    return this.assertConnection().address;
+  }
+
+  async connect(): Promise<void> {
+    const config = await this.getConfig();
+
+    const res = await createPopup(buildJoyIDURL(config, "popup", "/auth"), {
+      ...config,
+      type: DappRequestType.Auth,
+    });
+
+    this.connection = {
+      address: res.ethAddress,
+      publicKey: ccc.hexFrom(res.pubkey),
+      keyType: res.keyType,
+    };
+    await this.saveConnection();
+  }
+
+  async isConnected(): Promise<boolean> {
+    if (this.connection) {
+      return true;
+    }
+    await this.restoreConnection();
+    return this.connection !== undefined;
+  }
+
+  async signMessageRaw(message: string | ccc.BytesLike): Promise<ccc.Hex> {
+    const { address } = this.assertConnection();
+
+    const challenge =
+      typeof message === "string" ? message : ccc.hexFrom(message).slice(2);
+
+    const config = this.getConfig();
+    const { signature } = await createPopup(
+      buildJoyIDURL(
+        {
+          ...config,
+          challenge,
+          isData: typeof message !== "string",
+          address,
+        },
+        "popup",
+        "/sign-message",
+      ),
+      { ...config, type: DappRequestType.SignMessage },
+    );
+    return ccc.hexFrom(signature);
+  }
+
+  private async saveConnection() {
+    return this.connectionsRepo.set(
+      {
+        uri: this.getConfig().joyidAppURL,
+        addressType: "ethereum",
+      },
+      this.connection,
+    );
+  }
+
+  private async restoreConnection() {
+    this.connection = await this.connectionsRepo.get({
+      uri: this.getConfig().joyidAppURL,
+      addressType: "ethereum",
+    });
+  }
+}

package/src/signerFactory/index.ts

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