@idos-network/kwil-infra 2.3.0 → 3.0.1

package/src/near/create-near-wallet-kwil-signer.test.ts

@@ -0,0 +1,218 @@
+import type { Wallet as NearWallet } from "@near-wallet-selector/core";
+
+import {
+  base64Encode,
+  borshSerialize,
+  bs58Encode,
+  bytesConcat,
+  sha256Hash,
+} from "@idos-network/utils/codecs";
+import { MemoryStore } from "@idos-network/utils/store";
+import nacl from "tweetnacl";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import type { KwilActionClient } from "../create-kwil-client";
+
+import { createNearWalletKwilSigner } from "./create-near-wallet-kwil-signer";
+
+const fullAccess = vi.hoisted(() => ({
+  keys: [] as string[],
+  limitedKeys: [] as string[],
+  queries: 0,
+  lastRequest: undefined as { request_type?: string; account_id?: string } | undefined,
+}));
+
+vi.mock("near-api-js", () => ({
+  connect: async () => ({
+    connection: {
+      provider: {
+        query: async (request: { request_type?: string; account_id?: string }) => {
+          fullAccess.queries += 1;
+          fullAccess.lastRequest = request;
+          return {
+            keys: [
+              ...fullAccess.keys.map((public_key) => ({
+                public_key,
+                access_key: { permission: "FullAccess" },
+              })),
+              ...fullAccess.limitedKeys.map((public_key) => ({
+                public_key,
+                access_key: {
+                  permission: {
+                    FunctionCall: {
+                      allowance: "0",
+                      receiver_id: "example.near",
+                      method_names: [],
+                    },
+                  },
+                },
+              })),
+            ],
+          };
+        },
+      },
+    },
+  }),
+}));
+
+const ACCOUNT = "victim.testnet";
+const RECIPIENT = "idos.network";
+const CALLBACK = "https://app.example/callback";
+const MESSAGE = "idOS authentication";
+const NEP413_TAG = 2147484061;
+
+const nep413PayloadSchema = {
+  struct: {
+    message: "string",
+    nonce: { array: { type: "u8", len: 32 } },
+    recipient: "string",
+    callbackUrl: { option: "string" },
+  },
+} as const;
+
+const keyPair = nacl.sign.keyPair.fromSeed(new Uint8Array(32).fill(4));
+const fragmentKey = `ed25519:${bs58Encode(keyPair.publicKey)}`;
+const realKey = `ed25519:${bs58Encode(new Uint8Array(32).fill(1))}`;
+
+const kwilClient = {
+  client: { auth: { logoutKGW: async () => {} } },
+} as unknown as KwilActionClient;
+
+function signNep413(nonce: Uint8Array, message = MESSAGE): string {
+  const hash = sha256Hash(
+    bytesConcat(
+      borshSerialize("u32", NEP413_TAG),
+      borshSerialize(nep413PayloadSchema, {
+        message,
+        nonce,
+        recipient: RECIPIENT,
+        callbackUrl: CALLBACK,
+      }),
+    ),
+  );
+  return base64Encode(nacl.sign.detached(hash, keyPair.secretKey));
+}
+
+function signedRequest(): { nonce: Uint8Array; signature: string } {
+  for (let i = 0; i < 64; i++) {
+    const nonce = new Uint8Array(32).fill(i);
+    const signature = signNep413(nonce);
+    if (signature.includes("+")) return { nonce, signature };
+  }
+  throw new Error("expected a base64 signature containing '+'");
+}
+
+async function signerPublicKey(fragment: {
+  accountId: string;
+  signature: string;
+  publicKey: string;
+  nonce: Uint8Array;
+  message?: string;
+}): Promise<string> {
+  // Literal "+", not percent-encoded, so URLSearchParams would turn it into a space.
+  window.location.hash = `accountId=${fragment.accountId}&signature=${fragment.signature}&publicKey=${fragment.publicKey}`;
+  const store = new MemoryStore();
+  await store.set("signer-address", ACCOUNT);
+  await store.set("signer-public-key", realKey);
+  await store.set("sign-last-message", fragment.message ?? MESSAGE);
+  await store.set("sign-last-nonce", Array.from(fragment.nonce));
+  await store.set("sign-last-url", CALLBACK);
+  const wallet = { id: "my-near-wallet", signMessage: vi.fn() } as unknown as NearWallet;
+
+  const { publicKey } = await createNearWalletKwilSigner(wallet, ACCOUNT, store, kwilClient);
+  return publicKey;
+}
+
+describe("createNearWalletKwilSigner my-near-wallet redirect", () => {
+  afterEach(() => {
+    window.location.hash = "";
+    fullAccess.keys = [];
+    fullAccess.limitedKeys = [];
+    fullAccess.queries = 0;
+    fullAccess.lastRequest = undefined;
+  });
+
+  it("accepts a fragment whose signature matches the saved request and a full-access key", async () => {
+    const { nonce, signature } = signedRequest();
+    fullAccess.keys = [realKey, fragmentKey];
+
+    expect(
+      await signerPublicKey({ accountId: ACCOUNT, signature, publicKey: fragmentKey, nonce }),
+    ).toBe(fragmentKey);
+    expect(window.location.hash).toBe("");
+    expect(fullAccess.queries).toBe(1);
+    expect(fullAccess.lastRequest).toMatchObject({
+      request_type: "view_access_key_list",
+      account_id: ACCOUNT,
+    });
+  });
+
+  it("ignores a signature that does not match the saved request", async () => {
+    const { nonce, signature } = signedRequest();
+    fullAccess.keys = [realKey, fragmentKey];
+
+    expect(
+      await signerPublicKey({
+        accountId: ACCOUNT,
+        signature,
+        publicKey: fragmentKey,
+        nonce,
+        message: "different message",
+      }),
+    ).toBe(realKey);
+    expect(fullAccess.queries).toBe(0);
+  });
+
+  it("ignores a fragment for a different account", async () => {
+    const { nonce, signature } = signedRequest();
+    fullAccess.keys = [realKey, fragmentKey];
+
+    expect(
+      await signerPublicKey({
+        accountId: "attacker.testnet",
+        signature,
+        publicKey: fragmentKey,
+        nonce,
+      }),
+    ).toBe(realKey);
+    expect(fullAccess.queries).toBe(0);
+  });
+
+  it("ignores a public key that is not a full-access key of the account", async () => {
+    const { nonce, signature } = signedRequest();
+    fullAccess.keys = [realKey];
+    fullAccess.limitedKeys = [fragmentKey];
+
+    expect(
+      await signerPublicKey({ accountId: ACCOUNT, signature, publicKey: fragmentKey, nonce }),
+    ).toBe(realKey);
+    expect(fullAccess.queries).toBe(1);
+    expect(fullAccess.lastRequest).toMatchObject({
+      request_type: "view_access_key_list",
+      account_id: ACCOUNT,
+    });
+  });
+
+  it("does not replay an untrusted fragment signature", async () => {
+    const { nonce } = signedRequest();
+    window.location.hash = `accountId=${ACCOUNT}&signature=sig&publicKey=${fragmentKey}`;
+    const store = new MemoryStore();
+    await store.set("signer-address", ACCOUNT);
+    await store.set("signer-public-key", realKey);
+    await store.set("sign-last-message", MESSAGE);
+    await store.set("sign-last-nonce", Array.from(nonce));
+    await store.set("sign-last-url", CALLBACK);
+    const original = vi.fn();
+    const wallet = { id: "my-near-wallet", signMessage: original } as unknown as NearWallet;
+
+    await createNearWalletKwilSigner(wallet, ACCOUNT, store, kwilClient);
+    void wallet.signMessage?.({
+      message: MESSAGE,
+      recipient: RECIPIENT,
+      nonce: Buffer.alloc(32),
+    });
+
+    await vi.waitFor(() => expect(original).toHaveBeenCalledOnce());
+    expect(original.mock.calls[0]?.[0].message).toBe(MESSAGE);
+  });
+});

package/src/near/create-near-wallet-kwil-signer.ts

@@ -11,16 +11,17 @@ import { KwilSigner } from "@idos-network/kwil-js";
 import {
   base64Decode,
   binaryWriteUint16BE,
-  borshSerialize,
   bs58Decode,
   bytesConcat,
   hexEncode,
   utf8Decode,
 } from "@idos-network/utils/codecs";
+import nacl from "tweetnacl";
 
 import type { KwilActionClient } from "../create-kwil-client";
 
 import { getNearConnectionConfig } from "./get-config";
+import { nep413SignHash, serializeKwilNep413 } from "./nep413";
 
 const NEAR_WALLET_TYPES: string[] = [
   "browser",
@@ -88,25 +89,12 @@ function createNearWalletSigner(
       nonce: nonceSuggestion,
     }))!;
 
-    const nep413BorschSchema = {
-      struct: {
-        tag: "u32",
-        message: "string",
-        nonce: { array: { type: "u8", len: 32 } },
-        recipient: "string",
-        callbackUrl: { option: "string" },
-      },
-    };
-
-    const nep413BorshParams = {
-      tag: 2147484061,
+    const nep413BorshPayload = serializeKwilNep413({
       message: messageString,
       nonce: Array.from(nonce),
       recipient,
       callbackUrl,
-    };
-
-    const nep413BorshPayload = borshSerialize(nep413BorschSchema, nep413BorshParams);
+    });
     const result = bytesConcat(
       binaryWriteUint16BE(nep413BorshPayload.length),
       nep413BorshPayload,
@@ -149,6 +137,112 @@ export async function getNearFullAccessPublicKeys(
   }
 }
 
+type NearRedirect = {
+  accountId?: string;
+  publicKey?: string;
+  signature?: string;
+  error?: string;
+};
+
+function parseNearRedirect(hash: string): NearRedirect {
+  const params = new URLSearchParams(hash.startsWith("#") ? hash.slice(1) : hash);
+  const signature = params.get("signature");
+  return {
+    accountId: params.get("accountId") ?? undefined,
+    publicKey: params.get("publicKey") ?? undefined,
+    // URLSearchParams decodes a literal "+" as a space. NEP-413 signatures are base64.
+    signature: signature?.replaceAll(" ", "+"),
+    error: params.get("error") ?? undefined,
+  };
+}
+
+function takeNearRedirect(): NearRedirect {
+  const redirect = parseNearRedirect(window.location.hash);
+  if (!redirect.accountId && !redirect.publicKey && !redirect.signature && !redirect.error) {
+    return redirect;
+  }
+
+  const params = new URLSearchParams(window.location.hash.slice(1));
+  for (const key of ["accountId", "publicKey", "signature", "error", "state"]) params.delete(key);
+  const rest = params.toString();
+  window.history.replaceState(
+    null,
+    "",
+    `${window.location.pathname}${window.location.search}${rest ? `#${rest}` : ""}`,
+  );
+  return redirect;
+}
+
+function verifyNep413Signature(
+  message: string,
+  nonce: Uint8Array,
+  recipient: string,
+  callbackUrl: string,
+  signature: string,
+  publicKey: string,
+): boolean {
+  const pieces = publicKey.split(":");
+  if (pieces.length !== 2 || pieces[0] !== "ed25519" || !pieces[1] || nonce.length !== 32) {
+    return false;
+  }
+
+  try {
+    const publicKeyBytes = bs58Decode(pieces[1]);
+    const signatureBytes = base64Decode(signature);
+    if (publicKeyBytes.length !== 32 || signatureBytes.length !== 64) return false;
+
+    return nacl.sign.detached.verify(
+      nep413SignHash({ message, nonce, recipient, callbackUrl }),
+      signatureBytes,
+      publicKeyBytes,
+    );
+  } catch {
+    return false;
+  }
+}
+
+// The hash is attacker-controlled. A signature is only the wallet's if it verifies
+// against the request we stored before the redirect, for a full-access key of this account.
+async function trustedNearRedirect(
+  redirect: NearRedirect,
+  currentAddress: string,
+  recipient: string,
+  store: Store,
+): Promise<{ signature: string; publicKey: string } | undefined> {
+  if (
+    redirect.error ||
+    !redirect.signature ||
+    !redirect.publicKey ||
+    redirect.accountId !== currentAddress
+  ) {
+    return;
+  }
+
+  const message = await store.get<string>("sign-last-message");
+  const savedNonce = await store.get<number[] | Uint8Array>("sign-last-nonce");
+  const callbackUrl = await store.get<string>("sign-last-url");
+  if (!message || !savedNonce || !callbackUrl) return;
+
+  const nonce = Uint8Array.from(savedNonce);
+  if (
+    !verifyNep413Signature(
+      message,
+      nonce,
+      recipient,
+      callbackUrl,
+      redirect.signature,
+      redirect.publicKey,
+    )
+  ) {
+    return;
+  }
+
+  const keys = await getNearFullAccessPublicKeys(currentAddress);
+  if (!keys?.includes(redirect.publicKey)) return;
+
+  return { signature: redirect.signature, publicKey: redirect.publicKey };
+}
+
 export async function signNearMessage(
   wallet: NearWallet,
   message: string,
@@ -169,34 +263,33 @@ export async function createNearWalletKwilSigner(
   if (!wallet.signMessage) throw new Error("Only wallets with signMessage are supported.");
 
   if (wallet.id === "my-near-wallet") {
-    const { accountId, signature, publicKey, error } = Object.fromEntries(
-      new URLSearchParams(window.location.hash.slice(1)).entries(),
-    );
+    const redirect = takeNearRedirect();
+    const trusted = await trustedNearRedirect(redirect, currentAddress, recipient, store);
 
-    if (signature) {
-      await store.set("signer-address", accountId);
-      await store.set("signer-public-key", publicKey);
+    if (trusted) {
+      await store.set("signer-address", currentAddress);
+      await store.set("signer-public-key", trusted.publicKey);
     }
 
     const signMessageOriginal = wallet.signMessage.bind(wallet);
 
     wallet.signMessage = async ({
       message,
-      recipient,
+      recipient: signRecipient,
     }: SignMessageParams): Promise<SignedMessage & { nonce?: Uint8Array }> => {
-      if (error) return Promise.reject();
+      if (redirect.error) return Promise.reject();
 
       const lastMessage = await store.get<string>("sign-last-message");
       const lastNonce = await store.get<Uint8Array>("sign-last-nonce");
 
-      if (signature && message === lastMessage && lastNonce) {
+      if (trusted && message === lastMessage && lastNonce) {
         const nonce = Buffer.from(lastNonce);
         const callbackUrl = await store.get<string>("sign-last-url");
 
         return Promise.resolve({
           accountId: currentAddress,
-          publicKey,
-          signature,
+          publicKey: trusted.publicKey,
+          signature: trusted.signature,
           nonce,
           message,
           callbackUrl,
@@ -210,7 +303,7 @@ export async function createNearWalletKwilSigner(
       await store.set("sign-last-nonce", Array.from(nonce));
       await store.set("sign-last-url", callbackUrl);
 
-      signMessageOriginal({ message, nonce, recipient, callbackUrl });
+      signMessageOriginal({ message, nonce, recipient: signRecipient, callbackUrl });
 
       return new Promise(() => ({}) as SignedMessage);
     };

package/src/near/nep413.ts

@@ -2,56 +2,66 @@ import type { KeyPair } from "near-api-js";
 
 import {
   binaryWriteUint16BE,
+  borshDeserialize,
   borshSerialize,
   bytesConcat,
   sha256Hash,
   utf8Decode,
 } from "@idos-network/utils/codecs";
 
+// 2**31 + 413. Prepended so a NEP-413 payload cannot be a valid NEAR transaction.
+const NEP413_TAG = 2147484061;
+
+const nep413PayloadSchema = {
+  struct: {
+    message: "string",
+    nonce: { array: { type: "u8", len: 32 } },
+    recipient: "string",
+    callbackUrl: { option: "string" },
+  },
+} as const;
+
+// Borsh has no struct header, so this is the same bytes as `u32 tag` followed by `nep413PayloadSchema`.
+const kwilNep413Schema = {
+  struct: {
+    tag: "u32",
+    ...nep413PayloadSchema.struct,
+  },
+} as const;
+
+type Nep413Fields = {
+  message: string;
+  nonce: Uint8Array | number[];
+  recipient: string;
+  callbackUrl?: string;
+};
+
+export type Nep413Envelope = Nep413Fields & { tag: number };
+
+export function nep413SignHash(payload: Nep413Fields): Uint8Array {
+  return sha256Hash(
+    bytesConcat(borshSerialize("u32", NEP413_TAG), borshSerialize(nep413PayloadSchema, payload)),
+  );
+}
+
+export function serializeKwilNep413(payload: Nep413Fields): Uint8Array {
+  return borshSerialize(kwilNep413Schema, { tag: NEP413_TAG, ...payload });
+}
+
+export function deserializeKwilNep413(bytes: Uint8Array): Nep413Envelope {
+  return borshDeserialize(kwilNep413Schema, bytes) as Nep413Envelope;
+}
+
 export function kwilNep413Signer(
   recipient: string,
 ): (keyPair: KeyPair) => (messageBytes: Uint8Array) => Promise<Uint8Array> {
   return (keyPair: KeyPair) =>
     async (messageBytes: Uint8Array): Promise<Uint8Array> => {
       const message = utf8Decode(messageBytes);
-      const nonceLength = 32;
-      const nonce = crypto.getRandomValues(new Uint8Array(nonceLength));
-
-      const nep413BorschSchema = {
-        struct: {
-          message: "string",
-          nonce: { array: { type: "u8", len: nonceLength } },
-          recipient: "string",
-          callbackUrl: { option: "string" },
-        },
-      } as const;
-
-      const tag = 2147484061; // 2**31 + 413
-
-      const { signature } = keyPair.sign(
-        sha256Hash(
-          bytesConcat(
-            borshSerialize("u32", tag),
-            borshSerialize(nep413BorschSchema, { message, nonce, recipient }),
-          ),
-        ),
-      );
+      const nonce = crypto.getRandomValues(new Uint8Array(32));
+      const { signature } = keyPair.sign(nep413SignHash({ message, nonce, recipient }));
 
-      const kwilNep413BorschSchema = {
-        struct: {
-          tag: "u32",
-          ...nep413BorschSchema.struct,
-        },
-      };
-
-      const kwilNep413BorshParams = {
-        tag,
-        message,
-        nonce,
-        recipient,
-      };
-
-      const kwilNep413BorshPayload = borshSerialize(kwilNep413BorschSchema, kwilNep413BorshParams);
+      const kwilNep413BorshPayload = serializeKwilNep413({ message, nonce, recipient });
 
       return bytesConcat(
         binaryWriteUint16BE(kwilNep413BorshPayload.length),

package/src/near/signature-verification.test.ts

@@ -0,0 +1,35 @@
+import { hexEncode, utf8Encode } from "@idos-network/utils/codecs";
+import { KeyPair } from "near-api-js";
+import { describe, expect, it } from "vitest";
+
+import { kwilNep413Signer } from "./nep413";
+import { verifyNearSignature } from "./signature-verification";
+
+async function sign(message: string, recipient: string) {
+  const keyPair = KeyPair.fromRandom("ed25519");
+  const signed = await kwilNep413Signer(recipient)(keyPair)(utf8Encode(message));
+  return {
+    signature: hexEncode(signed),
+    publicKey: keyPair.getPublicKey().toString(),
+  };
+}
+
+describe("verifyNearSignature", () => {
+  it("accepts a signature addressed to idos.network", async () => {
+    const { signature, publicKey } = await sign("hello", "idos.network");
+    expect(await verifyNearSignature("hello", signature, publicKey)).toBe(true);
+  });
+
+  it.each(["evil.example", "idos.network.evil", "idos-issuer"])(
+    "rejects a valid signature addressed to %s",
+    async (recipient) => {
+      const { signature, publicKey } = await sign("hello", recipient);
+      expect(await verifyNearSignature("hello", signature, publicKey)).toBe(false);
+    },
+  );
+
+  it("rejects an idos.network signature of a different message", async () => {
+    const { signature, publicKey } = await sign("hello", "idos.network");
+    expect(await verifyNearSignature("goodbye", signature, publicKey)).toBe(false);
+  });
+});

package/src/near/signature-verification.ts

@@ -1,19 +1,10 @@
-import {
-  borshDeserialize,
-  borshSerialize,
-  bs58Decode,
-  hexDecode,
-  sha256Hash,
-} from "@idos-network/utils/codecs";
+import { bs58Decode, hexDecode } from "@idos-network/utils/codecs";
 import nacl from "tweetnacl";
 
-interface NEP413Payload {
-  tag: number;
-  message: string;
-  nonce: number[];
-  recipient: string;
-  callbackUrl?: string;
-}
+import { deserializeKwilNep413, nep413SignHash } from "./nep413";
+
+// Must match the recipient the idOS node accepts for NEP-413 wallet signatures.
+const NEP413_RECIPIENT = "idos.network";
 
 export const verifyNearSignature = async (
   message: string,
@@ -48,33 +39,21 @@ export const verifyNearSignature = async (
       return false;
     }
 
-    // Deserialize the payload to extract nonce, recipient, callbackUrl
-    const payloadSchema = {
-      struct: {
-        tag: "u32",
-        message: "string",
-        nonce: { array: { type: "u8", len: 32 } },
-        recipient: "string",
-        callbackUrl: { option: "string" },
-      },
-    };
+    const deserializedPayload = deserializeKwilNep413(payloadBytes);
 
-    const deserializedPayload = borshDeserialize(payloadSchema, payloadBytes) as NEP413Payload;
+    // NEP-413 binds the signature to a relying party; reject ones addressed elsewhere.
+    if (deserializedPayload.recipient !== NEP413_RECIPIENT) {
+      console.warn("Invalid NEP-413 recipient");
+      return false;
+    }
 
-    // Reconstruct the payload with tag and message (matching Go implementation)
-    const reconstructedPayload: NEP413Payload = {
-      tag: 2147484061, // 2**31 + 413
-      message: message, // Use the provided message
+    // Hash the caller-supplied message with the nonce and recipient from the envelope.
+    const hash = nep413SignHash({
+      message,
       nonce: deserializedPayload.nonce,
       recipient: deserializedPayload.recipient,
       callbackUrl: deserializedPayload.callbackUrl,
-    };
-
-    // Serialize the entire payload (matching Go's borsch.Serialize(*payload))
-    const fullPayloadBytes = borshSerialize(payloadSchema, reconstructedPayload);
-    // Hash the payload (matching Go's sha256.Sum256(payloadBytes))
-    const hash = sha256Hash(fullPayloadBytes);
-    // Raw ed25519 verification using nacl (matching Go's ed25519.Verify)
+    });
     const isValid = nacl.sign.detached.verify(hash, actualSignature, publicKeyBytes);
 
     return isValid;

package/dist/facesign-signer-5I8juA7p.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"facesign-signer-5I8juA7p.d.mts","names":[],"sources":["../src/facesign/facesign-signer.ts"],"mappings":";UAMiB;EACf;EACA;;UAGe;EACf,UAAU;EACV;;cAOW;;EAqBX;EACA;EACA;EACA;EAEA,YAAY,SAAS;EA2DrB,WAAiB;IAAU;;EAM3B,QAAc;EAWd,cAAoB;MA0BhB;EAIJ,YAAkB,SAAS,sBAAsB,QAAQ;EAiFzD,SAAe;EAqCf;EAqBA"}

package/dist/facesign-signer-z5T312uQ.mjs

@@ -1,2 +0,0 @@
-const e=6e5;var t=class{#e=null;#t=null;#n=null;#r=null;#i=null;#a=null;#o=null;#s=null;#c=null;#l=null;#u=null;#d=!1;#f=0;#p=null;#m;#h;#g;signatureType=`ed25519`;walletType=`FaceSign`;publicAddress=``;publicKey=``;constructor(e){this.#m=e.metadata,this.#h=e.enclaveUrl,this.#g=new URL(e.enclaveUrl).origin}#_(){this.#d||=(this.#u=e=>{if(e.origin===this.#g){if(e.data?.type===`facesign_ready`&&(this.#p=!!e.data.hasKey,this.#n?.()),e.data?.type===`sign_proposal_response`){let t=e.data.data;if(!t)return;t.signature?this.#r?.(new Uint8Array(t.signature)):this.#i?.(Error(`Sign request rejected by user`))}if(e.data?.type===`session_proposal_response`){let t=e.data.data;if(!t)return;t.approved&&t.address?this.#a?.({address:t.address}):this.#o?.(Error(`Session request rejected by user`))}if(e.data?.type===`address_response`){let t=e.data.data;this.#s?.(t?.address??null)}e.data?.type===`reset_complete`&&(e.data.data?.ok?this.#c?.():this.#l?.(Error(`FaceSign enclave failed to delete its key`)))}},window.addEventListener(`message`,this.#u),!0)}async preload(){return this.#_(),await this.#x(),{hasKey:this.#p??!1}}async init(){this.#_();let e=await this.#v();return this.publicKey=e.address,this.publicAddress=e.address,e.address}async getAddress(){return this.#_(),await this.#x(),this.#p?new Promise(t=>{let n=setTimeout(()=>t(null),e);this.#s=e=>{clearTimeout(n),this.#s=null,e&&(this.publicKey=e,this.publicAddress=e),t(e)},this.#e?.contentWindow?.postMessage({type:`address_request`,data:{id:++this.#f}},this.#h)}):null}get signer(){return this}async signMessage(t){await this.#x(),this.#S();let n=typeof t==`string`?new TextEncoder().encode(t):t;try{return await new Promise((t,r)=>{let i=setTimeout(()=>{r(Error(`FaceSign sign request timed out`))},e);this.#r=e=>{clearTimeout(i),t(e)},this.#i=e=>{clearTimeout(i),r(e)},setTimeout(()=>{this.#e?.contentWindow?.postMessage({type:`sign_proposal`,data:{id:++this.#f,data:n,metadata:this.#m}},this.#h)},300)})}finally{this.#r=null,this.#i=null,this.#C()}}async#v(){await this.#x(),this.#S();try{return await new Promise((t,n)=>{let r=setTimeout(()=>{n(Error(`FaceSign session proposal timed out`))},e);this.#a=e=>{clearTimeout(r),t(e)},this.#o=e=>{clearTimeout(r),n(e)},setTimeout(()=>{this.#e?.contentWindow?.postMessage({type:`session_proposal`,data:{id:++this.#f,metadata:this.#m}},this.#h)},300)})}finally{this.#a=null,this.#o=null,this.#C()}}async reset(){this.#_();let e=Date.now()+15e3;try{await this.#x(e-Date.now()),await new Promise((t,n)=>{let r=setTimeout(()=>{n(Error(`FaceSign reset timed out`))},Math.max(e-Date.now(),0));this.#c=()=>{clearTimeout(r),this.#c=null,this.#l=null,t()},this.#l=e=>{clearTimeout(r),this.#c=null,this.#l=null,n(e)},this.#e?.contentWindow?.postMessage({type:`reset`,data:{id:++this.#f}},this.#g)})}finally{this.destroy()}}hide(){this.#y(),this.#C()}#y(){let e=Error(`FaceSign operation cancelled`);this.#i&&=(this.#i(e),this.#r=null,null),this.#o&&=(this.#o(e),this.#a=null,null)}destroy(){this.#y(),this.#u&&=(window.removeEventListener(`message`,this.#u),null),this.#w()}#b(){let e=document.createElement(`dialog`);return Object.assign(e.style,{position:`fixed`,inset:`0`,width:`100%`,height:`100%`,maxWidth:`100%`,maxHeight:`100%`,margin:`0`,padding:`0`,border:`none`,zIndex:`99999`,background:`#0a0a0a`}),document.body.appendChild(e),e}#x(t=e){return this.#e?.contentWindow?Promise.resolve():new Promise((e,n)=>{let r=setTimeout(()=>{n(Error(`FaceSign enclave failed to load`))},t);this.#t||=this.#b(),this.#e=document.createElement(`iframe`),this.#e.src=this.#h,this.#e.title=`FaceSign Enclave`,this.#e.allow=`camera; fullscreen`,this.#e.style.cssText=`width:100%;height:100%;border:none;`,this.#t.appendChild(this.#e),this.#n=()=>{console.log(`resolveOpenEnclave`),clearTimeout(r),e()}})}#S(){let e=this.#t;e&&!e.open&&e.showModal()}#C(){let e=this.#t;e?.open&&e.close()}#w(){this.#e&&=(this.#e.remove(),null),this.#t&&=(this.#t.remove(),null)}};export{t};
-//# sourceMappingURL=facesign-signer-z5T312uQ.mjs.map