@phantom/browser-sdk 0.0.10 → 0.2.0

package/dist/index.mjs

@@ -1,13 +1,772 @@
-import "./chunk-GV6AIHPN.mjs";
+// src/providers/injected/index.ts
+import { AddressType } from "@phantom/client";
+import { createPhantom, createExtensionPlugin } from "@phantom/browser-injected-sdk";
+import { createSolanaPlugin } from "@phantom/browser-injected-sdk/solana";
+import { createEthereumPlugin } from "@phantom/browser-injected-sdk/ethereum";
+var InjectedProvider = class {
+  constructor(config) {
+    this.connected = false;
+    this.addresses = [];
+    this.addressTypes = config.addressTypes || [AddressType.solana, AddressType.ethereum];
+    const plugins = [createExtensionPlugin()];
+    if (this.addressTypes.includes(AddressType.solana)) {
+      plugins.push(createSolanaPlugin());
+    }
+    if (this.addressTypes.includes(AddressType.ethereum)) {
+      plugins.push(createEthereumPlugin());
+    }
+    this.phantom = createPhantom({ plugins });
+  }
+  async connect() {
+    if (!this.phantom.extension.isInstalled()) {
+      throw new Error("Phantom wallet not found");
+    }
+    const connectedAddresses = [];
+    if (this.addressTypes.includes(AddressType.solana)) {
+      try {
+        const publicKey = await this.phantom.solana.connect();
+        if (publicKey) {
+          connectedAddresses.push({
+            addressType: AddressType.solana,
+            address: publicKey
+          });
+        }
+      } catch (err) {
+        console.error("Failed to connect Solana:", err);
+      }
+    }
+    if (this.addressTypes.includes(AddressType.ethereum)) {
+      try {
+        const accounts = await this.phantom.ethereum.connect();
+        if (accounts && accounts.length > 0) {
+          connectedAddresses.push(
+            ...accounts.map((address) => ({
+              addressType: AddressType.ethereum,
+              address
+            }))
+          );
+        }
+      } catch (err) {
+        console.error("Failed to connect Ethereum:", err);
+      }
+    }
+    if (connectedAddresses.length === 0) {
+      throw new Error("Failed to connect to any supported wallet provider");
+    }
+    this.addresses = connectedAddresses;
+    this.connected = true;
+    return {
+      addresses: this.addresses
+      // walletId is not applicable for injected providers
+    };
+  }
+  async disconnect() {
+    if (this.addressTypes.includes(AddressType.solana)) {
+      try {
+        await this.phantom.solana.disconnect();
+      } catch (err) {
+        console.error("Failed to disconnect Solana:", err);
+      }
+    }
+    if (this.addressTypes.includes(AddressType.ethereum)) {
+      try {
+        await this.phantom.ethereum.disconnect();
+      } catch (err) {
+        console.error("Failed to disconnect Ethereum:", err);
+      }
+    }
+    this.connected = false;
+    this.addresses = [];
+  }
+  async signMessage(params) {
+    if (!this.connected) {
+      throw new Error("Wallet not connected");
+    }
+    const networkPrefix = params.networkId.split(":")[0].toLowerCase();
+    if (networkPrefix === "solana") {
+      const { signature } = await this.phantom.solana.signMessage(new TextEncoder().encode(params.message));
+      return Array.from(signature).map((b) => b.toString(16).padStart(2, "0")).join("");
+    } else if (networkPrefix === "ethereum" || networkPrefix === "polygon" || networkPrefix === "eip155") {
+      const address = this.addresses.find((addr) => addr.addressType === AddressType.ethereum)?.address;
+      if (!address) {
+        throw new Error("No address available");
+      }
+      const signature = await this.phantom.ethereum.signPersonalMessage(params.message, address);
+      return signature;
+    }
+    throw new Error(`Network ${params.networkId} is not supported for injected wallets`);
+  }
+  async signAndSendTransaction(params) {
+    if (!this.connected) {
+      throw new Error("Wallet not connected");
+    }
+    const networkPrefix = params.networkId.split(":")[0].toLowerCase();
+    if (networkPrefix === "solana") {
+      const transaction = params.transaction;
+      const result = await this.phantom.solana.signAndSendTransaction(transaction);
+      return {
+        rawTransaction: result.signature
+      };
+    } else if (networkPrefix === "ethereum" || networkPrefix === "polygon" || networkPrefix === "eip155") {
+      const toHex = (value) => {
+        if (!value)
+          return void 0;
+        if (typeof value === "string" && value.startsWith("0x"))
+          return value;
+        if (typeof value === "string")
+          return value;
+        return "0x" + value.toString(16);
+      };
+      const txRequest = {
+        to: params.transaction.to,
+        value: params.transaction.value ? toHex(params.transaction.value) : "0x0",
+        gas: toHex(params.transaction.gas),
+        gasPrice: toHex(params.transaction.gasPrice),
+        maxFeePerGas: toHex(params.transaction.maxFeePerGas),
+        maxPriorityFeePerGas: toHex(params.transaction.maxPriorityFeePerGas),
+        data: params.transaction.data || "0x"
+      };
+      const txHash = await this.phantom.ethereum.sendTransaction(txRequest);
+      return {
+        rawTransaction: txHash
+      };
+    }
+    throw new Error(`Network ${params.networkId} is not supported for injected wallets`);
+  }
+  getAddresses() {
+    return this.addresses;
+  }
+  isConnected() {
+    return this.connected;
+  }
+};
 
-// src/index.ts
-function createPhantom({ plugins = [] }) {
-  const phantom = {};
-  for (const plugin of plugins) {
-    phantom[plugin.name] = plugin.create();
+// src/providers/embedded/index.ts
+import { PhantomClient, generateKeyPair } from "@phantom/client";
+import { ApiKeyStamper } from "@phantom/api-key-stamper";
+
+// src/providers/embedded/storage.ts
+var IndexedDBStorage = class {
+  constructor() {
+    this.dbName = "phantom-browser-sdk";
+    this.storeName = "sessions";
+    this.version = 1;
+  }
+  async getDB() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, this.version);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName);
+        }
+      };
+    });
   }
-  return phantom;
+  async getSession() {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([this.storeName], "readonly");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.get("currentSession");
+      request.onsuccess = () => resolve(request.result || null);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async saveSession(session) {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.put(session, "currentSession");
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async clearSession() {
+    const db = await this.getDB();
+    return new Promise((resolve, reject) => {
+      const transaction = db.transaction([this.storeName], "readwrite");
+      const store = transaction.objectStore(this.storeName);
+      const request = store.delete("currentSession");
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+};
+
+// src/providers/embedded/auth.ts
+var IframeAuth = class {
+  async authenticate(_options) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    return {
+      walletId: `wallet-${Date.now()}`
+    };
+  }
+};
+
+// src/parsers/index.ts
+import { base64urlEncode, stringToBase64url } from "@phantom/base64url";
+
+// src/polyfills.ts
+import { Buffer } from "buffer";
+import { base64url } from "jose";
+
+// src/parsers/index.ts
+function parseMessage(message) {
+  return {
+    base64url: stringToBase64url(message)
+  };
 }
+async function parseTransaction(transaction, networkId) {
+  const networkPrefix = networkId.split(":")[0].toLowerCase();
+  switch (networkPrefix) {
+    case "solana":
+      return parseSolanaTransaction(transaction);
+    case "ethereum":
+    case "polygon":
+      return parseEVMTransaction(transaction);
+    case "sui":
+      return await parseSuiTransaction(transaction);
+    case "bitcoin":
+      return parseBitcoinTransaction(transaction);
+    default:
+      throw new Error(`Unsupported network: ${networkPrefix}`);
+  }
+}
+function parseSolanaTransaction(transaction) {
+  if (transaction?.messageBytes != null) {
+    return {
+      base64url: base64urlEncode(transaction.messageBytes),
+      originalFormat: "@solana/kit"
+    };
+  }
+  if (typeof transaction?.serialize === "function") {
+    const serialized = transaction.serialize();
+    return {
+      base64url: base64urlEncode(serialized),
+      originalFormat: "@solana/web3.js"
+    };
+  }
+  if (transaction instanceof Uint8Array) {
+    return {
+      base64url: base64urlEncode(transaction),
+      originalFormat: "bytes"
+    };
+  }
+  throw new Error("Unsupported Solana transaction format");
+}
+function parseEVMTransaction(transaction) {
+  if (transaction && typeof transaction === "object" && (transaction.to || transaction.data)) {
+    const bytes = new TextEncoder().encode(
+      JSON.stringify(transaction, (_key, value) => typeof value === "bigint" ? value.toString() : value)
+    );
+    return {
+      base64url: base64urlEncode(bytes),
+      originalFormat: "viem"
+    };
+  }
+  if (transaction?.serialize && typeof transaction.serialize === "function") {
+    const serialized = transaction.serialize();
+    const bytes = new Uint8Array(Buffer.from(serialized.slice(2), "hex"));
+    return {
+      base64url: base64urlEncode(bytes),
+      originalFormat: "ethers"
+    };
+  }
+  if (transaction instanceof Uint8Array) {
+    return {
+      base64url: base64urlEncode(transaction),
+      originalFormat: "bytes"
+    };
+  }
+  if (typeof transaction === "string" && transaction.startsWith("0x")) {
+    const bytes = new Uint8Array(Buffer.from(transaction.slice(2), "hex"));
+    return {
+      base64url: base64urlEncode(bytes),
+      originalFormat: "hex"
+    };
+  }
+  throw new Error("Unsupported EVM transaction format");
+}
+async function parseSuiTransaction(transaction) {
+  if (transaction?.serialize && typeof transaction.serialize === "function") {
+    const serialized = transaction.serialize();
+    return {
+      base64url: base64urlEncode(serialized),
+      originalFormat: "sui-sdk"
+    };
+  }
+  if (transaction instanceof Uint8Array) {
+    return {
+      base64url: base64urlEncode(transaction),
+      originalFormat: "bytes"
+    };
+  }
+  if (transaction?.build && typeof transaction.build === "function") {
+    const built = await transaction.build();
+    if (built?.serialize && typeof built.serialize === "function") {
+      const serialized = built.serialize();
+      return {
+        base64url: base64urlEncode(serialized),
+        originalFormat: "transaction-block"
+      };
+    }
+  }
+  throw new Error("Unsupported Sui transaction format");
+}
+function parseBitcoinTransaction(transaction) {
+  if (transaction?.toBuffer && typeof transaction.toBuffer === "function") {
+    const buffer = transaction.toBuffer();
+    return {
+      base64url: base64urlEncode(new Uint8Array(buffer)),
+      originalFormat: "bitcoinjs-lib"
+    };
+  }
+  if (transaction instanceof Uint8Array) {
+    return {
+      base64url: base64urlEncode(transaction),
+      originalFormat: "bytes"
+    };
+  }
+  if (typeof transaction === "string") {
+    const bytes = new Uint8Array(Buffer.from(transaction, "hex"));
+    return {
+      base64url: base64urlEncode(bytes),
+      originalFormat: "hex"
+    };
+  }
+  throw new Error("Unsupported Bitcoin transaction format");
+}
+
+// src/providers/embedded/index.ts
+var EmbeddedProvider = class {
+  constructor(config) {
+    this.client = null;
+    this.walletId = null;
+    this.addresses = [];
+    this.config = config;
+    this.storage = new IndexedDBStorage();
+    config.solanaProvider;
+  }
+  async connect() {
+    let session = await this.storage.getSession();
+    if (!session) {
+      const keypair = generateKeyPair();
+      const stamper2 = new ApiKeyStamper({
+        apiSecretKey: keypair.secretKey
+      });
+      const tempClient = new PhantomClient(
+        {
+          apiBaseUrl: this.config.apiBaseUrl
+        },
+        stamper2
+      );
+      const uid = Date.now();
+      const organizationName = `${this.config.organizationId}-${uid}`;
+      const { organizationId } = await tempClient.createOrganization(organizationName, keypair);
+      let walletId;
+      if (this.config.embeddedWalletType === "user-wallet") {
+        const auth = new IframeAuth();
+        const authResult = await auth.authenticate({
+          iframeUrl: this.config.authUrl || "https://auth-flow.phantom.app",
+          organizationId,
+          parentOrganizationId: this.config.organizationId,
+          embeddedWalletType: this.config.embeddedWalletType
+        });
+        walletId = authResult.walletId;
+      } else {
+        const wallet = await tempClient.createWallet(`Wallet ${Date.now()}`);
+        walletId = wallet.walletId;
+      }
+      session = {
+        walletId,
+        organizationId: this.config.organizationId,
+        keypair
+      };
+      await this.storage.saveSession(session);
+    }
+    const stamper = new ApiKeyStamper({
+      apiSecretKey: session.keypair.secretKey
+    });
+    this.client = new PhantomClient(
+      {
+        apiBaseUrl: this.config.apiBaseUrl,
+        organizationId: session.organizationId
+      },
+      stamper
+    );
+    this.walletId = session.walletId;
+    const addresses = await this.client.getWalletAddresses(session.walletId);
+    this.addresses = addresses.filter((addr) => this.config.addressTypes.some((type) => type === addr.addressType)).map((addr) => ({
+      addressType: addr.addressType,
+      address: addr.address
+    }));
+    return {
+      walletId: this.walletId,
+      addresses: this.addresses
+    };
+  }
+  async disconnect() {
+    await this.storage.clearSession();
+    this.client = null;
+    this.walletId = null;
+    this.addresses = [];
+  }
+  async signMessage(params) {
+    if (!this.client || !this.walletId) {
+      throw new Error("Not connected");
+    }
+    const parsedMessage = parseMessage(params.message);
+    return await this.client.signMessage(this.walletId, parsedMessage.base64url, params.networkId);
+  }
+  async signAndSendTransaction(params) {
+    if (!this.client || !this.walletId) {
+      throw new Error("Not connected");
+    }
+    const parsedTransaction = await parseTransaction(params.transaction, params.networkId);
+    return await this.client.signAndSendTransaction(this.walletId, parsedTransaction.base64url, params.networkId);
+  }
+  getAddresses() {
+    return this.addresses;
+  }
+  isConnected() {
+    return this.client !== null && this.walletId !== null;
+  }
+};
+
+// src/ProviderManager.ts
+var ProviderManager = class {
+  constructor(config) {
+    this.providers = /* @__PURE__ */ new Map();
+    this.currentProvider = null;
+    this.currentProviderKey = null;
+    this.walletId = null;
+    this.config = config;
+    this.setDefaultProvider();
+  }
+  /**
+   * Switch to a different provider type
+   */
+  switchProvider(type, options) {
+    if (options?.embeddedWalletType && !["app-wallet", "user-wallet"].includes(options.embeddedWalletType)) {
+      throw new Error(
+        `Invalid embeddedWalletType: ${options.embeddedWalletType}. Must be "app-wallet" or "user-wallet".`
+      );
+    }
+    const key = this.getProviderKey(type, options?.embeddedWalletType);
+    if (!this.providers.has(key)) {
+      this.createProvider(type, options?.embeddedWalletType);
+    }
+    this.currentProvider = this.providers.get(key);
+    this.currentProviderKey = key;
+    this.walletId = null;
+    return this.currentProvider;
+  }
+  /**
+   * Get the current active provider
+   */
+  getCurrentProvider() {
+    return this.currentProvider;
+  }
+  /**
+   * Get current provider type and options
+   */
+  getCurrentProviderInfo() {
+    if (!this.currentProviderKey)
+      return null;
+    const [type, embeddedWalletType] = this.currentProviderKey.split("-");
+    return {
+      type,
+      embeddedWalletType
+    };
+  }
+  /**
+   * Connect using the current provider
+   */
+  async connect() {
+    if (!this.currentProvider) {
+      throw new Error("No provider selected");
+    }
+    const result = await this.currentProvider.connect();
+    this.walletId = result.walletId || null;
+    this.saveProviderPreference();
+    return result;
+  }
+  /**
+   * Disconnect from current provider
+   */
+  async disconnect() {
+    if (!this.currentProvider)
+      return;
+    await this.currentProvider.disconnect();
+    this.walletId = null;
+  }
+  /**
+   * Sign a message using current provider
+   */
+  async signMessage(params) {
+    if (!this.currentProvider) {
+      throw new Error("No provider connected");
+    }
+    return this.currentProvider.signMessage(params);
+  }
+  /**
+   * Sign and send transaction using current provider
+   */
+  async signAndSendTransaction(params) {
+    if (!this.currentProvider) {
+      throw new Error("No provider connected");
+    }
+    return this.currentProvider.signAndSendTransaction(params);
+  }
+  /**
+   * Get addresses from current provider
+   */
+  getAddresses() {
+    if (!this.currentProvider) {
+      return [];
+    }
+    return this.currentProvider.getAddresses();
+  }
+  /**
+   * Check if current provider is connected
+   */
+  isConnected() {
+    return this.currentProvider?.isConnected() ?? false;
+  }
+  /**
+   * Get current wallet ID
+   */
+  getWalletId() {
+    return this.walletId;
+  }
+  /**
+   * Set default provider based on initial config
+   */
+  setDefaultProvider() {
+    const defaultType = this.config.providerType || "embedded";
+    const defaultEmbeddedType = this.config.embeddedWalletType || "app-wallet";
+    this.createProvider(defaultType, defaultEmbeddedType);
+    this.switchProvider(defaultType, { embeddedWalletType: defaultEmbeddedType });
+  }
+  /**
+   * Create a provider instance
+   */
+  createProvider(type, embeddedWalletType) {
+    const key = this.getProviderKey(type, embeddedWalletType);
+    if (this.providers.has(key))
+      return;
+    let provider;
+    if (type === "injected") {
+      provider = new InjectedProvider({
+        solanaProvider: this.config.solanaProvider || "web3js",
+        addressTypes: this.config.addressTypes || []
+      });
+    } else {
+      if (!this.config.apiBaseUrl || !this.config.organizationId) {
+        throw new Error("apiBaseUrl and organizationId are required for embedded provider");
+      }
+      provider = new EmbeddedProvider({
+        apiBaseUrl: this.config.apiBaseUrl,
+        organizationId: this.config.organizationId,
+        authUrl: this.config.authUrl,
+        embeddedWalletType: embeddedWalletType || "app-wallet",
+        addressTypes: this.config.addressTypes || [],
+        solanaProvider: this.config.solanaProvider || "web3js"
+      });
+    }
+    this.providers.set(key, provider);
+  }
+  /**
+   * Generate a unique key for provider instances
+   */
+  getProviderKey(type, embeddedWalletType) {
+    if (type === "injected") {
+      return "injected";
+    }
+    return `embedded-${embeddedWalletType || "app-wallet"}`;
+  }
+  /**
+   * Save provider preference to localStorage
+   */
+  saveProviderPreference() {
+    try {
+      const preference = this.getCurrentProviderInfo();
+      if (preference) {
+        localStorage.setItem("phantom-provider-preference", JSON.stringify(preference));
+      }
+    } catch (error) {
+      console.error("Failed to save provider preference:", error);
+    }
+  }
+  /**
+   * Restore provider preference from localStorage
+   */
+  /*
+  private restoreProviderPreference(): void {
+    try {
+      const saved = localStorage.getItem("phantom-provider-preference");
+      if (saved) {
+        const preference: ProviderPreference = JSON.parse(saved);
+        this.switchProvider(preference.type, {
+          embeddedWalletType: preference.embeddedWalletType,
+        });
+      }
+    } catch (error) {
+      // Ignore localStorage errors - just use default provider
+      console.error("Failed to restore provider preference:", error);
+    }
+  }*/
+};
+
+// src/BrowserSDK.ts
+import { isPhantomExtensionInstalled } from "@phantom/browser-injected-sdk";
+var BrowserSDK = class {
+  constructor(config) {
+    if (!["injected", "embedded"].includes(config.providerType)) {
+      throw new Error(`Invalid providerType: ${config.providerType}. Must be "injected" or "embedded".`);
+    }
+    const embeddedWalletType = config.embeddedWalletType || "app-wallet";
+    if (config.providerType === "embedded" && !["app-wallet", "user-wallet"].includes(embeddedWalletType)) {
+      throw new Error(
+        `Invalid embeddedWalletType: ${config.embeddedWalletType}. Must be "app-wallet" or "user-wallet".`
+      );
+    }
+    config.embeddedWalletType = embeddedWalletType;
+    this.config = config;
+    this.providerManager = new ProviderManager(config);
+  }
+  /**
+   * Connect to the wallet with optional provider switching
+   */
+  async connect(options) {
+    if (options?.providerType) {
+      if (!["injected", "embedded"].includes(options.providerType)) {
+        throw new Error(`Invalid providerType: ${options.providerType}. Must be "injected" or "embedded".`);
+      }
+      if (options.embeddedWalletType && !["app-wallet", "user-wallet"].includes(options.embeddedWalletType)) {
+        throw new Error(
+          `Invalid embeddedWalletType: ${options.embeddedWalletType}. Must be "app-wallet" or "user-wallet".`
+        );
+      }
+      await this.providerManager.switchProvider(options.providerType, {
+        embeddedWalletType: options.embeddedWalletType
+      });
+    }
+    return this.providerManager.connect();
+  }
+  /**
+   * Switch to a different provider type
+   */
+  async switchProvider(type, options) {
+    if (!["injected", "embedded"].includes(type)) {
+      throw new Error(`Invalid providerType: ${type}. Must be "injected" or "embedded".`);
+    }
+    await this.providerManager.switchProvider(type, options);
+  }
+  /**
+   * Get current provider information
+   */
+  getCurrentProviderInfo() {
+    return this.providerManager.getCurrentProviderInfo();
+  }
+  /**
+   * Wait for Phantom extension to become available
+   */
+  async waitForPhantomExtension(timeoutMs) {
+    const isInstalled = async (retries = 3, timeAccumulated = 0) => {
+      const installed = isPhantomExtensionInstalled();
+      if (installed)
+        return true;
+      if (retries <= 0)
+        return false;
+      if (timeAccumulated >= (timeoutMs || 3e3))
+        return false;
+      return new Promise((resolve) => {
+        setTimeout(async () => {
+          const result = await isInstalled(retries - 1, timeAccumulated + 100);
+          resolve(result);
+        }, 100);
+      });
+    };
+    return isInstalled();
+  }
+  /**
+   * Disconnect from the wallet
+   */
+  async disconnect() {
+    return this.providerManager.disconnect();
+  }
+  /**
+   * Sign a message
+   * @param message - Message string to sign
+   * @param networkId - Network identifier
+   * @returns Signature string
+   */
+  async signMessage(params) {
+    return this.providerManager.signMessage(params);
+  }
+  /**
+   * Sign and send a transaction
+   * @param params - Transaction parameters with native transaction object
+   * @returns Transaction result
+   */
+  async signAndSendTransaction(params) {
+    return this.providerManager.signAndSendTransaction(params);
+  }
+  /**
+   * Get wallet addresses
+   */
+  getAddresses() {
+    return this.providerManager.getAddresses();
+  }
+  /**
+   * Check if wallet is connected
+   */
+  isConnected() {
+    return this.providerManager.isConnected();
+  }
+  /**
+   * Get the current wallet ID (for embedded wallets)
+   */
+  getWalletId() {
+    return this.providerManager.getWalletId();
+  }
+  /**
+   * Create a user organization via your backend API
+   * @param params - Parameters including userId and any additional options
+   * @returns Organization creation result with organizationId
+   */
+  async createUserOrganization(params) {
+    if (!this.config.serverUrl) {
+      throw new Error("serverUrl is required in config to create user organizations");
+    }
+    try {
+      const response = await fetch(`${this.config.serverUrl}/organizations`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(params)
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to create organization: ${response.status} ${response.statusText}`);
+      }
+      const result = await response.json();
+      return result;
+    } catch (error) {
+      throw new Error(`Error creating user organization: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+};
+
+// src/index.ts
+import { NetworkId, AddressType as AddressType2 } from "@phantom/client";
 export {
-  createPhantom
+  AddressType2 as AddressType,
+  BrowserSDK,
+  NetworkId
 };