@partylayer/adapter-bron 0.2.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CantonConnect
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,89 @@
+import * as _partylayer_core from '@partylayer/core';
+import { WalletAdapter, CapabilityKey, AdapterDetectResult, AdapterContext, AdapterConnectResult, SignMessageParams, SignTransactionParams } from '@partylayer/core';
+
+/**
+ * Bron OAuth2 Authentication Client
+ *
+ * Handles OAuth2 flows for Bron enterprise wallet.
+ *
+ * References:
+ * - Bron developer portal: https://developer.bron.org/
+ * - Bron ecosystem: https://www.canton.network/ecosystem/bron-wallet
+ */
+
+/**
+ * OAuth2 configuration
+ */
+interface BronAuthConfig {
+    /** Authorization server URL */
+    authorizationUrl: string;
+    /** Token endpoint URL */
+    tokenUrl: string;
+    /** Client ID */
+    clientId: string;
+    /** Client secret (for server-side flows) */
+    clientSecret?: string;
+    /** Redirect URI */
+    redirectUri: string;
+    /** Scopes */
+    scopes?: string[];
+    /** Use PKCE (recommended for browser) */
+    usePKCE?: boolean;
+}
+
+/**
+ * Bron API Client
+ *
+ * Typed client for Bron enterprise wallet API endpoints.
+ *
+ * References:
+ * - Bron developer portal: https://developer.bron.org/
+ */
+
+/**
+ * Bron API configuration
+ */
+interface BronApiConfig {
+    /** Base API URL */
+    baseUrl: string;
+    /** Access token getter */
+    getAccessToken: () => Promise<string | null>;
+}
+
+/**
+ * Bron adapter configuration
+ */
+interface BronAdapterConfig {
+    /** OAuth2 configuration */
+    auth: BronAuthConfig;
+    /** API configuration */
+    api: BronApiConfig;
+    /** Use mock API in development */
+    useMockApi?: boolean;
+}
+/**
+ * Bron Wallet Adapter
+ */
+declare class BronAdapter implements WalletAdapter {
+    readonly walletId: _partylayer_core.WalletId;
+    readonly name = "Bron";
+    private authClient;
+    private apiClient;
+    constructor(config: BronAdapterConfig);
+    /**
+     * Create mock API client for development
+     */
+    private createMockApiClient;
+    getCapabilities(): CapabilityKey[];
+    detectInstalled(): Promise<AdapterDetectResult>;
+    connect(ctx: AdapterContext, _opts?: {
+        timeoutMs?: number;
+        requiredCapabilities?: CapabilityKey[];
+    }): Promise<AdapterConnectResult>;
+    disconnect(_ctx: AdapterContext, _session: _partylayer_core.Session): Promise<void>;
+    restore(_ctx: AdapterContext, persisted: _partylayer_core.PersistedSession): Promise<_partylayer_core.Session | null>;
+    signMessage(_ctx: AdapterContext, session: _partylayer_core.Session, params: SignMessageParams): Promise<_partylayer_core.SignedMessage>;
+    signTransaction(_ctx: AdapterContext, session: _partylayer_core.Session, params: SignTransactionParams): Promise<_partylayer_core.SignedTransaction>;
+}
+
+export { BronAdapter, type BronAdapterConfig, type BronApiConfig, type BronAuthConfig };

package/dist/index.d.ts

@@ -0,0 +1,89 @@
+import * as _partylayer_core from '@partylayer/core';
+import { WalletAdapter, CapabilityKey, AdapterDetectResult, AdapterContext, AdapterConnectResult, SignMessageParams, SignTransactionParams } from '@partylayer/core';
+
+/**
+ * Bron OAuth2 Authentication Client
+ *
+ * Handles OAuth2 flows for Bron enterprise wallet.
+ *
+ * References:
+ * - Bron developer portal: https://developer.bron.org/
+ * - Bron ecosystem: https://www.canton.network/ecosystem/bron-wallet
+ */
+
+/**
+ * OAuth2 configuration
+ */
+interface BronAuthConfig {
+    /** Authorization server URL */
+    authorizationUrl: string;
+    /** Token endpoint URL */
+    tokenUrl: string;
+    /** Client ID */
+    clientId: string;
+    /** Client secret (for server-side flows) */
+    clientSecret?: string;
+    /** Redirect URI */
+    redirectUri: string;
+    /** Scopes */
+    scopes?: string[];
+    /** Use PKCE (recommended for browser) */
+    usePKCE?: boolean;
+}
+
+/**
+ * Bron API Client
+ *
+ * Typed client for Bron enterprise wallet API endpoints.
+ *
+ * References:
+ * - Bron developer portal: https://developer.bron.org/
+ */
+
+/**
+ * Bron API configuration
+ */
+interface BronApiConfig {
+    /** Base API URL */
+    baseUrl: string;
+    /** Access token getter */
+    getAccessToken: () => Promise<string | null>;
+}
+
+/**
+ * Bron adapter configuration
+ */
+interface BronAdapterConfig {
+    /** OAuth2 configuration */
+    auth: BronAuthConfig;
+    /** API configuration */
+    api: BronApiConfig;
+    /** Use mock API in development */
+    useMockApi?: boolean;
+}
+/**
+ * Bron Wallet Adapter
+ */
+declare class BronAdapter implements WalletAdapter {
+    readonly walletId: _partylayer_core.WalletId;
+    readonly name = "Bron";
+    private authClient;
+    private apiClient;
+    constructor(config: BronAdapterConfig);
+    /**
+     * Create mock API client for development
+     */
+    private createMockApiClient;
+    getCapabilities(): CapabilityKey[];
+    detectInstalled(): Promise<AdapterDetectResult>;
+    connect(ctx: AdapterContext, _opts?: {
+        timeoutMs?: number;
+        requiredCapabilities?: CapabilityKey[];
+    }): Promise<AdapterConnectResult>;
+    disconnect(_ctx: AdapterContext, _session: _partylayer_core.Session): Promise<void>;
+    restore(_ctx: AdapterContext, persisted: _partylayer_core.PersistedSession): Promise<_partylayer_core.Session | null>;
+    signMessage(_ctx: AdapterContext, session: _partylayer_core.Session, params: SignMessageParams): Promise<_partylayer_core.SignedMessage>;
+    signTransaction(_ctx: AdapterContext, session: _partylayer_core.Session, params: SignTransactionParams): Promise<_partylayer_core.SignedTransaction>;
+}
+
+export { BronAdapter, type BronAdapterConfig, type BronApiConfig, type BronAuthConfig };

package/dist/index.js

@@ -0,0 +1,479 @@
+'use strict';
+
+var core = require('@partylayer/core');
+
+// src/bron-adapter.ts
+
+// src/auth.ts
+var BronAuthClient = class {
+  config;
+  storage;
+  tokens = null;
+  // In-memory by default
+  constructor(config, storage) {
+    this.config = config;
+    this.storage = storage;
+  }
+  /**
+   * Generate PKCE code verifier and challenge
+   */
+  async generatePKCE() {
+    const verifier = this.generateRandomString(128);
+    const encoder = new TextEncoder();
+    const data = encoder.encode(verifier);
+    const digest = await crypto.subtle.digest("SHA-256", data);
+    const challenge = btoa(String.fromCharCode(...new Uint8Array(digest))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    return { verifier, challenge };
+  }
+  /**
+   * Generate random string
+   */
+  generateRandomString(length) {
+    const array = new Uint8Array(length);
+    crypto.getRandomValues(array);
+    return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Start authorization flow
+   */
+  async startAuth() {
+    const state = this.generateRandomString(32);
+    const params = new URLSearchParams({
+      response_type: "code",
+      client_id: this.config.clientId,
+      redirect_uri: this.config.redirectUri,
+      state,
+      scope: (this.config.scopes || ["openid", "profile"]).join(" ")
+    });
+    if (this.config.usePKCE) {
+      const pkce = await this.generatePKCE();
+      params.set("code_challenge", pkce.challenge);
+      params.set("code_challenge_method", "S256");
+      if (typeof window !== "undefined") {
+        sessionStorage.setItem("bron_pkce_verifier", pkce.verifier);
+        sessionStorage.setItem("bron_auth_state", state);
+      }
+    } else {
+      if (typeof window !== "undefined") {
+        sessionStorage.setItem("bron_auth_state", state);
+      }
+    }
+    const authUrl = `${this.config.authorizationUrl}?${params.toString()}`;
+    return authUrl;
+  }
+  /**
+   * Finish authorization flow with callback URL
+   */
+  async finishAuth(callbackUrl) {
+    const url = new URL(callbackUrl);
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    const error = url.searchParams.get("error");
+    if (error) {
+      throw new Error(`OAuth error: ${error}`);
+    }
+    if (!code) {
+      throw new Error("No authorization code in callback");
+    }
+    if (typeof window !== "undefined") {
+      const storedState = sessionStorage.getItem("bron_auth_state");
+      if (state !== storedState) {
+        throw new Error("State mismatch");
+      }
+    }
+    const tokenParams = new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: this.config.redirectUri,
+      client_id: this.config.clientId
+    });
+    if (this.config.usePKCE && typeof window !== "undefined") {
+      const verifier = sessionStorage.getItem("bron_pkce_verifier");
+      if (verifier) {
+        tokenParams.set("code_verifier", verifier);
+        sessionStorage.removeItem("bron_pkce_verifier");
+      }
+    }
+    if (this.config.clientSecret) {
+      tokenParams.set("client_secret", this.config.clientSecret);
+    }
+    const response = await fetch(this.config.tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: tokenParams.toString()
+    });
+    if (!response.ok) {
+      const error2 = await response.text();
+      throw new Error(`Token exchange failed: ${error2}`);
+    }
+    const tokenData = await response.json();
+    const tokens = {
+      accessToken: tokenData.access_token,
+      refreshToken: tokenData.refresh_token,
+      expiresAt: Date.now() + tokenData.expires_in * 1e3,
+      tokenType: tokenData.token_type || "Bearer"
+    };
+    this.tokens = tokens;
+    if (this.storage) {
+      await this.storage.set("bron_tokens", JSON.stringify(tokens));
+    }
+    if (typeof window !== "undefined") {
+      sessionStorage.removeItem("bron_auth_state");
+    }
+    return tokens;
+  }
+  /**
+   * Get current access token
+   */
+  async getAccessToken() {
+    if (this.tokens && Date.now() < this.tokens.expiresAt) {
+      return this.tokens.accessToken;
+    }
+    if (this.storage) {
+      const stored = await this.storage.get("bron_tokens");
+      if (stored) {
+        this.tokens = JSON.parse(stored);
+        if (Date.now() < this.tokens.expiresAt) {
+          return this.tokens.accessToken;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Logout
+   */
+  async logout() {
+    this.tokens = null;
+    if (this.storage) {
+      await this.storage.remove("bron_tokens");
+    }
+  }
+};
+var BronApiClient = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create authenticated request headers
+   */
+  async getHeaders() {
+    const token = await this.config.getAccessToken();
+    if (!token) {
+      throw new Error("No access token available");
+    }
+    return {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  /**
+   * Create session / get party mapping
+   */
+  async createSession() {
+    if (this.config.baseUrl.includes("mock") || this.config.baseUrl.includes("dev")) {
+      return {
+        sessionId: "mock-session-" + Date.now(),
+        partyId: core.toPartyId("mock-party-" + Date.now()),
+        expiresAt: Date.now() + 36e5
+      };
+    }
+    const headers = await this.getHeaders();
+    const response = await fetch(`${this.config.baseUrl}/sessions`, {
+      method: "POST",
+      headers
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to create session: ${error}`);
+    }
+    const data = await response.json();
+    return {
+      sessionId: data.sessionId,
+      partyId: core.toPartyId(data.partyId),
+      expiresAt: data.expiresAt
+    };
+  }
+  /**
+   * Request signature
+   */
+  async requestSignature(request) {
+    if (this.config.baseUrl.includes("mock") || this.config.baseUrl.includes("dev")) {
+      return {
+        requestId: "mock-request-" + Date.now(),
+        status: "pending"
+      };
+    }
+    const headers = await this.getHeaders();
+    const response = await fetch(`${this.config.baseUrl}/signatures`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to request signature: ${error}`);
+    }
+    const data = await response.json();
+    return {
+      requestId: data.requestId,
+      status: data.status,
+      signature: data.signature,
+      transactionHash: data.transactionHash
+    };
+  }
+  /**
+   * Get request status
+   */
+  async getRequestStatus(requestId) {
+    if (this.config.baseUrl.includes("mock") || this.config.baseUrl.includes("dev")) {
+      return {
+        requestId,
+        status: "approved",
+        signature: "mock-signature-" + requestId,
+        transactionHash: "mock-tx-hash"
+      };
+    }
+    const headers = await this.getHeaders();
+    const response = await fetch(`${this.config.baseUrl}/signatures/${requestId}`, {
+      method: "GET",
+      headers
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to get request status: ${error}`);
+    }
+    const data = await response.json();
+    return {
+      requestId: data.requestId,
+      status: data.status,
+      signature: data.signature,
+      transactionHash: data.transactionHash,
+      error: data.error
+    };
+  }
+  /**
+   * Poll request status until complete
+   */
+  async pollRequestStatus(requestId, timeoutMs = 6e4, intervalMs = 2e3) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const status = await this.getRequestStatus(requestId);
+      if (status.status === "approved" || status.status === "denied" || status.status === "expired") {
+        return status;
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new Error("Polling timeout");
+  }
+};
+
+// src/bron-adapter.ts
+var BronAdapter = class {
+  walletId = core.toWalletId("bron");
+  name = "Bron";
+  authClient;
+  apiClient;
+  constructor(config) {
+    this.authClient = new BronAuthClient(config.auth);
+    if (config.useMockApi || process.env.NODE_ENV === "development") {
+      this.apiClient = this.createMockApiClient();
+    } else {
+      this.apiClient = new BronApiClient({
+        baseUrl: config.api.baseUrl,
+        getAccessToken: async () => {
+          return await this.authClient.getAccessToken();
+        }
+      });
+    }
+  }
+  /**
+   * Create mock API client for development
+   */
+  createMockApiClient() {
+    const mockBaseUrl = "https://api.bron.dev";
+    return new BronApiClient({
+      baseUrl: mockBaseUrl,
+      getAccessToken: () => {
+        return Promise.resolve("mock-bron-token");
+      }
+    });
+  }
+  getCapabilities() {
+    return [
+      "connect",
+      "disconnect",
+      "remoteSigner",
+      "signMessage",
+      "signTransaction"
+      // restore depends on session persistence
+    ];
+  }
+  detectInstalled() {
+    return Promise.resolve({
+      installed: true,
+      reason: "Bron is a remote signer service"
+    });
+  }
+  async connect(ctx, _opts) {
+    try {
+      let accessToken = await this.authClient.getAccessToken();
+      if (!accessToken) {
+        if (typeof window === "undefined") {
+          throw new Error("OAuth flow requires browser environment");
+        }
+        const authUrl = await this.authClient.startAuth();
+        const popup = window.open(
+          authUrl,
+          "Bron Auth",
+          "width=500,height=600"
+        );
+        if (!popup) {
+          throw new Error("Failed to open auth popup");
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        if (process.env.NODE_ENV === "development") {
+          accessToken = "mock-token";
+        } else {
+          throw new Error("OAuth callback not implemented in adapter - handle in app");
+        }
+      }
+      const session = await this.apiClient.createSession();
+      return {
+        partyId: session.partyId,
+        session: {
+          walletId: this.walletId,
+          network: ctx.network,
+          createdAt: Date.now(),
+          expiresAt: session.expiresAt,
+          capabilitiesSnapshot: ["connect", "signMessage", "signTransaction", "remoteSigner"],
+          metadata: {
+            sessionId: session.sessionId
+          }
+        },
+        capabilities: ["connect", "signMessage", "signTransaction", "remoteSigner"]
+      };
+    } catch (err) {
+      throw core.mapUnknownErrorToPartyLayerError(err, {
+        walletId: this.walletId,
+        phase: "connect",
+        transport: "remote"
+      });
+    }
+  }
+  async disconnect(_ctx, _session) {
+    await this.authClient.logout();
+  }
+  async restore(_ctx, persisted) {
+    const sessionId = persisted.metadata?.sessionId;
+    if (typeof sessionId !== "string") {
+      return null;
+    }
+    const accessToken = await this.authClient.getAccessToken();
+    if (!accessToken) {
+      return null;
+    }
+    if (persisted.expiresAt && Date.now() >= persisted.expiresAt) {
+      return null;
+    }
+    return {
+      ...persisted,
+      walletId: this.walletId
+    };
+  }
+  async signMessage(_ctx, session, params) {
+    try {
+      const sessionId = session.metadata?.sessionId;
+      if (typeof sessionId !== "string") {
+        throw new Error("No session ID");
+      }
+      const signResponse = await this.apiClient.requestSignature({
+        message: params.message,
+        sessionId
+      });
+      if (signResponse.status === "pending") {
+        const status = await this.apiClient.pollRequestStatus(signResponse.requestId);
+        if (status.status === "denied") {
+          throw new core.UserRejectedError("Signature request denied");
+        }
+        if (status.status === "approved" && status.signature) {
+          return {
+            message: params.message,
+            signature: core.toSignature(status.signature),
+            partyId: session.partyId
+          };
+        }
+        throw new Error("Signature request failed");
+      }
+      if (signResponse.status === "denied") {
+        throw new core.UserRejectedError("Signature request denied");
+      }
+      if (!signResponse.signature) {
+        throw new Error("No signature in response");
+      }
+      return {
+        message: params.message,
+        signature: core.toSignature(signResponse.signature),
+        partyId: session.partyId
+      };
+    } catch (err) {
+      throw core.mapUnknownErrorToPartyLayerError(err, {
+        walletId: this.walletId,
+        phase: "signMessage",
+        transport: "remote"
+      });
+    }
+  }
+  async signTransaction(_ctx, session, params) {
+    try {
+      const sessionId = session.metadata?.sessionId;
+      if (typeof sessionId !== "string") {
+        throw new Error("No session ID");
+      }
+      const signResponse = await this.apiClient.requestSignature({
+        transaction: params.tx,
+        sessionId
+      });
+      if (signResponse.status === "pending") {
+        const status = await this.apiClient.pollRequestStatus(signResponse.requestId);
+        if (status.status === "denied") {
+          throw new core.UserRejectedError("Transaction signing denied");
+        }
+        if (status.status === "approved" && status.signature) {
+          const signedTx2 = typeof params.tx === "object" && params.tx !== null ? { ...params.tx, signature: status.signature } : { tx: params.tx, signature: status.signature };
+          return {
+            signedTx: signedTx2,
+            transactionHash: status.transactionHash ? core.toTransactionHash(status.transactionHash) : core.toTransactionHash("pending"),
+            partyId: session.partyId
+          };
+        }
+        throw new Error("Transaction signing failed");
+      }
+      if (signResponse.status === "denied") {
+        throw new core.UserRejectedError("Transaction signing denied");
+      }
+      if (!signResponse.signature) {
+        throw new Error("No signature in response");
+      }
+      const signedTx = typeof params.tx === "object" && params.tx !== null ? { ...params.tx, signature: signResponse.signature } : { tx: params.tx, signature: signResponse.signature };
+      return {
+        signedTx,
+        transactionHash: signResponse.transactionHash ? core.toTransactionHash(signResponse.transactionHash) : core.toTransactionHash("pending"),
+        partyId: session.partyId
+      };
+    } catch (err) {
+      throw core.mapUnknownErrorToPartyLayerError(err, {
+        walletId: this.walletId,
+        phase: "signTransaction",
+        transport: "remote"
+      });
+    }
+  }
+};
+
+exports.BronAdapter = BronAdapter;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map