@karn_lat/protocol-sdk 0.1.0-alpha.1

package/src/wallet/adapters/AlbedoAdapter.ts

@@ -0,0 +1,140 @@
+/**
+ * Albedo Wallet Adapter
+ *
+ * Web-based Stellar wallet (no extension required)
+ * https://albedo.link
+ */
+
+import {
+  WalletAdapter,
+  WalletType,
+  WalletMetadata,
+  SignTransactionOptions,
+  WalletError,
+  WalletErrorCode,
+} from '../types.js';
+
+// Albedo API types
+interface AlbedoAPI {
+  publicKey(options?: { require_existing?: boolean }): Promise<{ pubkey: string }>;
+  tx(options: {
+    xdr: string;
+    network?: string;
+    pubkey?: string;
+    submit?: boolean;
+  }): Promise<{ signed_envelope_xdr: string; tx_hash?: string; network?: string }>;
+  trust(options: { asset_code: string; asset_issuer: string }): Promise<any>;
+}
+
+declare global {
+  interface Window {
+    albedo?: AlbedoAPI;
+  }
+}
+
+export class AlbedoAdapter implements WalletAdapter {
+  type = WalletType.ALBEDO;
+
+  metadata: WalletMetadata = {
+    type: WalletType.ALBEDO,
+    name: 'Albedo',
+    url: 'https://albedo.link',
+    description: 'Web-based Stellar wallet with seamless browser integration',
+    isAvailable: true, // Albedo is always available (web-based)
+  };
+
+  private currentAddress: string | null = null;
+
+  async isAvailable(): Promise<boolean> {
+    // Albedo is web-based, always available
+    // Load script if not present
+    if (typeof window !== 'undefined' && !window.albedo) {
+      await this.loadAlbedoScript();
+    }
+    return true;
+  }
+
+  private async loadAlbedoScript(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (window.albedo) {
+        resolve();
+        return;
+      }
+
+      const script = document.createElement('script');
+      script.src = 'https://cdn.jsdelivr.net/npm/@albedo-link/intent@latest/lib/albedo.intent.js';
+      script.async = true;
+      script.onload = () => resolve();
+      script.onerror = () => reject(new Error('Failed to load Albedo'));
+      document.head.appendChild(script);
+    });
+  }
+
+  async connect(): Promise<string> {
+    await this.isAvailable();
+
+    if (!window.albedo) {
+      throw new WalletError(
+        'Albedo failed to load',
+        WalletErrorCode.NOT_INSTALLED,
+        WalletType.ALBEDO
+      );
+    }
+
+    try {
+      const result = await window.albedo.publicKey({ require_existing: false });
+      this.currentAddress = result.pubkey;
+      return result.pubkey;
+    } catch (error: any) {
+      throw new WalletError(
+        `Failed to connect to Albedo: ${error.message}`,
+        WalletErrorCode.USER_REJECTED,
+        WalletType.ALBEDO
+      );
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    this.currentAddress = null;
+  }
+
+  async getAddress(): Promise<string | null> {
+    return this.currentAddress;
+  }
+
+  async isConnected(): Promise<boolean> {
+    return this.currentAddress !== null;
+  }
+
+  async signTransaction(
+    xdr: string,
+    options?: SignTransactionOptions
+  ): Promise<string> {
+    await this.isAvailable();
+
+    if (!window.albedo) {
+      throw new WalletError(
+        'Albedo is not available',
+        WalletErrorCode.NOT_CONNECTED,
+        WalletType.ALBEDO
+      );
+    }
+
+    try {
+      const result = await window.albedo.tx({
+        xdr,
+        network: options?.networkPassphrase || 'testnet',
+        pubkey: this.currentAddress || undefined,
+        submit: false, // Don't auto-submit
+      });
+
+      return result.signed_envelope_xdr;
+    } catch (error: any) {
+      throw new WalletError(
+        `Failed to sign transaction: ${error.message}`,
+        WalletErrorCode.SIGNING_FAILED,
+        WalletType.ALBEDO
+      );
+    }
+  }
+}

package/src/wallet/adapters/FreighterAdapter.ts

@@ -0,0 +1,179 @@
+/**
+ * Freighter Wallet Adapter
+ *
+ * Official Stellar wallet extension
+ * https://freighter.app
+ */
+
+import {
+  WalletAdapter,
+  WalletType,
+  WalletMetadata,
+  SignTransactionOptions,
+  WalletError,
+  WalletErrorCode,
+} from '../types.js';
+
+// Freighter API types (from @stellar/freighter-api)
+interface FreighterAPI {
+  isConnected(): Promise<boolean>;
+  getPublicKey(): Promise<string>;
+  signTransaction(
+    xdr: string,
+    opts?: { network?: string; networkPassphrase?: string; accountToSign?: string }
+  ): Promise<string>;
+  getNetwork(): Promise<string>;
+  getNetworkDetails(): Promise<{ network: string; networkPassphrase: string }>;
+}
+
+declare global {
+  interface Window {
+    freighter?: FreighterAPI;
+  }
+}
+
+export class FreighterAdapter implements WalletAdapter {
+  type = WalletType.FREIGHTER;
+
+  metadata: WalletMetadata = {
+    type: WalletType.FREIGHTER,
+    name: 'Freighter',
+    url: 'https://freighter.app',
+    chromeUrl: 'https://chrome.google.com/webstore/detail/freighter/bcacfldlkkdogcmkkibnjlakofdplcbk',
+    firefoxUrl: 'https://addons.mozilla.org/en-US/firefox/addon/freighter/',
+    description: 'Official Stellar wallet extension with Soroban support',
+    isAvailable: false,
+  };
+
+  private api: FreighterAPI | null = null;
+
+  constructor() {
+    this.init();
+  }
+
+  private init() {
+    if (typeof window !== 'undefined' && window.freighter) {
+      this.api = window.freighter;
+      this.metadata.isAvailable = true;
+    }
+  }
+
+  async isAvailable(): Promise<boolean> {
+    return this.metadata.isAvailable;
+  }
+
+  async connect(): Promise<string> {
+    if (!this.api) {
+      throw new WalletError(
+        'Freighter is not installed. Please install from https://freighter.app',
+        WalletErrorCode.NOT_INSTALLED,
+        WalletType.FREIGHTER
+      );
+    }
+
+    try {
+      const publicKey = await this.api.getPublicKey();
+      if (!publicKey) {
+        throw new WalletError(
+          'User rejected connection request',
+          WalletErrorCode.USER_REJECTED,
+          WalletType.FREIGHTER
+        );
+      }
+      return publicKey;
+    } catch (error: any) {
+      if (error instanceof WalletError) throw error;
+
+      throw new WalletError(
+        `Failed to connect to Freighter: ${error.message}`,
+        WalletErrorCode.UNKNOWN_ERROR,
+        WalletType.FREIGHTER
+      );
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    // Freighter doesn't have explicit disconnect
+    // Connection state is managed by extension
+    this.api = null;
+  }
+
+  async getAddress(): Promise<string | null> {
+    if (!this.api) return null;
+
+    try {
+      const connected = await this.api.isConnected();
+      if (!connected) return null;
+
+      return await this.api.getPublicKey();
+    } catch {
+      return null;
+    }
+  }
+
+  async isConnected(): Promise<boolean> {
+    if (!this.api) return false;
+
+    try {
+      return await this.api.isConnected();
+    } catch {
+      return false;
+    }
+  }
+
+  async signTransaction(
+    xdr: string,
+    options?: SignTransactionOptions
+  ): Promise<string> {
+    if (!this.api) {
+      throw new WalletError(
+        'Freighter is not connected',
+        WalletErrorCode.NOT_CONNECTED,
+        WalletType.FREIGHTER
+      );
+    }
+
+    try {
+      const signedXdr = await this.api.signTransaction(xdr, {
+        networkPassphrase: options?.networkPassphrase,
+        accountToSign: options?.accountToSign,
+      });
+
+      return signedXdr;
+    } catch (error: any) {
+      if (error.message?.includes('User declined')) {
+        throw new WalletError(
+          'User rejected signature request',
+          WalletErrorCode.USER_REJECTED,
+          WalletType.FREIGHTER
+        );
+      }
+
+      throw new WalletError(
+        `Failed to sign transaction: ${error.message}`,
+        WalletErrorCode.SIGNING_FAILED,
+        WalletType.FREIGHTER
+      );
+    }
+  }
+
+  async getNetwork(): Promise<string> {
+    if (!this.api) {
+      throw new WalletError(
+        'Freighter is not connected',
+        WalletErrorCode.NOT_CONNECTED,
+        WalletType.FREIGHTER
+      );
+    }
+
+    try {
+      return await this.api.getNetwork();
+    } catch (error: any) {
+      throw new WalletError(
+        `Failed to get network: ${error.message}`,
+        WalletErrorCode.NETWORK_ERROR,
+        WalletType.FREIGHTER
+      );
+    }
+  }
+}

package/src/wallet/adapters/LobstrAdapter.ts

@@ -0,0 +1,142 @@
+/**
+ * Lobstr Wallet Adapter
+ *
+ * Popular Stellar mobile wallet with extension support
+ * https://lobstr.co
+ */
+
+import {
+  WalletAdapter,
+  WalletType,
+  WalletMetadata,
+  SignTransactionOptions,
+  WalletError,
+  WalletErrorCode,
+} from '../types.js';
+
+// Lobstr Extension API (similar to Freighter)
+interface LobstrAPI {
+  isConnected(): Promise<boolean>;
+  getPublicKey(): Promise<string>;
+  signTransaction(xdr: string, opts?: { network?: string }): Promise<string>;
+}
+
+declare global {
+  interface Window {
+    lobstrExtension?: LobstrAPI;
+  }
+}
+
+export class LobstrAdapter implements WalletAdapter {
+  type = WalletType.LOBSTR;
+
+  metadata: WalletMetadata = {
+    type: WalletType.LOBSTR,
+    name: 'Lobstr',
+    url: 'https://lobstr.co',
+    chromeUrl: 'https://chrome.google.com/webstore/detail/lobstr-extension/cmgchfbiagidgmjmfjkhldngnmlfpnog',
+    description: 'Popular Stellar wallet with mobile and extension support',
+    isAvailable: false,
+  };
+
+  private api: LobstrAPI | null = null;
+
+  constructor() {
+    this.init();
+  }
+
+  private init() {
+    if (typeof window !== 'undefined' && window.lobstrExtension) {
+      this.api = window.lobstrExtension;
+      this.metadata.isAvailable = true;
+    }
+  }
+
+  async isAvailable(): Promise<boolean> {
+    return this.metadata.isAvailable;
+  }
+
+  async connect(): Promise<string> {
+    if (!this.api) {
+      throw new WalletError(
+        'Lobstr Extension is not installed',
+        WalletErrorCode.NOT_INSTALLED,
+        WalletType.LOBSTR
+      );
+    }
+
+    try {
+      const publicKey = await this.api.getPublicKey();
+      if (!publicKey) {
+        throw new WalletError(
+          'User rejected connection request',
+          WalletErrorCode.USER_REJECTED,
+          WalletType.LOBSTR
+        );
+      }
+      return publicKey;
+    } catch (error: any) {
+      if (error instanceof WalletError) throw error;
+
+      throw new WalletError(
+        `Failed to connect to Lobstr: ${error.message}`,
+        WalletErrorCode.UNKNOWN_ERROR,
+        WalletType.LOBSTR
+      );
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    this.api = null;
+  }
+
+  async getAddress(): Promise<string | null> {
+    if (!this.api) return null;
+
+    try {
+      const connected = await this.api.isConnected();
+      if (!connected) return null;
+
+      return await this.api.getPublicKey();
+    } catch {
+      return null;
+    }
+  }
+
+  async isConnected(): Promise<boolean> {
+    if (!this.api) return false;
+
+    try {
+      return await this.api.isConnected();
+    } catch {
+      return false;
+    }
+  }
+
+  async signTransaction(
+    xdr: string,
+    options?: SignTransactionOptions
+  ): Promise<string> {
+    if (!this.api) {
+      throw new WalletError(
+        'Lobstr is not connected',
+        WalletErrorCode.NOT_CONNECTED,
+        WalletType.LOBSTR
+      );
+    }
+
+    try {
+      const signedXdr = await this.api.signTransaction(xdr, {
+        network: options?.networkPassphrase,
+      });
+
+      return signedXdr;
+    } catch (error: any) {
+      throw new WalletError(
+        `Failed to sign transaction: ${error.message}`,
+        WalletErrorCode.SIGNING_FAILED,
+        WalletType.LOBSTR
+      );
+    }
+  }
+}

package/src/wallet/adapters/RabetAdapter.ts

@@ -0,0 +1,162 @@
+/**
+ * Rabet Wallet Adapter
+ *
+ * Modern Stellar wallet with built-in swap features
+ * https://rabet.io
+ */
+
+import {
+  WalletAdapter,
+  WalletType,
+  WalletMetadata,
+  SignTransactionOptions,
+  WalletError,
+  WalletErrorCode,
+} from '../types.js';
+
+// Rabet API types
+interface RabetAPI {
+  connect(): Promise<{ publicKey: string }>;
+  sign(xdr: string, opts?: { network?: string }): Promise<{ xdr: string }>;
+  disconnect(): Promise<void>;
+  isConnected(): Promise<boolean>;
+}
+
+declare global {
+  interface Window {
+    rabet?: RabetAPI;
+  }
+}
+
+export class RabetAdapter implements WalletAdapter {
+  type = WalletType.RABET;
+
+  metadata: WalletMetadata = {
+    type: WalletType.RABET,
+    name: 'Rabet',
+    url: 'https://rabet.io',
+    chromeUrl: 'https://chrome.google.com/webstore/detail/rabet/aapjbdekemjjmldlfinkhcmkbcfikkde',
+    firefoxUrl: 'https://addons.mozilla.org/en-US/firefox/addon/rabet/',
+    description: 'Modern Stellar wallet with built-in swap and DeFi features',
+    isAvailable: false,
+  };
+
+  private api: RabetAPI | null = null;
+
+  constructor() {
+    this.init();
+  }
+
+  private init() {
+    if (typeof window !== 'undefined' && window.rabet) {
+      this.api = window.rabet;
+      this.metadata.isAvailable = true;
+    }
+  }
+
+  async isAvailable(): Promise<boolean> {
+    return this.metadata.isAvailable;
+  }
+
+  async connect(): Promise<string> {
+    if (!this.api) {
+      throw new WalletError(
+        'Rabet is not installed',
+        WalletErrorCode.NOT_INSTALLED,
+        WalletType.RABET
+      );
+    }
+
+    try {
+      const result = await this.api.connect();
+      if (!result.publicKey) {
+        throw new WalletError(
+          'User rejected connection request',
+          WalletErrorCode.USER_REJECTED,
+          WalletType.RABET
+        );
+      }
+      return result.publicKey;
+    } catch (error: any) {
+      if (error instanceof WalletError) throw error;
+
+      throw new WalletError(
+        `Failed to connect to Rabet: ${error.message}`,
+        WalletErrorCode.UNKNOWN_ERROR,
+        WalletType.RABET
+      );
+    }
+  }
+
+  async disconnect(): Promise<void> {
+    if (this.api) {
+      try {
+        await this.api.disconnect();
+      } catch {
+        // Ignore disconnect errors
+      }
+    }
+    this.api = null;
+  }
+
+  async getAddress(): Promise<string | null> {
+    if (!this.api) return null;
+
+    try {
+      const connected = await this.api.isConnected();
+      if (!connected) return null;
+
+      // Rabet doesn't expose getPublicKey directly
+      // Need to reconnect to get address
+      const result = await this.api.connect();
+      return result.publicKey;
+    } catch {
+      return null;
+    }
+  }
+
+  async isConnected(): Promise<boolean> {
+    if (!this.api) return false;
+
+    try {
+      return await this.api.isConnected();
+    } catch {
+      return false;
+    }
+  }
+
+  async signTransaction(
+    xdr: string,
+    options?: SignTransactionOptions
+  ): Promise<string> {
+    if (!this.api) {
+      throw new WalletError(
+        'Rabet is not connected',
+        WalletErrorCode.NOT_CONNECTED,
+        WalletType.RABET
+      );
+    }
+
+    try {
+      const result = await this.api.sign(xdr, {
+        network: options?.networkPassphrase,
+      });
+
+      return result.xdr;
+    } catch (error: any) {
+      if (error.message?.includes('User cancelled')) {
+        throw new WalletError(
+          'User rejected signature request',
+          WalletErrorCode.USER_REJECTED,
+          WalletType.RABET
+        );
+      }
+
+      throw new WalletError(
+        `Failed to sign transaction: ${error.message}`,
+        WalletErrorCode.SIGNING_FAILED,
+        WalletType.RABET
+      );
+    }
+  }
+}