@phantom/embedded-provider-core 0.1.10 → 1.0.0-beta.1

package/dist/index.js

@@ -32,7 +32,9 @@ var src_exports = {};
 __export(src_exports, {
   AUTHENTICATOR_EXPIRATION_TIME_MS: () => AUTHENTICATOR_EXPIRATION_TIME_MS,
   AUTHENTICATOR_RENEWAL_WINDOW_MS: () => AUTHENTICATOR_RENEWAL_WINDOW_MS,
+  EmbeddedEthereumChain: () => EmbeddedEthereumChain,
   EmbeddedProvider: () => EmbeddedProvider,
+  EmbeddedSolanaChain: () => EmbeddedSolanaChain,
   JWTAuth: () => JWTAuth,
   generateSessionId: () => generateSessionId,
   retryWithBackoff: () => retryWithBackoff
@@ -64,7 +66,8 @@ var JWTAuth = class {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${options.jwtToken}`
+          Authorization: `Bearer ${options.jwtToken}`,
+          "X-PHANTOM-APPID": options.appId
         },
         body: JSON.stringify({
           organizationId: options.organizationId,
@@ -165,6 +168,302 @@ async function retryWithBackoff(operation, operationName, logger, maxRetries = 3
   throw lastError;
 }
 
+// src/chains/SolanaChain.ts
+var import_eventemitter3 = require("eventemitter3");
+var import_constants = require("@phantom/constants");
+var import_buffer = require("buffer");
+var EmbeddedSolanaChain = class {
+  constructor(provider) {
+    this.provider = provider;
+    this.currentNetworkId = import_constants.NetworkId.SOLANA_MAINNET;
+    this._connected = false;
+    this._publicKey = null;
+    this.eventEmitter = new import_eventemitter3.EventEmitter();
+    this.setupEventListeners();
+    this.syncInitialState();
+  }
+  // Wallet adapter compliant properties
+  get connected() {
+    return this._connected;
+  }
+  get publicKey() {
+    return this._publicKey;
+  }
+  ensureConnected() {
+    if (!this.provider.isConnected()) {
+      throw new Error("Solana chain not available. Ensure SDK is connected.");
+    }
+  }
+  // Standard wallet adapter methods
+  async signMessage(message) {
+    this.ensureConnected();
+    const messageStr = typeof message === "string" ? message : new TextDecoder().decode(message);
+    const result = await this.provider.signMessage({
+      message: messageStr,
+      networkId: this.currentNetworkId
+    });
+    const signature = typeof result.signature === "string" ? new Uint8Array(import_buffer.Buffer.from(result.signature, "base64")) : result.signature;
+    return {
+      signature,
+      publicKey: this._publicKey || ""
+    };
+  }
+  signTransaction(_transaction) {
+    this.ensureConnected();
+    throw new Error("signTransaction not yet implemented for embedded provider");
+  }
+  async signAndSendTransaction(transaction) {
+    this.ensureConnected();
+    const result = await this.provider.signAndSendTransaction({
+      transaction,
+      networkId: this.currentNetworkId
+    });
+    if (!result.hash) {
+      throw new Error("Transaction not submitted");
+    }
+    return { signature: result.hash };
+  }
+  async signAllTransactions(transactions) {
+    const results = await Promise.all(transactions.map((tx) => this.signTransaction(tx)));
+    return results;
+  }
+  connect(_options) {
+    if (!this.provider.isConnected()) {
+      throw new Error("Provider not connected. Call provider connect first.");
+    }
+    const addresses = this.provider.getAddresses();
+    const solanaAddr = addresses.find((a) => a.addressType === "Solana");
+    if (!solanaAddr)
+      throw new Error("No Solana address found");
+    this.updateConnectionState(true, solanaAddr.address);
+    return Promise.resolve({ publicKey: solanaAddr.address });
+  }
+  async disconnect() {
+    return this.provider.disconnect();
+  }
+  switchNetwork(network) {
+    this.currentNetworkId = network === "mainnet" ? import_constants.NetworkId.SOLANA_MAINNET : import_constants.NetworkId.SOLANA_DEVNET;
+    return Promise.resolve();
+  }
+  getPublicKey() {
+    if (!this.provider.isConnected())
+      return Promise.resolve(null);
+    const addresses = this.provider.getAddresses();
+    const solanaAddr = addresses.find((a) => a.addressType === "Solana");
+    return Promise.resolve(solanaAddr?.address || null);
+  }
+  isConnected() {
+    return this._connected && this.provider.isConnected();
+  }
+  setupEventListeners() {
+    this.provider.on("connect", (data) => {
+      const solanaAddress = data.addresses?.find((addr) => addr.addressType === "Solana");
+      if (solanaAddress) {
+        this.updateConnectionState(true, solanaAddress.address);
+        this.eventEmitter.emit("connect", solanaAddress.address);
+      }
+    });
+    this.provider.on("disconnect", () => {
+      this.updateConnectionState(false, null);
+      this.eventEmitter.emit("disconnect");
+    });
+  }
+  syncInitialState() {
+    if (this.provider.isConnected()) {
+      const addresses = this.provider.getAddresses();
+      const solanaAddress = addresses.find((a) => a.addressType === "Solana");
+      if (solanaAddress) {
+        this.updateConnectionState(true, solanaAddress.address);
+      }
+    }
+  }
+  updateConnectionState(connected, publicKey) {
+    this._connected = connected;
+    this._publicKey = publicKey;
+  }
+  // Event methods for interface compliance
+  on(event, listener) {
+    this.eventEmitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.eventEmitter.off(event, listener);
+  }
+};
+
+// src/chains/EthereumChain.ts
+var import_eventemitter32 = require("eventemitter3");
+var import_constants2 = require("@phantom/constants");
+var EmbeddedEthereumChain = class {
+  constructor(provider) {
+    this.provider = provider;
+    this.currentNetworkId = import_constants2.NetworkId.ETHEREUM_MAINNET;
+    this._connected = false;
+    this._accounts = [];
+    this.eventEmitter = new import_eventemitter32.EventEmitter();
+    this.setupEventListeners();
+    this.syncInitialState();
+  }
+  // EIP-1193 compliant properties
+  get connected() {
+    return this._connected;
+  }
+  get chainId() {
+    const chainId = (0, import_constants2.networkIdToChainId)(this.currentNetworkId) || 1;
+    return `0x${chainId.toString(16)}`;
+  }
+  get accounts() {
+    return this._accounts;
+  }
+  ensureConnected() {
+    if (!this.provider.isConnected()) {
+      throw new Error("Ethereum chain not available. Ensure SDK is connected.");
+    }
+  }
+  async request(args) {
+    this.ensureConnected();
+    return this.handleEmbeddedRequest(args);
+  }
+  // Connection methods
+  connect() {
+    if (!this.provider.isConnected()) {
+      throw new Error("Provider not connected. Call provider connect first.");
+    }
+    const addresses = this.provider.getAddresses();
+    const ethAddresses = addresses.filter((a) => a.addressType === "Ethereum").map((a) => a.address);
+    this.updateConnectionState(true, ethAddresses);
+    return Promise.resolve(ethAddresses);
+  }
+  async disconnect() {
+    await this.provider.disconnect();
+  }
+  // Standard compliant methods (return raw values)
+  async signPersonalMessage(message, address) {
+    return await this.request({
+      method: "personal_sign",
+      params: [message, address]
+    });
+  }
+  async signTypedData(typedData, address) {
+    return await this.request({
+      method: "eth_signTypedData_v4",
+      params: [address, JSON.stringify(typedData)]
+    });
+  }
+  async sendTransaction(transaction) {
+    const result = await this.provider.signAndSendTransaction({
+      transaction,
+      networkId: this.currentNetworkId
+    });
+    if (!result.hash) {
+      throw new Error("Transaction not submitted");
+    }
+    return result.hash;
+  }
+  switchChain(chainId) {
+    const networkId = (0, import_constants2.chainIdToNetworkId)(chainId);
+    if (!networkId) {
+      throw new Error(`Unsupported chainId: ${chainId}`);
+    }
+    this.currentNetworkId = networkId;
+    this.eventEmitter.emit("chainChanged", `0x${chainId.toString(16)}`);
+    return Promise.resolve();
+  }
+  getChainId() {
+    const chainId = (0, import_constants2.networkIdToChainId)(this.currentNetworkId);
+    return Promise.resolve(chainId || 1);
+  }
+  async getAccounts() {
+    return this.request({ method: "eth_accounts" });
+  }
+  isConnected() {
+    return this._connected && this.provider.isConnected();
+  }
+  setupEventListeners() {
+    this.provider.on("connect", (data) => {
+      const ethAddresses = data.addresses?.filter((addr) => addr.addressType === "Ethereum")?.map((addr) => addr.address) || [];
+      if (ethAddresses.length > 0) {
+        this.updateConnectionState(true, ethAddresses);
+        this.eventEmitter.emit("connect", { chainId: this.chainId });
+        this.eventEmitter.emit("accountsChanged", ethAddresses);
+      }
+    });
+    this.provider.on("disconnect", () => {
+      this.updateConnectionState(false, []);
+      this.eventEmitter.emit("disconnect", { code: 4900, message: "Provider disconnected" });
+      this.eventEmitter.emit("accountsChanged", []);
+    });
+  }
+  syncInitialState() {
+    if (this.provider.isConnected()) {
+      const addresses = this.provider.getAddresses();
+      const ethAddresses = addresses.filter((a) => a.addressType === "Ethereum").map((a) => a.address);
+      if (ethAddresses.length > 0) {
+        this.updateConnectionState(true, ethAddresses);
+      }
+    }
+  }
+  updateConnectionState(connected, accounts) {
+    this._connected = connected;
+    this._accounts = accounts;
+  }
+  async handleEmbeddedRequest(args) {
+    switch (args.method) {
+      case "personal_sign": {
+        const [message, _address] = args.params;
+        const result = await this.provider.signMessage({
+          message,
+          networkId: this.currentNetworkId
+        });
+        return result.signature;
+      }
+      case "eth_signTypedData_v4": {
+        const [_typedDataAddress, typedDataStr] = args.params;
+        const _typedData = JSON.parse(typedDataStr);
+        const typedDataResult = await this.provider.signMessage({
+          message: typedDataStr,
+          // Pass the stringified typed data as message
+          networkId: this.currentNetworkId
+        });
+        return typedDataResult.signature;
+      }
+      case "eth_sendTransaction": {
+        const [transaction] = args.params;
+        const networkIdFromTx = transaction.chainId ? (0, import_constants2.chainIdToNetworkId)(
+          typeof transaction.chainId === "number" ? transaction.chainId : parseInt(transaction.chainId, 16)
+        ) : null;
+        const sendResult = await this.provider.signAndSendTransaction({
+          transaction,
+          networkId: networkIdFromTx || this.currentNetworkId
+        });
+        return sendResult.hash;
+      }
+      case "eth_accounts": {
+        const addresses = this.provider.getAddresses();
+        const ethAddr = addresses.find((a) => a.addressType === "Ethereum");
+        return ethAddr ? [ethAddr.address] : [];
+      }
+      case "eth_chainId": {
+        return `0x${((0, import_constants2.networkIdToChainId)(this.currentNetworkId) || 1).toString(16)}`;
+      }
+      case "wallet_switchEthereumChain": {
+        const [{ chainId }] = args.params;
+        const numericChainId = parseInt(chainId, 16);
+        await this.switchChain(numericChainId);
+        return void 0;
+      }
+      default:
+        throw new Error(`Embedded provider doesn't support method: ${args.method}`);
+    }
+  }
+  // Event methods for interface compliance
+  on(event, listener) {
+    this.eventEmitter.on(event, listener);
+  }
+  off(event, listener) {
+    this.eventEmitter.off(event, listener);
+  }
+};
+
 // src/embedded-provider.ts
 var EmbeddedProvider = class {
   constructor(config, platform, logger) {
@@ -182,6 +481,8 @@ var EmbeddedProvider = class {
     this.stamper = platform.stamper;
     this.jwtAuth = new JWTAuth();
     config.solanaProvider;
+    this.solana = new EmbeddedSolanaChain(this);
+    this.ethereum = new EmbeddedEthereumChain(this);
     this.logger.info("EMBEDDED_PROVIDER", "EmbeddedProvider initialized");
   }
   /*
@@ -278,24 +579,13 @@ var EmbeddedProvider = class {
   }
   /*
    * Shared connection logic for both connect() and autoConnect().
-   * Handles redirect resume, existing session validation, and session initialization.
+   * Handles existing session validation, redirect resume, and session initialization.
    * Returns ConnectResult if connection succeeds, null if should continue with new auth flow.
    */
-  async tryExistingConnection() {
+  async tryExistingConnection(isAutoConnect) {
     this.logger.log("EMBEDDED_PROVIDER", "Getting existing session");
     let session = await this.storage.getSession();
     session = await this.validateAndCleanSession(session);
-    this.logger.log("EMBEDDED_PROVIDER", "Checking for redirect resume");
-    if (this.authProvider.resumeAuthFromRedirect) {
-      const authResult = this.authProvider.resumeAuthFromRedirect();
-      if (authResult) {
-        this.logger.info("EMBEDDED_PROVIDER", "Resuming from redirect", {
-          walletId: authResult.walletId,
-          provider: authResult.provider
-        });
-        return this.completeAuthConnection(authResult);
-      }
-    }
     if (session && session.status === "completed") {
       this.logger.info("EMBEDDED_PROVIDER", "Using existing completed session", {
         sessionId: session.sessionId,
@@ -321,6 +611,33 @@ var EmbeddedProvider = class {
       });
       return result;
     }
+    this.logger.log("EMBEDDED_PROVIDER", "No completed session found, checking for redirect resume");
+    if (this.authProvider.resumeAuthFromRedirect) {
+      const authResult = this.authProvider.resumeAuthFromRedirect();
+      if (authResult) {
+        this.logger.info("EMBEDDED_PROVIDER", "Resuming from redirect", {
+          walletId: authResult.walletId,
+          provider: authResult.provider
+        });
+        try {
+          return await this.completeAuthConnection(authResult);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("No session found after redirect") && !isAutoConnect) {
+            this.logger.warn(
+              "EMBEDDED_PROVIDER",
+              "Session missing during redirect resume - will start fresh auth flow",
+              {
+                error: error.message,
+                walletId: authResult.walletId
+              }
+            );
+            await this.storage.clearSession();
+            return null;
+          }
+          throw error;
+        }
+      }
+    }
     return null;
   }
   /*
@@ -387,7 +704,7 @@ var EmbeddedProvider = class {
     try {
       this.logger.log("EMBEDDED_PROVIDER", "Starting auto-connect attempt");
       this.emit("connect_start", { source: "auto-connect" });
-      const result = await this.tryExistingConnection();
+      const result = await this.tryExistingConnection(true);
       if (result) {
         this.logger.info("EMBEDDED_PROVIDER", "Auto-connect successful", {
           walletId: result.walletId,
@@ -476,7 +793,7 @@ var EmbeddedProvider = class {
         source: "manual-connect",
         authOptions: authOptions ? { provider: authOptions.provider } : void 0
       });
-      const existingResult = await this.tryExistingConnection();
+      const existingResult = await this.tryExistingConnection(false);
       if (existingResult) {
         this.logger.info("EMBEDDED_PROVIDER", "Manual connect using existing connection", {
           walletId: existingResult.walletId,
@@ -599,7 +916,7 @@ var EmbeddedProvider = class {
       walletId: this.walletId,
       networkId: params.networkId
     });
-    const parsedTransaction = await (0, import_parsers.parseTransaction)(params.transaction, params.networkId);
+    const parsedTransaction = await (0, import_parsers.parseTransactionToBase64Url)(params.transaction, params.networkId);
     const session = await this.storage.getSession();
     const derivationIndex = session?.accountDerivationIndex ?? 0;
     this.logger.log("EMBEDDED_PROVIDER", "Parsed transaction for signing", {
@@ -665,6 +982,7 @@ var EmbeddedProvider = class {
         sessionId: generateSessionId(),
         walletId,
         organizationId,
+        appId: this.config.appId,
         stamperInfo,
         authProvider: "app-wallet",
         userInfo: { embeddedWalletType: this.config.embeddedWalletType },
@@ -696,6 +1014,7 @@ var EmbeddedProvider = class {
     this.logger.log("EMBEDDED_PROVIDER", "Starting JWT authentication");
     const authResult = await this.jwtAuth.authenticate({
       organizationId,
+      appId: this.config.appId,
       parentOrganizationId: this.config.organizationId,
       jwtToken: authOptions.jwtToken,
       customAuthData: authOptions.customAuthData
@@ -707,6 +1026,7 @@ var EmbeddedProvider = class {
       sessionId: generateSessionId(),
       walletId,
       organizationId,
+      appId: this.config.appId,
       stamperInfo,
       authProvider: authResult.provider,
       userInfo: authResult.userInfo,
@@ -741,6 +1061,7 @@ var EmbeddedProvider = class {
       walletId: `temp-${now}`,
       // Temporary ID, will be updated after redirect
       organizationId,
+      appId: this.config.appId,
       stamperInfo,
       authProvider: "phantom-connect",
       userInfo: { provider: authOptions?.provider },
@@ -763,19 +1084,19 @@ var EmbeddedProvider = class {
     this.logger.info("EMBEDDED_PROVIDER", "Starting Phantom Connect redirect", {
       organizationId,
       parentOrganizationId: this.config.organizationId,
+      appId: this.config.appId,
       provider: authOptions?.provider,
       authUrl: this.config.authOptions?.authUrl
     });
     const authResult = await this.authProvider.authenticate({
       organizationId,
+      appId: this.config.appId,
       parentOrganizationId: this.config.organizationId,
       provider: authOptions?.provider,
       redirectUrl: this.config.authOptions?.redirectUrl,
       customAuthData: authOptions?.customAuthData,
       authUrl: this.config.authOptions?.authUrl,
-      sessionId,
-      appName: this.config.appName,
-      appLogo: this.config.appLogo
+      sessionId
     });
     if (authResult && "walletId" in authResult) {
       this.logger.info("EMBEDDED_PROVIDER", "Authentication completed after redirect", {
@@ -814,7 +1135,7 @@ var EmbeddedProvider = class {
   }
   /*
    * Ensures the authenticator is valid and performs renewal if needed.
-   * The renewal of the authenticator can only happen meanwhile the previous authenticator is still valid. 
+   * The renewal of the authenticator can only happen meanwhile the previous authenticator is still valid.
    */
   async ensureValidAuthenticator() {
     const session = await this.storage.getSession();
@@ -892,7 +1213,9 @@ var EmbeddedProvider = class {
           error: error instanceof Error ? error.message : String(error)
         });
         await this.stamper.rollbackRotation();
-        throw new Error(`Failed to create new authenticator: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(
+          `Failed to create new authenticator: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
       this.logger.info("EMBEDDED_PROVIDER", "Created new authenticator", {
         authenticatorId: authenticatorResult.id
@@ -920,7 +1243,8 @@ var EmbeddedProvider = class {
   async initializeClientFromSession(session) {
     this.logger.log("EMBEDDED_PROVIDER", "Initializing PhantomClient from session", {
       organizationId: session.organizationId,
-      walletId: session.walletId
+      walletId: session.walletId,
+      appId: session.appId
     });
     if (!this.stamper.getKeyInfo()) {
       await this.stamper.init();
@@ -940,7 +1264,9 @@ var EmbeddedProvider = class {
 0 && (module.exports = {
   AUTHENTICATOR_EXPIRATION_TIME_MS,
   AUTHENTICATOR_RENEWAL_WINDOW_MS,
+  EmbeddedEthereumChain,
   EmbeddedProvider,
+  EmbeddedSolanaChain,
   JWTAuth,
   generateSessionId,
   retryWithBackoff