@dynamic-labs/stellar 4.59.2 → 4.60.1

package/src/wallet/StellarWallet.js

@@ -1,6 +1,11 @@
 'use client'
 import { __awaiter } from '../../_virtual/_tslib.js';
+import { TransactionBuilder } from '@stellar/stellar-sdk';
 import { Wallet } from '@dynamic-labs/wallet-connector-core';
+import { buildPaymentTransaction } from '../utils/buildPaymentTransaction.js';
+import { checkTrustline } from '../utils/checkTrustline.js';
+import { createPaymentAsset } from '../utils/createPaymentAsset.js';
+import { getAccountBalance } from '../utils/getAccountBalance.js';
 
 /**
  * Stellar wallet implementation that provides chain-specific functionality
@@ -12,26 +17,76 @@ import { Wallet } from '@dynamic-labs/wallet-connector-core';
 class StellarWallet extends Wallet {
     /**
      * Get balance of the wallet.
-     * @returns Balance of the wallet in XLM
+     * @param assetCode - Optional asset code. If not provided, returns native XLM balance
+     * @param assetIssuer - Optional asset issuer. Required if assetCode is provided
+     * @returns Balance of the wallet
      */
-    getBalance() {
+    getBalance(assetCode, assetIssuer) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this._connector.connect();
-            // Balance fetching will be implemented when full SDK support is added
-            return '0';
+            const horizonServer = yield this.getHorizonServer();
+            const account = yield horizonServer.loadAccount(this.address);
+            return getAccountBalance(account, assetCode, assetIssuer);
         });
     }
     /**
      * Sends balance to another address.
-     * @param amount - Amount to send (in XLM for native transfers)
-     * @param toAddress - Recipient address
+     * Supports both native XLM and custom Stellar assets.
+     *
+     * @param params - Send balance parameters
+     * @param params.amount - Amount to send
+     * @param params.toAddress - Recipient address (Stellar public key)
+     * @param params.token - Optional token information for non-XLM transfers
+     * @param params.token.address - Token address in format "CODE:ISSUER"
+     * @param params.token.decimals - Token decimals (optional, Stellar uses 7 decimals by default)
      * @returns Transaction hash
      */
-    sendBalance(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ amount, toAddress, }) {
+    sendBalance(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { amount, toAddress, token } = params;
             yield this._connector.connect();
-            // Transaction sending will be implemented when full SDK support is added
-            throw new Error(`sendBalance not yet implemented. Amount: ${amount}, To: ${toAddress}`);
+            const horizonServer = yield this.getHorizonServer();
+            const sourceAccount = yield horizonServer.loadAccount(this.address);
+            const networkPassphrase = yield this._connector.getNetworkPassphrase();
+            let asset;
+            if (token === null || token === void 0 ? void 0 : token.address) {
+                const [code, issuer] = token.address.split(':');
+                if (!code || !issuer) {
+                    throw new Error('Invalid token address format. Expected "CODE:ISSUER" (e.g., "USDC:GXXXXXXX...")');
+                }
+                asset = { code, issuer };
+            }
+            const paymentAsset = createPaymentAsset(asset);
+            let destinationAccount;
+            try {
+                destinationAccount = yield horizonServer.loadAccount(toAddress);
+            }
+            catch (error) {
+                throw new Error(`Failed to load destination account ${toAddress}. The account may not exist or be funded.`);
+            }
+            // Check if destination account has trustline for non-native assets
+            if (!paymentAsset.isNative()) {
+                const hasTrustline = checkTrustline(destinationAccount, paymentAsset);
+                if (!hasTrustline) {
+                    const assetCode = paymentAsset.getCode();
+                    const assetIssuer = paymentAsset.getIssuer();
+                    throw new Error(`Destination account ${toAddress} does not have a trustline for asset ${assetCode}:${assetIssuer}. ` +
+                        'The recipient must establish a trustline before receiving this asset.');
+                }
+            }
+            const transaction = buildPaymentTransaction({
+                amount,
+                asset: paymentAsset,
+                memo: undefined,
+                networkPassphrase,
+                sourceAccount,
+                toAddress,
+            });
+            const transactionXdr = transaction.toXDR();
+            const signedXdr = yield this.signTransaction(transactionXdr);
+            const transactionToSubmit = TransactionBuilder.fromXDR(signedXdr, networkPassphrase);
+            const response = yield horizonServer.submitTransaction(transactionToSubmit);
+            return response.hash;
         });
     }
     /**

package/src/types/FreighterProvider.d.ts

@@ -1,82 +0,0 @@
-/**
- * Freighter Wallet Provider Types
- *
- * Types for the Freighter wallet API
- * From @stellar/freighter-api package
- */
-/// <reference types="node" />
-/**
- * Freighter API error type
- */
-export type FreighterApiError = {
-    code: number;
-    message: string;
-};
-/**
- * Freighter API response wrapper
- * All Freighter API methods return responses in this format
- */
-export type FreighterApiResponse<T> = T & {
-    error?: FreighterApiError;
-};
-/**
- * Freighter API methods
- * These are the raw methods provided by @stellar/freighter-api package
- *
- * Note: Freighter uses a functional API (individual exported functions)
- * rather than a provider object at window.freighter
- */
-export type FreighterApi = {
-    /** Get the user's address */
-    getAddress: () => Promise<FreighterApiResponse<{
-        address: string;
-    }>>;
-    /** Get current network */
-    getNetwork: () => Promise<string>;
-    /** Check if extension is installed and accessible */
-    isConnected: () => Promise<boolean>;
-    /** Check if user has granted access */
-    isAllowed: () => Promise<boolean>;
-    /** Request access to the wallet */
-    requestAccess: () => Promise<FreighterApiResponse<{
-        address: string;
-    }>>;
-    /** Sign a transaction */
-    signTransaction: (transactionXdr: string, opts?: {
-        networkPassphrase?: string;
-        address?: string;
-    }) => Promise<FreighterApiResponse<{
-        signedTxXdr: string;
-        signerAddress: string;
-    }>>;
-    /** Sign a message */
-    signMessage: (message: string, opts?: {
-        networkPassphrase?: string;
-        address?: string;
-    }) => Promise<FreighterApiResponse<{
-        signedMessage: string | Buffer | null;
-        signerAddress: string;
-    }>>;
-    /** Sign an auth entry */
-    signAuthEntry: (entry: string, opts?: {
-        networkPassphrase?: string;
-        address?: string;
-    }) => Promise<FreighterApiResponse<{
-        signedAuthEntry: string;
-        signerAddress: string;
-    }>>;
-    /** Set allowed status (internal use) */
-    setAllowed: () => Promise<void>;
-};
-/**
- * Type guard to check if a Freighter API response has an error
- */
-export declare const isFreighterError: <T>(response: FreighterApiResponse<T>) => response is T & {
-    error?: FreighterApiError | undefined;
-} & {
-    error: FreighterApiError;
-};
-/**
- * Handle Freighter API response and throw if there's an error
- */
-export declare const handleFreighterResponse: <T>(response: FreighterApiResponse<T>) => T;