@openfort/react 0.3.2 → 1.0.0

package/build/solana/operations.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Solana Wallet Operations
+ *
+ * Pure functions for signing operations.
+ * Extracted from hooks for testability and reusability.
+ *
+ * CRITICAL: Solana uses Ed25519, NOT keccak256.
+ * Always set hashMessage: false when signing.
+ */
+import type { SolanaTransaction } from './types';
+/**
+ * Extract message bytes from various Solana transaction formats
+ *
+ * Supports:
+ * - Raw Uint8Array
+ * - Object with messageBytes property
+ * - Object with serializeMessage() method (legacy Transaction)
+ *
+ * @param transaction - Transaction in various formats
+ * @returns Transaction bytes as Uint8Array
+ */
+export declare function getTransactionBytes(transaction: SolanaTransaction): Uint8Array;

package/build/solana/operations.js

@@ -0,0 +1,40 @@
+import { OpenfortError, OpenfortReactErrorType } from '../types.js';
+
+/**
+ * Solana Wallet Operations
+ *
+ * Pure functions for signing operations.
+ * Extracted from hooks for testability and reusability.
+ *
+ * CRITICAL: Solana uses Ed25519, NOT keccak256.
+ * Always set hashMessage: false when signing.
+ */
+/**
+ * Extract message bytes from various Solana transaction formats
+ *
+ * Supports:
+ * - Raw Uint8Array
+ * - Object with messageBytes property
+ * - Object with serializeMessage() method (legacy Transaction)
+ *
+ * @param transaction - Transaction in various formats
+ * @returns Transaction bytes as Uint8Array
+ */
+function getTransactionBytes(transaction) {
+    // Raw bytes
+    if (transaction instanceof Uint8Array) {
+        return transaction;
+    }
+    // Object with messageBytes (VersionedTransaction style)
+    if ('messageBytes' in transaction) {
+        return transaction.messageBytes;
+    }
+    // Object with serializeMessage (legacy Transaction style)
+    if ('serializeMessage' in transaction && typeof transaction.serializeMessage === 'function') {
+        return transaction.serializeMessage();
+    }
+    throw new OpenfortError('Unsupported Solana transaction format', OpenfortReactErrorType.CONFIGURATION_ERROR);
+}
+
+export { getTransactionBytes };
+//# sourceMappingURL=operations.js.map

package/build/solana/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/solana/provider.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Solana Wallet Provider Implementation
+ *
+ * Provides signing capabilities for Solana transactions and messages.
+ * This provider implements a request-based API pattern similar to EIP-1193
+ * but adapted for Solana operations.
+ *
+ * CRITICAL: Ed25519 signing is used for Solana (no keccak256 hashing).
+ * When calling the Openfort SDK, always use hashMessage: false.
+ */
+import type { EmbeddedAccount } from '@openfort/openfort-js';
+import type { OpenfortEmbeddedSolanaWalletProvider, SignedSolanaTransaction, SolanaSignAllTransactionsRequest, SolanaSignMessageRequest, SolanaSignTransactionRequest, SolanaTransaction } from './types';
+/**
+ * Configuration for creating an OpenfortSolanaProvider
+ */
+interface OpenfortSolanaProviderConfig {
+    /** The embedded account to use for this provider */
+    account: EmbeddedAccount;
+    /**
+     * Function to sign a single transaction.
+     * Should use hashMessage: false for Ed25519 signing.
+     */
+    signTransaction: (transaction: SolanaTransaction) => Promise<SignedSolanaTransaction>;
+    /**
+     * Function to sign multiple transactions.
+     * Should use hashMessage: false for Ed25519 signing.
+     */
+    signAllTransactions: (transactions: SolanaTransaction[]) => Promise<SignedSolanaTransaction[]>;
+    /**
+     * Function to sign a message.
+     * CRITICAL: Must use hashMessage: false for Ed25519 (no keccak256).
+     */
+    signMessage: (message: string) => Promise<string>;
+}
+/**
+ * Embedded Solana wallet provider implementation for Openfort.
+ *
+ * This provider can be used directly for signing operations or wrapped
+ * with Kit signers for use with @solana/kit.
+ *
+ * @example Direct usage
+ * ```ts
+ * const signature = await provider.signMessage('Hello Solana!');
+ * const signed = await provider.signTransaction(transaction);
+ * ```
+ *
+ * @example Request-based API
+ * ```ts
+ * const { signature } = await provider.request({
+ *   method: 'signMessage',
+ *   params: { message: 'Hello Solana!' }
+ * });
+ * ```
+ */
+declare class OpenfortSolanaProvider implements OpenfortEmbeddedSolanaWalletProvider {
+    private readonly _account;
+    private readonly _signTransaction;
+    private readonly _signAllTransactions;
+    private readonly _signMessage;
+    /**
+     * Creates a new OpenfortSolanaProvider instance
+     *
+     * @param config - Provider configuration including account and signing functions
+     */
+    constructor(config: OpenfortSolanaProviderConfig);
+    /**
+     * The public key of the wallet (Solana address in Base58 format)
+     */
+    get publicKey(): string;
+    /**
+     * Sign a message
+     *
+     * @param message - Message to sign (UTF-8 string)
+     * @returns Base58 encoded signature
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Sign a single transaction
+     *
+     * @param transaction - Transaction to sign (various formats supported)
+     * @returns Signed transaction with signature and public key
+     */
+    signTransaction(transaction: SolanaTransaction): Promise<SignedSolanaTransaction>;
+    /**
+     * Sign multiple transactions atomically
+     *
+     * @param transactions - Array of transactions to sign
+     * @returns Array of signed transactions in the same order
+     */
+    signAllTransactions(transactions: SolanaTransaction[]): Promise<SignedSolanaTransaction[]>;
+    /**
+     * Request-based API for wallet operations
+     *
+     * Provides a unified interface similar to EIP-1193 but for Solana operations.
+     */
+    request(args: SolanaSignMessageRequest): Promise<{
+        signature: string;
+    }>;
+    request(args: SolanaSignTransactionRequest): Promise<{
+        signedTransaction: SignedSolanaTransaction;
+    }>;
+    request(args: SolanaSignAllTransactionsRequest): Promise<{
+        signedTransactions: SignedSolanaTransaction[];
+    }>;
+    /**
+     * Pretty log output for when an instance of this class is console.log'd
+     */
+    toJSON(): string;
+    /**
+     * String representation
+     */
+    toString(): string;
+}
+/**
+ * Creates a new OpenfortSolanaProvider instance
+ *
+ * @param config - Provider configuration
+ * @returns A new OpenfortSolanaProvider instance
+ *
+ * @example
+ * ```ts
+ * const provider = createSolanaProvider({
+ *   account: embeddedAccount,
+ *   signTransaction: async (tx) => { ... },
+ *   signAllTransactions: async (txs) => { ... },
+ *   signMessage: async (msg) => { ... },
+ * });
+ * ```
+ */
+export declare function createSolanaProvider(config: OpenfortSolanaProviderConfig): OpenfortSolanaProvider;
+export {};

package/build/solana/provider.js

@@ -0,0 +1,126 @@
+/**
+ * Solana Wallet Provider Implementation
+ *
+ * Provides signing capabilities for Solana transactions and messages.
+ * This provider implements a request-based API pattern similar to EIP-1193
+ * but adapted for Solana operations.
+ *
+ * CRITICAL: Ed25519 signing is used for Solana (no keccak256 hashing).
+ * When calling the Openfort SDK, always use hashMessage: false.
+ */
+/**
+ * Embedded Solana wallet provider implementation for Openfort.
+ *
+ * This provider can be used directly for signing operations or wrapped
+ * with Kit signers for use with @solana/kit.
+ *
+ * @example Direct usage
+ * ```ts
+ * const signature = await provider.signMessage('Hello Solana!');
+ * const signed = await provider.signTransaction(transaction);
+ * ```
+ *
+ * @example Request-based API
+ * ```ts
+ * const { signature } = await provider.request({
+ *   method: 'signMessage',
+ *   params: { message: 'Hello Solana!' }
+ * });
+ * ```
+ */
+class OpenfortSolanaProvider {
+    /**
+     * Creates a new OpenfortSolanaProvider instance
+     *
+     * @param config - Provider configuration including account and signing functions
+     */
+    constructor(config) {
+        this._account = config.account;
+        this._signTransaction = config.signTransaction;
+        this._signAllTransactions = config.signAllTransactions;
+        this._signMessage = config.signMessage;
+    }
+    /**
+     * The public key of the wallet (Solana address in Base58 format)
+     */
+    get publicKey() {
+        return this._account.address;
+    }
+    /**
+     * Sign a message
+     *
+     * @param message - Message to sign (UTF-8 string)
+     * @returns Base58 encoded signature
+     */
+    async signMessage(message) {
+        return await this._signMessage(message);
+    }
+    /**
+     * Sign a single transaction
+     *
+     * @param transaction - Transaction to sign (various formats supported)
+     * @returns Signed transaction with signature and public key
+     */
+    async signTransaction(transaction) {
+        return await this._signTransaction(transaction);
+    }
+    /**
+     * Sign multiple transactions atomically
+     *
+     * @param transactions - Array of transactions to sign
+     * @returns Array of signed transactions in the same order
+     */
+    async signAllTransactions(transactions) {
+        return await this._signAllTransactions(transactions);
+    }
+    async request(args) {
+        switch (args.method) {
+            case 'signMessage': {
+                const signature = await this._signMessage(args.params.message);
+                return { signature };
+            }
+            case 'signTransaction': {
+                const signedTransaction = await this._signTransaction(args.params.transaction);
+                return { signedTransaction };
+            }
+            case 'signAllTransactions': {
+                const signedTransactions = await this._signAllTransactions(args.params.transactions);
+                return { signedTransactions };
+            }
+        }
+    }
+    /**
+     * Pretty log output for when an instance of this class is console.log'd
+     */
+    toJSON() {
+        return `OpenfortSolanaProvider(${this.publicKey})`;
+    }
+    /**
+     * String representation
+     */
+    toString() {
+        return this.toJSON();
+    }
+}
+/**
+ * Creates a new OpenfortSolanaProvider instance
+ *
+ * @param config - Provider configuration
+ * @returns A new OpenfortSolanaProvider instance
+ *
+ * @example
+ * ```ts
+ * const provider = createSolanaProvider({
+ *   account: embeddedAccount,
+ *   signTransaction: async (tx) => { ... },
+ *   signAllTransactions: async (txs) => { ... },
+ *   signMessage: async (msg) => { ... },
+ * });
+ * ```
+ */
+function createSolanaProvider(config) {
+    return new OpenfortSolanaProvider(config);
+}
+
+export { createSolanaProvider };
+//# sourceMappingURL=provider.js.map

package/build/solana/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/build/solana/types.d.ts

@@ -0,0 +1,253 @@
+/**
+ * Solana-specific types for @openfort/react/solana
+ *
+ * These types define the Solana wallet state machine and related interfaces.
+ */
+import type { ChainTypeEnum, EmbeddedAccount, RecoveryMethod, RecoveryParams } from '@openfort/openfort-js';
+import type React from 'react';
+import type { ConnectedWalletState, CreateEmbeddedWalletOptions, SetActiveEmbeddedWalletOptionsBase, SetRecoveryOptions as SetRecoveryOptionsBase, WalletDerived } from '../shared/types';
+/**
+ * Solana cluster identifier
+ */
+export type SolanaCluster = 'mainnet-beta' | 'devnet' | 'testnet';
+/**
+ * Solana commitment level for transactions
+ */
+export type SolanaCommitment = 'processed' | 'confirmed' | 'finalized';
+/**
+ * UI options for Solana-connected views (e.g. SolanaConnected page)
+ */
+export type SolanaUIOptions = {
+    /** Custom avatar component; receives address for display */
+    customAvatar?: React.ComponentType<{
+        address: string;
+    }>;
+};
+/**
+ * Configuration for Solana support in OpenfortProvider
+ *
+ * @example
+ * ```tsx
+ * <OpenfortProvider
+ *   publishableKey="pk_..."
+ *   walletConfig={{
+ *     shieldPublishableKey: 'shield_pk_...',
+ *     solana: {
+ *       cluster: 'mainnet-beta',
+ *       commitment: 'confirmed'
+ *     }
+ *   }}
+ * >
+ * ```
+ */
+export type SolanaConfig = {
+    /** Solana cluster to connect to */
+    cluster: SolanaCluster;
+    /** RPC URLs per cluster (mirrors ethereum.rpcUrls) */
+    rpcUrls?: Partial<Record<'mainnet-beta' | 'devnet' | 'testnet', string>>;
+    /** Commitment level for transactions (default: 'confirmed') */
+    commitment?: SolanaCommitment;
+    /** UI options for Solana-connected screens */
+    ui?: SolanaUIOptions;
+};
+/**
+ * Solana transaction formats supported by the provider
+ *
+ * Supports both @solana/kit format and raw bytes.
+ */
+export type SolanaTransaction = {
+    messageBytes: Uint8Array;
+} | {
+    serializeMessage(): Uint8Array;
+} | Uint8Array;
+/**
+ * Signed Solana transaction result
+ */
+export type SignedSolanaTransaction = {
+    /** Base58 encoded signature */
+    signature: string;
+    /** Base58 encoded public key of signer */
+    publicKey: string;
+};
+/**
+ * Request to sign a message
+ */
+export type SolanaSignMessageRequest = {
+    method: 'signMessage';
+    params: {
+        message: string;
+    };
+};
+/**
+ * Request to sign a transaction
+ */
+export type SolanaSignTransactionRequest = {
+    method: 'signTransaction';
+    params: {
+        transaction: SolanaTransaction;
+    };
+};
+/**
+ * Request to sign multiple transactions
+ */
+export type SolanaSignAllTransactionsRequest = {
+    method: 'signAllTransactions';
+    params: {
+        transactions: SolanaTransaction[];
+    };
+};
+/**
+ * Solana embedded wallet provider
+ *
+ * Provides signing capabilities for Solana transactions and messages.
+ * Can be used directly or wrapped with Kit signers.
+ *
+ * @example Direct usage
+ * ```tsx
+ * if (solana.status === 'connected') {
+ *   const signature = await solana.provider.signMessage('Hello Solana!');
+ * }
+ * ```
+ *
+ * @example With Kit Signer (from @openfort/react/solana)
+ * ```tsx
+ * const signer = createTransactionSigner(provider);
+ * // Use with @solana/kit
+ * ```
+ */
+export interface OpenfortEmbeddedSolanaWalletProvider {
+    /** Public key of the wallet (Base58 encoded) */
+    readonly publicKey: string;
+    /**
+     * Sign a message
+     * @param message - Message to sign (UTF-8 string)
+     * @returns Base58 encoded signature
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Sign a single transaction
+     * @param transaction - Transaction to sign
+     * @returns Signed transaction with signature and public key
+     */
+    signTransaction(transaction: SolanaTransaction): Promise<SignedSolanaTransaction>;
+    /**
+     * Sign multiple transactions atomically
+     * @param transactions - Array of transactions to sign
+     * @returns Array of signed transactions
+     */
+    signAllTransactions(transactions: SolanaTransaction[]): Promise<SignedSolanaTransaction[]>;
+    /**
+     * Request-based API (EIP-1193 style)
+     */
+    request(args: SolanaSignMessageRequest): Promise<{
+        signature: string;
+    }>;
+    request(args: SolanaSignTransactionRequest): Promise<{
+        signedTransaction: SignedSolanaTransaction;
+    }>;
+    request(args: SolanaSignAllTransactionsRequest): Promise<{
+        signedTransactions: SignedSolanaTransaction[];
+    }>;
+}
+/**
+ * Connected Solana embedded wallet
+ */
+export type ConnectedEmbeddedSolanaWallet = {
+    /** Embedded account id (from Openfort) */
+    id: string;
+    /** Solana address in Base58 format */
+    address: string;
+    /** Chain type discriminator */
+    chainType: typeof ChainTypeEnum.SVM;
+    /** Wallet index (for multiple wallets) */
+    walletIndex: number;
+    /** Recovery method for this wallet */
+    recoveryMethod?: RecoveryMethod;
+    /** Get the Solana wallet provider */
+    getProvider(): Promise<OpenfortEmbeddedSolanaWalletProvider>;
+};
+/** Options for setting active Solana wallet (chain-specific address + shared recovery). */
+export type SetActiveSolanaWalletOptions = SetActiveEmbeddedWalletOptionsBase & {
+    /** Wallet address to set as active (Base58) */
+    address: string;
+};
+/**
+ * Actions available on Solana embedded wallets
+ */
+export interface SolanaWalletActions {
+    /** Create a new Solana embedded wallet */
+    create(options?: CreateEmbeddedWalletOptions): Promise<EmbeddedAccount>;
+    /** List of available Solana wallets */
+    wallets: ConnectedEmbeddedSolanaWallet[];
+    /** Set the active wallet */
+    setActive(options: SetActiveSolanaWalletOptions): Promise<void>;
+    /** Update recovery method */
+    setRecovery(options: SetRecoveryOptionsBase): Promise<void>;
+    /** Export the private key (requires user confirmation) */
+    exportPrivateKey(): Promise<string>;
+}
+export type SolanaWalletStateBase = (SolanaWalletActions & {
+    status: 'disconnected';
+    activeWallet: null;
+    address?: never;
+    cluster?: never;
+    displayAddress?: never;
+}) | (SolanaWalletActions & {
+    status: 'fetching-wallets';
+    activeWallet: null;
+    address?: never;
+    cluster?: never;
+    displayAddress?: never;
+}) | (SolanaWalletActions & {
+    status: 'connecting';
+    activeWallet: ConnectedEmbeddedSolanaWallet;
+    address: string;
+    cluster: SolanaCluster;
+    displayAddress: string;
+}) | (SolanaWalletActions & {
+    status: 'reconnecting';
+    activeWallet: ConnectedEmbeddedSolanaWallet;
+    address: string;
+    cluster: SolanaCluster;
+    displayAddress: string;
+}) | (SolanaWalletActions & {
+    status: 'creating';
+    activeWallet: null;
+    address?: never;
+    cluster?: never;
+    displayAddress?: never;
+}) | (SolanaWalletActions & {
+    status: 'needs-recovery';
+    activeWallet: ConnectedEmbeddedSolanaWallet;
+    address?: string;
+    cluster?: SolanaCluster;
+    displayAddress?: string;
+}) | (SolanaWalletActions & {
+    status: 'connected';
+    activeWallet: ConnectedEmbeddedSolanaWallet;
+    provider: OpenfortEmbeddedSolanaWalletProvider;
+    address: string;
+    cluster: SolanaCluster;
+    displayAddress: string;
+}) | (SolanaWalletActions & {
+    status: 'error';
+    activeWallet: ConnectedEmbeddedSolanaWallet | null;
+    error: string;
+    address?: string;
+    cluster?: SolanaCluster;
+    displayAddress?: string;
+});
+/** Derived booleans + optional RPC URL (Solana-specific). */
+export type SolanaWalletDerived = WalletDerived & {
+    rpcUrl?: string;
+};
+export type SolanaWalletState = SolanaWalletStateBase & SolanaWalletDerived & ConnectedWalletState;
+/**
+ * Options for useSolanaEmbeddedWallet hook
+ */
+export type UseEmbeddedSolanaWalletOptions = {
+    /** Solana cluster (mainnet-beta, devnet, testnet). Overrides context when set. */
+    cluster?: SolanaCluster;
+    /** Recovery params for wallet access */
+    recoveryParams?: RecoveryParams;
+};

package/build/solana/utils/transfer.d.ts

@@ -0,0 +1,9 @@
+import { AccountRole, address } from '@solana/kit';
+export declare function createTransferSolInstruction(from: string, to: string, lamports: bigint): {
+    programAddress: ReturnType<typeof address>;
+    data: Uint8Array;
+    accounts: Array<{
+        address: ReturnType<typeof address>;
+        role: AccountRole;
+    }>;
+};

package/build/solana/utils/transfer.js

@@ -0,0 +1,20 @@
+import { address, AccountRole } from '@solana/kit';
+import { TRANSFER_INSTRUCTION_INDEX, SYSTEM_PROGRAM_ADDRESS } from '../constants.js';
+
+function createTransferSolInstruction(from, to, lamports) {
+    const data = new Uint8Array(12);
+    const view = new DataView(data.buffer);
+    view.setUint32(0, TRANSFER_INSTRUCTION_INDEX, true);
+    view.setBigUint64(4, lamports, true);
+    return {
+        programAddress: address(SYSTEM_PROGRAM_ADDRESS),
+        data,
+        accounts: [
+            { address: address(from), role: AccountRole.WRITABLE_SIGNER },
+            { address: address(to), role: AccountRole.WRITABLE },
+        ],
+    };
+}
+
+export { createTransferSolInstruction };
+//# sourceMappingURL=transfer.js.map

package/build/solana/utils/transfer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}