@pioneer-platform/solana-network 8.11.1 → 8.11.2

package/.turbo/turbo-build.log

@@ -1,2 +1 @@
-
-$ tsc -p .
+$ tsc -p .

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @pioneer-platform/solana-network
 
+## 8.11.2
+
+### Patch Changes
+
+- zcash working!
+
 ## 8.11.1
 
 ### Patch Changes

package/README.md

@@ -0,0 +1,239 @@
+# @pioneer-platform/solana-network
+
+Solana blockchain network integration module for the Pioneer Platform.
+
+## Features
+
+- ✅ SOL balance queries
+- ✅ SPL token balance queries
+- ✅ Transfer transaction building
+- ✅ Fee estimation
+- ✅ Transaction broadcasting
+- ✅ Transaction status tracking
+- ✅ Account information queries
+
+## Installation
+
+```bash
+bun install @pioneer-platform/solana-network
+```
+
+## Network Information
+
+- **Network ID**: `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`
+- **Chain Symbol**: SOL
+- **SLIP44**: 501
+- **Decimals**: 9 (lamports)
+- **Default RPC**: https://api.mainnet-beta.solana.com
+
+## Usage
+
+### Initialize Module
+
+```javascript
+const solanaNetwork = require('@pioneer-platform/solana-network')
+
+// Initialize with default RPC
+await solanaNetwork.init()
+
+// Or with custom RPC
+await solanaNetwork.init('https://your-custom-rpc.com')
+
+// Or with environment variable
+// Set SOLANA_RPC_URL in .env
+await solanaNetwork.init()
+```
+
+### Get SOL Balance
+
+```javascript
+const balance = await solanaNetwork.getBalance('9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM')
+console.log('Balance:', balance, 'SOL')
+```
+
+### Get SPL Token Balances
+
+```javascript
+const tokens = await solanaNetwork.getTokenBalances('9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM')
+
+tokens.forEach(token => {
+    console.log(`Token: ${token.mint}`)
+    console.log(`Balance: ${token.balance}`)
+    console.log(`Decimals: ${token.decimals}`)
+})
+```
+
+### Build Transfer Transaction
+
+```javascript
+const tx = await solanaNetwork.buildTransfer(
+    '9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM', // from
+    'DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK', // to
+    0.001 // amount in SOL
+)
+
+console.log('Transaction:', {
+    from: tx.from,
+    to: tx.to,
+    amount: tx.amount,
+    lamports: tx.lamports,
+    blockhash: tx.blockhash,
+    serialized: tx.serialized // base64 encoded, ready for signing
+})
+```
+
+### Estimate Transfer Fee
+
+```javascript
+const fee = await solanaNetwork.estimateFee()
+console.log('Fee:', fee, 'SOL') // typically ~0.000005 SOL
+```
+
+### Broadcast Signed Transaction
+
+```javascript
+// After signing the transaction
+const result = await solanaNetwork.broadcast(signedTransactionBase64)
+
+if (result.success) {
+    console.log('Transaction ID:', result.txid)
+} else {
+    console.error('Broadcast failed:', result.error)
+}
+```
+
+### Get Transaction Details
+
+```javascript
+const txDetails = await solanaNetwork.getTransaction('signature...')
+console.log('Transaction:', txDetails)
+```
+
+### Get Recent Blockhash
+
+```javascript
+const { blockhash, lastValidBlockHeight } = await solanaNetwork.getRecentBlockhash()
+console.log('Blockhash:', blockhash)
+console.log('Valid until block:', lastValidBlockHeight)
+```
+
+## API Reference
+
+### Module Exports
+
+#### `init(url?, settings?): Promise<boolean>`
+Initialize the Solana network module.
+- `url`: Optional RPC URL (defaults to env var or mainnet)
+- `settings`: Optional configuration object
+- Returns: `true` if successful
+
+#### `isOnline(): boolean`
+Check if module is initialized and connected.
+
+#### `getBalance(address): Promise<number>`
+Get SOL balance for an address.
+- `address`: Solana public key (base58 encoded)
+- Returns: Balance in SOL
+
+#### `getTokenBalances(address): Promise<Array>`
+Get all SPL token balances for an address.
+- `address`: Solana public key (base58 encoded)
+- Returns: Array of token accounts with balances
+
+#### `buildTransfer(from, to, amount): Promise<Object>`
+Build an unsigned SOL transfer transaction.
+- `from`: Sender's public key (base58)
+- `to`: Recipient's public key (base58)
+- `amount`: Amount in SOL
+- Returns: Transaction object with serialized data
+
+#### `estimateFee(): Promise<number>`
+Estimate transfer fee.
+- Returns: Fee in SOL (typically ~0.000005 SOL)
+
+#### `broadcast(tx): Promise<Object>`
+Broadcast a signed transaction.
+- `tx`: Base64 encoded signed transaction
+- Returns: `{ success: boolean, txid?: string, error?: string }`
+
+#### `getTransaction(signature): Promise<Object>`
+Get transaction details by signature.
+- `signature`: Transaction signature
+- Returns: Transaction details or null
+
+#### `getRecentBlockhash(): Promise<Object>`
+Get recent blockhash for transaction building.
+- Returns: `{ blockhash: string, lastValidBlockHeight: number }`
+
+#### `getAccount(address): Promise<Object>`
+Get account information.
+- `address`: Solana public key (base58 encoded)
+- Returns: Account info or null
+
+### Constants
+
+- `NETWORK_ID`: Solana network identifier
+- `CHAIN_SYMBOL`: 'SOL'
+- `DECIMALS`: 9
+
+## Testing
+
+```bash
+# Run basic tests
+bun run test
+
+# Run transfer tests
+cd __tests__
+node test-transfer.js
+```
+
+## Environment Variables
+
+```bash
+# Optional: Custom RPC URL
+SOLANA_RPC_URL=https://your-custom-rpc.com
+```
+
+## Integration with Pioneer Platform
+
+This module integrates with the Pioneer Platform's multi-chain architecture:
+
+1. **Balance Queries**: Used by `pioneer-balance` for portfolio calculations
+2. **Transaction Building**: Used by transaction routers for SOL transfers
+3. **Token Support**: SPL token discovery and balance tracking
+4. **Network State**: Health checks and network status monitoring
+
+## RPC Endpoints
+
+### Mainnet
+- https://api.mainnet-beta.solana.com (default)
+- https://solana-api.projectserum.com
+
+### Performance Tips
+- Use private RPC endpoints for production (QuickNode, Alchemy, etc.)
+- Default public RPCs have rate limits
+- Consider connection pooling for high-frequency queries
+
+## Transaction Signing
+
+This module builds **unsigned** transactions. To sign and broadcast:
+
+```javascript
+// 1. Build transaction
+const tx = await solanaNetwork.buildTransfer(from, to, amount)
+
+// 2. Sign with your wallet/keypair (using @solana/web3.js)
+const { Keypair } = require('@solana/web3.js')
+const keypair = Keypair.fromSecretKey(secretKey)
+tx.transaction.sign(keypair)
+
+// 3. Serialize signed transaction
+const signedTx = tx.transaction.serialize().toString('base64')
+
+// 4. Broadcast
+const result = await solanaNetwork.broadcast(signedTx)
+```
+
+## License
+
+Pioneer Platform License

package/lib/index.js

@@ -62,6 +62,7 @@ var axiosLib = require('axios');
 var Axios = axiosLib.default || axiosLib;
 var https = require('https');
 var log = require('@pioneer-platform/loggerdog')();
+var _a = require('@solana/web3.js'), Connection = _a.Connection, PublicKey = _a.PublicKey, Transaction = _a.Transaction, SystemProgram = _a.SystemProgram, LAMPORTS_PER_SOL = _a.LAMPORTS_PER_SOL;
 // Default Solana mainnet RPC
 var DEFAULT_RPC_URL = "https://api.mainnet-beta.solana.com";
 // Network constants
@@ -80,6 +81,7 @@ var axios = Axios.create({
 // Module state
 var rpcUrl = DEFAULT_RPC_URL;
 var isInitialized = false;
+var connection = null;
 /**********************************
  // Module Exports
  //**********************************/
@@ -115,6 +117,7 @@ module.exports = {
                         testResult = _a.sent();
                         if (!(testResult.data && testResult.data.result === 'ok')) return [3 /*break*/, 3];
                         log.info(tag, "Successfully connected to Solana RPC");
+                        connection = new Connection(rpcUrl, 'confirmed');
                         isInitialized = true;
                         return [2 /*return*/, true];
                     case 3: return [4 /*yield*/, axios({
@@ -130,6 +133,7 @@ module.exports = {
                         versionResult = _a.sent();
                         if (versionResult.data && versionResult.data.result) {
                             log.info(tag, "Connected to Solana RPC, version:", versionResult.data.result['solana-core']);
+                            connection = new Connection(rpcUrl, 'confirmed');
                             isInitialized = true;
                             return [2 /*return*/, true];
                         }
@@ -185,6 +189,31 @@ module.exports = {
     getTransaction: function (signature) {
         return get_transaction(signature);
     },
+    /**
+     * Build a SOL transfer transaction
+     * @param from - Sender's public key (base58)
+     * @param to - Recipient's public key (base58)
+     * @param amount - Amount in SOL
+     * @returns Unsigned transaction object
+     */
+    buildTransfer: function (from, to, amount) {
+        return build_transfer(from, to, amount);
+    },
+    /**
+     * Estimate transfer fee
+     * @returns Fee in SOL
+     */
+    estimateFee: function () {
+        return estimate_fee();
+    },
+    /**
+     * Get SPL token balances for an address
+     * @param address - Solana public key (base58)
+     * @returns Array of token accounts with balances
+     */
+    getTokenBalances: function (address) {
+        return get_token_balances(address);
+    },
     // Network constants
     NETWORK_ID: exports.NETWORK_ID,
     CHAIN_SYMBOL: exports.CHAIN_SYMBOL,
@@ -401,3 +430,150 @@ function get_transaction(signature) {
         });
     });
 }
+function build_transfer(from, to, amount) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, fromPubkey, toPubkey, lamports, _a, blockhash, lastValidBlockHeight, transferInstruction, transaction, serialized, e_7;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    tag = TAG + " | build_transfer | ";
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    if (!connection) {
+                        throw new Error("Module not initialized. Call init() first.");
+                    }
+                    log.debug(tag, "Building transfer from ".concat(from, " to ").concat(to, " for ").concat(amount, " SOL"));
+                    fromPubkey = new PublicKey(from);
+                    toPubkey = new PublicKey(to);
+                    lamports = Math.floor(amount * LAMPORTS_PER_SOL);
+                    return [4 /*yield*/, connection.getLatestBlockhash('confirmed')
+                        // Create transfer instruction
+                    ];
+                case 2:
+                    _a = _b.sent(), blockhash = _a.blockhash, lastValidBlockHeight = _a.lastValidBlockHeight;
+                    transferInstruction = SystemProgram.transfer({
+                        fromPubkey: fromPubkey,
+                        toPubkey: toPubkey,
+                        lamports: lamports
+                    });
+                    transaction = new Transaction({
+                        feePayer: fromPubkey,
+                        blockhash: blockhash,
+                        lastValidBlockHeight: lastValidBlockHeight
+                    }).add(transferInstruction);
+                    serialized = transaction.serializeMessage();
+                    log.debug(tag, "Transfer transaction built successfully");
+                    return [2 /*return*/, {
+                            transaction: transaction,
+                            serialized: serialized.toString('base64'),
+                            blockhash: blockhash,
+                            lastValidBlockHeight: lastValidBlockHeight,
+                            from: from,
+                            to: to,
+                            amount: amount,
+                            lamports: lamports
+                        }];
+                case 3:
+                    e_7 = _b.sent();
+                    log.error(tag, "Error building transfer:", e_7.message);
+                    throw e_7;
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function estimate_fee() {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, response, feeInLamports, feeInSOL, fallbackFee, e_8;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + " | estimate_fee | ";
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    if (!connection) {
+                        throw new Error("Module not initialized. Call init() first.");
+                    }
+                    return [4 /*yield*/, axios({
+                            url: rpcUrl,
+                            method: 'POST',
+                            data: {
+                                "jsonrpc": "2.0",
+                                "id": 1,
+                                "method": "getFees"
+                            }
+                        })];
+                case 2:
+                    response = _a.sent();
+                    if (response.data && response.data.result) {
+                        feeInLamports = response.data.result.value.feeCalculator.lamportsPerSignature;
+                        feeInSOL = feeInLamports / LAMPORTS_PER_SOL;
+                        log.debug(tag, "Estimated fee:", feeInSOL, "SOL");
+                        return [2 /*return*/, feeInSOL];
+                    }
+                    fallbackFee = 5000 / LAMPORTS_PER_SOL;
+                    log.debug(tag, "Using fallback fee:", fallbackFee, "SOL");
+                    return [2 /*return*/, fallbackFee];
+                case 3:
+                    e_8 = _a.sent();
+                    log.debug(tag, "Using fallback fee due to error:", e_8.message);
+                    // Return standard fee as fallback (5000 lamports = 0.000005 SOL)
+                    return [2 /*return*/, 5000 / LAMPORTS_PER_SOL];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}
+function get_token_balances(address) {
+    return __awaiter(this, void 0, void 0, function () {
+        var tag, response, tokenAccounts, e_9;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    tag = TAG + " | get_token_balances | ";
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    log.debug(tag, "Getting token balances for:", address);
+                    return [4 /*yield*/, axios({
+                            url: rpcUrl,
+                            method: 'POST',
+                            data: {
+                                "jsonrpc": "2.0",
+                                "id": 1,
+                                "method": "getTokenAccountsByOwner",
+                                "params": [
+                                    address,
+                                    { "programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
+                                    { "encoding": "jsonParsed" }
+                                ]
+                            }
+                        })];
+                case 2:
+                    response = _a.sent();
+                    if (response.data && response.data.result && response.data.result.value) {
+                        tokenAccounts = response.data.result.value.map(function (account) {
+                            var parsedInfo = account.account.data.parsed.info;
+                            return {
+                                mint: parsedInfo.mint,
+                                owner: parsedInfo.owner,
+                                balance: parsedInfo.tokenAmount.uiAmount,
+                                decimals: parsedInfo.tokenAmount.decimals,
+                                uiAmountString: parsedInfo.tokenAmount.uiAmountString
+                            };
+                        });
+                        log.debug(tag, "Found ".concat(tokenAccounts.length, " token accounts"));
+                        return [2 /*return*/, tokenAccounts];
+                    }
+                    return [2 /*return*/, []];
+                case 3:
+                    e_9 = _a.sent();
+                    log.error(tag, "Error getting token balances:", e_9.message);
+                    return [2 /*return*/, []];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/solana-network",
-  "version": "8.11.1",
+  "version": "8.11.2",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "description": "Pioneer Platform Solana Network module",