Package Exports

@gorbchain-xyz/chaindecode

Readme

GorbchainSDK V1.3+ - The Complete Solana Development Toolkit 🚀

Build production-ready Solana applications with blockchain, DeFi, and cryptography in minutes, not months

Why GorbchainSDK V1.3+?

While Solana's Web3.js provides raw RPC access, GorbchainSDK V1.3+ delivers a complete ecosystem:

🔐 NEW: Advanced Cryptography Suite

Personal Encryption - Private key-based encryption/decryption
Direct Encryption - Public key encryption between parties
Group Encryption - Multi-recipient encryption with role-based access
Signature Groups - Dynamic membership with signature-based access control
Shared Keys - Managed encryption keys with granular permissions
Scalable Contexts - Auto-scaling from 1-to-N recipient encryption

🎯 Enhanced Blockchain Analysis

Rich Transaction Analysis - Decode ANY Solana transaction with human-readable insights
Real-time RPC Monitoring - Advanced connection management and health checks
Cross-program Correlation - Understand complex multi-instruction transactions

🚀 DeFi & Token Operations

One-Line Token Creation - Launch tokens with metadata in seconds using Token22
NFT Minting Made Simple - Create Metaplex Core NFTs with royalties and attributes
Portfolio Intelligence - Track wallets, analyze holdings, monitor performance
⚡ 10x Faster Development - Pre-built integrations for DeFi, NFTs, and analytics

🔧 Developer Experience

Framework Ready - Works seamlessly with React, Vue, Next.js, and Node.js
Interactive Playground - Test all features with built-in crypto playground
TypeScript First - Full type safety and IntelliSense support

🚀 Installation

npm install @gorbchain-xyz/chaindecode
# or
yarn add @gorbchain-xyz/chaindecode
# or
pnpm add @gorbchain-xyz/chaindecode

🔐 Cryptography Suite

GorbchainSDK V1.3+ introduces a comprehensive cryptography suite for secure data handling, key management, and encrypted communications on Solana.

Personal Encryption

Encrypt data with your private key - only you can decrypt:

import { encryptPersonal, decryptPersonalString } from '@gorbchain-xyz/chaindecode';

// Encrypt sensitive data
const encrypted = await encryptPersonal(
  'My secret message',
  privateKey,
  { compress: true }
);

// Decrypt your data
const decrypted = await decryptPersonalString(encrypted, privateKey);
console.log(decrypted); // "My secret message"

Direct Encryption

Encrypt data for a specific recipient using their public key:

import { encryptDirect, decryptDirectString } from '@gorbchain-xyz/chaindecode';

// Alice encrypts for Bob
const encrypted = await encryptDirect(
  'Hello Bob!',
  bobPublicKey,
  alicePrivateKey,
  { compress: true }
);

// Bob decrypts Alice's message
const decrypted = await decryptDirectString(encrypted, bobPrivateKey);
console.log(decrypted); // "Hello Bob!"

Group & Signature-Based Encryption

Create dynamic groups with role-based permissions and signature-based access control:

import { 
  createSignatureGroup, 
  encryptForSignatureGroup,
  addMemberToSignatureGroup,
  MemberRole 
} from '@gorbchain-xyz/chaindecode';

// Create a signature-based group
const group = await createSignatureGroup(
  'Project Alpha Team',
  creatorPrivateKey,
  [
    { publicKey: bobPublicKey, role: MemberRole.ADMIN },
    { publicKey: charliePublicKey, role: MemberRole.MEMBER }
  ],
  { 
    allowDynamicMembership: true, 
    maxMembers: 20,
    requireSignatureVerification: true
  }
);

// Encrypt for all group members
const encrypted = await encryptForSignatureGroup(
  'Team announcement: New feature launch!',
  group,
  senderPrivateKey,
  senderPublicKey
);

// Add new members dynamically
const updatedGroup = await addMemberToSignatureGroup(
  group,
  { publicKey: dianaPublicKey, role: MemberRole.VIEWER },
  adminPrivateKey,
  adminPublicKey
);

Shared Key Management

Manage shared encryption keys with granular permissions:

import { SharedKeyManager } from '@gorbchain-xyz/chaindecode';

const sharedKeyManager = new SharedKeyManager();

// Create shared key with specific permissions
const sharedKey = await sharedKeyManager.createSharedKey(
  { 
    name: 'Team Documents Key', 
    purpose: 'Secure document sharing',
    creator: creatorPublicKey 
  },
  [
    { 
      publicKey: alicePublicKey, 
      permissions: { canDecrypt: true, canEncrypt: true, canShare: true, canRevoke: true }
    },
    { 
      publicKey: bobPublicKey, 
      permissions: { canDecrypt: true, canEncrypt: true, canShare: false, canRevoke: false }
    }
  ],
  creatorPrivateKey
);

// Encrypt with shared key
const encrypted = await sharedKeyManager.encryptWithSharedKey(
  'Confidential team document',
  sharedKey.keyId,
  senderPrivateKey,
  senderPublicKey
);

// Add recipients to existing shared key
const updatedKey = await sharedKeyManager.addRecipientsToSharedKey(
  sharedKey.keyId,
  [{ 
    publicKey: charliePublicKey, 
    permissions: { canDecrypt: true, canEncrypt: false, canShare: false, canRevoke: false }
  }],
  authorizerPrivateKey,
  authorizerPublicKey
);

Scalable Encryption Contexts

Auto-scaling encryption that transitions from direct to group encryption based on recipient count:

import { ScalableEncryptionManager } from '@gorbchain-xyz/chaindecode';

const manager = new ScalableEncryptionManager();

// Create context that starts with direct encryption
const { context } = await manager.createEncryptionContext(
  'Project Communications',
  'Team messaging that scales',
  initialRecipientPublicKey,
  creatorPrivateKey,
  { autoTransitionThreshold: 3 }
);

// Encrypt data (uses direct encryption for 1-2 recipients)
const encrypted1 = await manager.encryptInContext(
  context.contextId,
  'Hello team member!',
  senderPrivateKey
);

// Add more recipients (automatically transitions to shared key when threshold reached)
const updatedContext = await manager.addRecipientsToContext(
  context.contextId,
  [charliePublicKey, dianaPublicKey, evePublicKey],
  authorizerPrivateKey,
  authorizerPublicKey
);

// Now uses shared key encryption automatically
const encrypted2 = await manager.encryptInContext(
  context.contextId,
  'Hello everyone! This uses shared key now.',
  senderPrivateKey
);

🌐 RPC & Network Management

GorbchainSDK provides advanced RPC connection management with health monitoring, automatic retries, and connection pooling.

Basic RPC Configuration

import { GorbchainSDK } from '@gorbchain-xyz/chaindecode';

const sdk = new GorbchainSDK({
  rpcEndpoint: 'https://api.mainnet-beta.solana.com',
  network: 'mainnet',
  timeout: 30000,        // 30 seconds
  retries: 3,            // Retry failed requests
  retryDelay: 1000,      // Wait 1s between retries
});

Advanced RPC Configuration

const sdk = new GorbchainSDK({
  rpcEndpoint: 'https://api.mainnet-beta.solana.com',
  network: 'mainnet',
  
  // Connection pooling for high-throughput applications
  connectionPool: {
    size: 10,
    minConnections: 2,
    maxConnections: 20,
    idleTimeoutMs: 30000
  },
  
  // Advanced retry configuration
  retryConfig: {
    retries: 5,
    retryDelay: 1000,
    exponentialBackoff: true,
    maxRetryDelay: 10000,
    retryCondition: (error) => error.code !== 'INVALID_SIGNATURE'
  },
  
  // Health monitoring
  healthCheck: {
    enabled: true,
    interval: 30000,     // Check every 30 seconds
    timeout: 5000,       // Health check timeout
    onHealthChange: (isHealthy) => {
      console.log(`RPC Health: ${isHealthy ? 'OK' : 'DEGRADED'}`);
    }
  },
  
  // Request caching
  cache: {
    enabled: true,
    ttl: 60000,          // Cache for 1 minute
    maxSize: 1000        // Max cached items
  }
});

Network Health Monitoring

// Check RPC health
const health = await sdk.getNetworkHealth();
console.log(`RPC Status: ${health.status}`);
console.log(`Latency: ${health.latency}ms`);
console.log(`Block Height: ${health.blockHeight}`);
console.log(`TPS: ${health.transactionsPerSecond}`);

// Monitor network status
sdk.onNetworkStatusChange((status) => {
  if (status.isHealthy) {
    console.log('Network is healthy');
  } else {
    console.log(`Network issues detected: ${status.issues.join(', ')}`);
  }
});

RPC Endpoint Recommendations

Network	Recommended Endpoints	Performance	Rate Limits
Mainnet	`https://api.mainnet-beta.solana.com`	Standard	100 req/s
Mainnet Premium	`https://solana-api.projectserum.com`	High	1000 req/s
Devnet	`https://api.devnet.solana.com`	Standard	Unlimited
Testnet	`https://api.testnet.solana.com`	Standard	Unlimited
Custom RPC	Your Helius/QuickNode endpoint	Premium	Custom

🎮 Interactive Playground

Test all SDK features with the built-in interactive playground:

# Clone the repository
git clone https://github.com/gorbchain/sdk.git
cd sdk/examples/react-docs

# Install dependencies
npm install

# Start the playground
npm start

Visit http://localhost:3000/crypto-playground to:

✅ Generate test keypairs
✅ Test all encryption methods
✅ Experiment with group management
✅ Try scalable encryption contexts
✅ Debug with real-time results

Playground Features

The crypto playground provides:

Key Generation: Generate Solana keypairs for testing
Personal Encryption: Test private key-based encryption
Direct Encryption: Test public key encryption between parties
Signature Groups: Create and manage dynamic groups
Scalable Contexts: Test auto-scaling encryption
Shared Keys: Manage shared encryption keys
Digital Signatures: Sign and verify data

💡 Quick Examples

1. Decode Any Transaction (The Killer Feature)

import { GorbchainSDK } from '@gorbchain-xyz/chaindecode';

const sdk = new GorbchainSDK({
  rpcEndpoint: 'https://api.mainnet-beta.solana.com',
  network: 'mainnet'
});

// Decode a Raydium swap, Jupiter trade, or ANY transaction
const decoded = await sdk.getAndDecodeTransaction(
  '3K7XxugEXv8CBQCaL1ZYB7cgYiCGE4THakb23hw3Ltv1XsYDCNctCEivhwCLvtyrfo3gsS9tS3CPqX6kYTe4WqZn',
  {
    richDecoding: true,
    includeTokenMetadata: true,
    includeNftMetadata: true
  }
);

// Get human-readable insights
console.log(`Transaction type: ${decoded.summary.type}`);
console.log(`Total value: $${decoded.summary.totalValueUSD}`);
decoded.instructions.forEach(ix => {
  console.log(`- ${ix.decoded.description}`);
});

2. Create a Token in 3 Lines

const tokenResult = await sdk.createToken22TwoTx(wallet, {
  name: 'My DeFi Token',
  symbol: 'MDT',
  supply: 1_000_000,
  decimals: 6,
  uri: 'https://my-metadata.com/token.json'
});

console.log(`Token launched: ${tokenResult.tokenAddress}`);
console.log(`Total cost: ${tokenResult.cost / 1e9} SOL`);

3. Mint an NFT Collection

const nft = await sdk.createNFT(wallet, {
  name: 'Genesis #001',
  uri: 'https://my-nft-metadata.com/001.json',
  royaltyBasisPoints: 500, // 5% royalty
  attributes: [
    { trait_type: 'Rarity', value: 'Legendary' },
    { trait_type: 'Power', value: 100, display_type: 'number' }
  ]
});

console.log(`NFT minted: ${nft.assetAddress}`);

4. Analyze a Wallet Portfolio

const portfolio = await sdk.getWalletPortfolio('8uZJDwaY1H1GmyQ7BGRB8ixNxHKB8fUCCjN3hAYvfvSL');

console.log(`Total value: $${portfolio.totalValueUSD}`);
console.log(`Token holdings: ${portfolio.tokens.length}`);
console.log(`NFT collections: ${portfolio.nfts.length}`);
console.log(`DeFi positions: ${portfolio.defiPositions.length}`);

🎯 V1 Specializations

1. Rich Transaction Decoding 🔍

Unlike basic RPC calls, GorbchainSDK provides:

Human-readable instruction descriptions
Automatic token/NFT metadata fetching
Cross-program instruction correlation
Transaction flow visualization
Cost analysis in SOL and USD

Supported Programs:

System Program (transfers, account creation)
SPL Token & Token-2022 (all token operations)
Metaplex (NFT minting, transfers, burns)
Associated Token Account Program
Custom program support via plugins

2. Simplified Token Operations 🪙

Create tokens with a single function call:

Token22 program integration (latest standard)
Automatic metadata upload
Supply and decimal configuration
Cost estimation before creation
Transaction status tracking

3. NFT Ecosystem Integration 🎨

Full Metaplex Core support:

Create NFTs with on-chain metadata
Set royalties and creator shares
Add unlimited attributes
Batch minting capabilities
Collection management

4. Portfolio Intelligence 📊

Track and analyze wallets:

Real-time token balances
NFT collection discovery
DeFi position tracking
Historical transaction analysis
Performance metrics

📚 Complete API Reference

Core SDK Class

const sdk = new GorbchainSDK({
  rpcEndpoint: string,          // RPC endpoint URL
  network: 'mainnet' | 'testnet' | 'devnet',
  timeout?: number,             // Request timeout (ms)
  retries?: number,             // Retry attempts
  richDecoding?: {
    enabled: boolean,           // Enable rich decoding
    includeTokenMetadata: boolean,
    includeNftMetadata: boolean
  }
});

Transaction Decoding

// Decode any transaction with rich insights
sdk.getAndDecodeTransaction(
  signature: string,
  options?: {
    richDecoding?: boolean,
    includeTokenMetadata?: boolean,
    includeNftMetadata?: boolean
  }
): Promise<DecodedTransaction>

// Decode individual instructions
sdk.decodeInstruction(instruction: TransactionInstruction): DecodedInstruction

// Batch decode multiple instructions
sdk.decodeInstructions(instructions: TransactionInstruction[]): DecodedInstruction[]

Token Creation

// Create token with 2 transactions (recommended)
sdk.createToken22TwoTx(
  payer: Keypair,
  params: {
    name: string,
    symbol: string,
    supply: number,
    decimals: number,
    uri: string,
    description?: string
  }
): Promise<TokenCreationResult>

// Single transaction token creation (faster)
sdk.createToken22SingleTx(payer: Keypair, params: TokenParams): Promise<TokenCreationResult>

// Estimate costs before creation
sdk.estimateTokenCreationCost(params: TokenParams): Promise<number>

// Get comprehensive token information
sdk.getTokenInfo(mintAddress: string): Promise<TokenInfo>

NFT Operations

// Create NFT with Metaplex Core
sdk.createNFT(
  wallet: Keypair,
  params: {
    name: string,
    uri: string,
    description?: string,
    royaltyBasisPoints?: number,
    creators?: Creator[],
    attributes?: Attribute[]
  }
): Promise<NFTCreationResult>

// Estimate NFT creation cost
sdk.estimateNFTCreationCost(params: NFTParams): Promise<number>

Wallet & Balance Management

// Check if wallet has sufficient balance
sdk.checkSufficientBalance(
  address: PublicKey,
  requiredAmount: number
): Promise<BalanceCheckResult>

// Get wallet portfolio analysis
sdk.getWalletPortfolio(address: string): Promise<Portfolio>

Network Operations

// Check network health
sdk.getNetworkHealth(): Promise<NetworkHealth>

// Get current slot
sdk.getCurrentSlot(): Promise<number>

// Get block height
sdk.getBlockHeight(): Promise<number>

🔐 Cryptography Operations

Personal Encryption

// Encrypt data with private key
encryptPersonal(
  data: string | Buffer,
  privateKey: string,
  options?: {
    compress?: boolean,
    metadata?: Record<string, any>
  }
): Promise<PersonalEncryptionResult>

// Decrypt personal data
decryptPersonalString(
  encryptedResult: PersonalEncryptionResult,
  privateKey: string
): Promise<string>

decryptPersonalBuffer(
  encryptedResult: PersonalEncryptionResult,
  privateKey: string
): Promise<Buffer>

Direct Encryption

// Encrypt for specific recipient
encryptDirect(
  data: string | Buffer,
  recipientPublicKey: string,
  senderPrivateKey: string,
  options?: {
    compress?: boolean,
    includeMetadata?: boolean
  }
): Promise<DirectEncryptionResult>

// Decrypt from sender
decryptDirectString(
  encryptedResult: DirectEncryptionResult,
  recipientPrivateKey: string
): Promise<string>

decryptDirectBuffer(
  encryptedResult: DirectEncryptionResult,
  recipientPrivateKey: string
): Promise<Buffer>

Group & Signature-Based Encryption

// Create signature group
createSignatureGroup(
  groupName: string,
  creatorPrivateKey: string,
  initialMembers?: GroupMember[],
  options?: {
    allowDynamicMembership?: boolean,
    maxMembers?: number,
    requireSignatureVerification?: boolean
  }
): Promise<SignatureGroup>

// Encrypt for group
encryptForSignatureGroup(
  data: string,
  groupMetadata: SignatureGroup,
  senderPrivateKey: string,
  senderPublicKey: string,
  options?: EncryptionOptions
): Promise<GroupEncryptionResult>

// Add member to group
addMemberToSignatureGroup(
  groupMetadata: SignatureGroup,
  newMember: { publicKey: string, role: MemberRole },
  authorizerPrivateKey: string,
  authorizerPublicKey: string
): Promise<SignatureGroup>

// Remove member from group
removeMemberFromSignatureGroup(
  groupMetadata: SignatureGroup,
  memberPublicKey: string,
  authorizerPrivateKey: string,
  authorizerPublicKey: string,
  rotateKeys?: boolean
): Promise<SignatureGroup>

Shared Key Management

// Create shared key
SharedKeyManager.createSharedKey(
  keyMetadata: {
    name: string,
    purpose: string,
    creator: string
  },
  initialRecipients: SharedKeyRecipient[],
  creatorPrivateKey: string
): Promise<SharedKeyResult>

// Encrypt with shared key
SharedKeyManager.encryptWithSharedKey(
  data: string,
  keyId: string,
  senderPrivateKey: string,
  senderPublicKey: string
): Promise<SharedKeyEncryptionResult>

// Add recipients to shared key
SharedKeyManager.addRecipientsToSharedKey(
  keyId: string,
  newRecipients: SharedKeyRecipient[],
  authorizerPrivateKey: string,
  authorizerPublicKey: string
): Promise<SharedKeyResult>

// Transition personal encryption to shared key
SharedKeyManager.transitionToSharedKey(
  originalEncryptionResult: PersonalEncryptionResult | DirectEncryptionResult,
  transitionRequest: TransitionRequest
): Promise<SharedKeyTransitionResult>

Scalable Encryption Contexts

// Create scalable context
ScalableEncryptionManager.createEncryptionContext(
  contextName: string,
  purpose: string,
  initialRecipient: string,
  creatorPrivateKey: string,
  options?: {
    autoTransitionThreshold?: number,
    defaultPermissions?: ContextPermissions
  }
): Promise<{ manager: ScalableEncryptionManager, context: EncryptionContext }>

// Encrypt in context (auto-scales method)
ScalableEncryptionManager.encryptInContext(
  contextId: string,
  data: string,
  senderPrivateKey: string
): Promise<ContextEncryptionResult>

// Add recipients to context
ScalableEncryptionManager.addRecipientsToContext(
  contextId: string,
  newRecipients: string[],
  authorizerPrivateKey: string,
  authorizerPublicKey: string
): Promise<EncryptionContext>

Digital Signatures

// Sign data
signData(
  data: string,
  privateKey: string
): string

// Verify signature
verifySignature(
  data: string,
  signature: string,
  publicKey: string
): boolean

// Sign with metadata
signWithMetadata(
  data: string,
  privateKey: string,
  metadata: Record<string, any>
): SignatureResult

// Verify with metadata
verifyWithMetadata(
  signatureResult: SignatureResult,
  publicKey: string
): VerificationResult

🏗️ Framework Integration

React / Next.js

import { GorbchainSDK } from '@gorbchain-xyz/chaindecode';
import { useWallet } from '@solana/wallet-adapter-react';

export function TokenLauncher() {
  const { publicKey, signTransaction } = useWallet();
  const [loading, setLoading] = useState(false);
  
  const launchToken = async () => {
    setLoading(true);
    const sdk = new GorbchainSDK({ rpcEndpoint: process.env.NEXT_PUBLIC_RPC });
    
    try {
      const result = await sdk.createToken22TwoTx(wallet, {
        name: 'My Token',
        symbol: 'MTK',
        supply: 1_000_000,
        decimals: 9,
        uri: 'https://metadata.com/token.json'
      });
      
      console.log('Token created:', result.tokenAddress);
    } finally {
      setLoading(false);
    }
  };
  
  return (
    <button onClick={launchToken} disabled={loading}>
      {loading ? 'Creating...' : 'Launch Token'}
    </button>
  );
}

Vue.js

<template>
  <div>
    <button @click="decodeTransaction" :disabled="loading">
      Decode Transaction
    </button>
    <div v-if="decoded">
      <h3>Transaction Summary</h3>
      <p>Type: {{ decoded.summary.type }}</p>
      <p>Value: ${{ decoded.summary.totalValueUSD }}</p>
    </div>
  </div>
</template>

<script setup>
import { ref } from 'vue';
import { GorbchainSDK } from '@gorbchain-xyz/chaindecode';

const loading = ref(false);
const decoded = ref(null);

const decodeTransaction = async () => {
  loading.value = true;
  const sdk = new GorbchainSDK({ rpcEndpoint: import.meta.env.VITE_RPC });
  
  try {
    decoded.value = await sdk.getAndDecodeTransaction('signature_here', {
      richDecoding: true,
      includeTokenMetadata: true
    });
  } finally {
    loading.value = false;
  }
};
</script>

Node.js Backend

import express from 'express';
import { GorbchainSDK } from '@gorbchain-xyz/chaindecode';

const app = express();
const sdk = new GorbchainSDK({ rpcEndpoint: process.env.RPC_ENDPOINT });

app.get('/api/decode/:signature', async (req, res) => {
  try {
    const decoded = await sdk.getAndDecodeTransaction(req.params.signature, {
      richDecoding: true
    });
    res.json(decoded);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.post('/api/estimate-token-cost', async (req, res) => {
  const cost = await sdk.estimateTokenCreationCost(req.body);
  res.json({ costInSOL: cost / 1e9 });
});

🚀 Real-World Use Cases

1. DeFi Dashboard

// Monitor user's DeFi positions across protocols
const positions = await sdk.getWalletPortfolio(userAddress);
const defiValue = positions.defiPositions.reduce((sum, pos) => sum + pos.valueUSD, 0);

2. NFT Marketplace

// List user's NFTs with metadata
const portfolio = await sdk.getWalletPortfolio(userAddress);
const nfts = portfolio.nfts.map(nft => ({
  name: nft.metadata.name,
  image: nft.metadata.image,
  attributes: nft.metadata.attributes,
  floorPrice: nft.floorPriceUSD
}));

3. Token Launchpad

// Launch token with automatic liquidity pool creation
const token = await sdk.createToken22TwoTx(wallet, tokenParams);
// Add liquidity using Raydium/Orca SDK

4. Transaction Explorer

// Build a better Solscan
const tx = await sdk.getAndDecodeTransaction(signature);
// Display human-readable transaction flow

5. Portfolio Tracker

// Track portfolio performance over time
const portfolio = await sdk.getWalletPortfolio(address);
const totalValue = portfolio.totalValueUSD;
const topHoldings = portfolio.tokens.sort((a, b) => b.valueUSD - a.valueUSD).slice(0, 10);

6. Secure Communication App

// End-to-end encrypted messaging
const encrypted = await encryptDirect(
  'Secret message',
  recipientPublicKey,
  senderPrivateKey
);

// Group chat with dynamic membership
const group = await createSignatureGroup('Team Chat', creatorPrivateKey);
const groupMessage = await encryptForSignatureGroup(
  'Team update',
  group,
  senderPrivateKey,
  senderPublicKey
);

7. Document Management System

// Shared document encryption
const sharedKey = await sharedKeyManager.createSharedKey(
  { name: 'Legal Documents', purpose: 'Contract management' },
  [
    { publicKey: lawyer1, permissions: { canDecrypt: true, canEncrypt: true, canShare: true }},
    { publicKey: client1, permissions: { canDecrypt: true, canEncrypt: false, canShare: false }}
  ],
  adminPrivateKey
);

const encryptedDoc = await sharedKeyManager.encryptWithSharedKey(
  documentContent,
  sharedKey.keyId,
  senderPrivateKey,
  senderPublicKey
);

📋 Version History & Changelog

V1.3.0+ (Latest) - Cryptography Suite Release

Released: December 2024

🔐 NEW FEATURES:

Personal Encryption: Private key-based encryption/decryption
Direct Encryption: Public key encryption between parties with ECDH
Group Encryption: Multi-recipient encryption with role-based access control
Signature Groups: Dynamic membership with signature-based verification
Shared Key Management: Managed encryption keys with granular permissions
Scalable Contexts: Auto-scaling from direct to group encryption
Digital Signatures: Ed25519 signatures with metadata support
Crypto Playground: Interactive testing environment for all crypto features

🌐 RPC ENHANCEMENTS:

Advanced connection pooling and health monitoring
Exponential backoff retry logic with custom retry conditions
Real-time network status monitoring
Enhanced caching with TTL and size limits
Connection-specific error handling and recovery

🏗️ DEVELOPER EXPERIENCE:

TypeScript-first API with full type safety
Interactive playground for testing all features
Comprehensive documentation with real-world examples
Framework integration guides for React, Vue, Next.js

V1.2.0 - Enhanced Analytics

Released: October 2024

Portfolio intelligence improvements
Cross-program transaction correlation
Enhanced token metadata fetching
Performance optimizations

V1.1.0 - Token & NFT Operations

Released: August 2024

Token22 program integration
Metaplex Core NFT support
Batch operation capabilities
Cost estimation features

V1.0.0 - Initial Release

Released: June 2024

Core transaction decoding functionality
Basic RPC connection management
Fundamental blockchain analysis tools

🔧 Dependencies & Requirements

Core Dependencies

{
  "@solana/web3.js": "^1.95.0+",
  "tweetnacl": "^1.0.3",
  "buffer": "^6.0.3"
}

System Requirements

Node.js: 16+ (18+ recommended)
TypeScript: 4.5+ (5.0+ recommended)
Browser Support: Chrome 90+, Firefox 88+, Safari 14+
Memory: 512MB+ available RAM
Network: Reliable internet connection for RPC calls

Optional Dependencies

React: 18+ for React components
Vue: 3+ for Vue components
Next.js: 13+ for SSR/SSG support

⚡ Performance Optimizations

Caching Strategy

const sdk = new GorbchainSDK({
  rpcEndpoint: 'https://api.mainnet-beta.solana.com',
  cache: {
    enabled: true,
    ttl: 60000, // 1 minute
    maxSize: 1000
  }
});

Batch Operations

// Decode multiple transactions efficiently
const signatures = ['sig1', 'sig2', 'sig3'];
const decoded = await Promise.all(
  signatures.map(sig => sdk.getAndDecodeTransaction(sig))
);

Connection Pooling

// Use connection pool for high-throughput applications
const sdk = new GorbchainSDK({
  rpcEndpoint: 'https://api.mainnet-beta.solana.com',
  connectionPool: {
    size: 10,
    minConnections: 2,
    maxConnections: 20
  }
});

🔧 Advanced Features

Custom Instruction Decoders

import { DecoderRegistry } from '@gorbchain-xyz/chaindecode';

// Add support for your custom program
const registry = new DecoderRegistry();
registry.register('MyDeFiProtocol', 'ProgramID...', (instruction) => ({
  type: 'swap',
  programId: instruction.programId,
  data: decodeSwapData(instruction.data),
  accounts: mapSwapAccounts(instruction.accounts)
}));

const sdk = new GorbchainSDK({
  rpcEndpoint: 'https://api.mainnet-beta.solana.com',
  customDecoders: registry
});

Webhook Integration

// Monitor addresses for new transactions
sdk.watchAddress('8uZJDwaY1H1GmyQ7BGRB8ixNxHKB8fUCCjN3hAYvfvSL', async (tx) => {
  const decoded = await sdk.getAndDecodeTransaction(tx.signature);
  // Send to webhook
  await fetch('https://your-webhook.com', {
    method: 'POST',
    body: JSON.stringify(decoded)
  });
});

Error Recovery

const sdk = new GorbchainSDK({
  rpcEndpoint: 'https://api.mainnet-beta.solana.com',
  retries: 3,
  retryDelay: 1000,
  onError: (error, attempt) => {
    console.log(`Attempt ${attempt} failed:`, error.message);
  }
});

🛡️ Security Best Practices

General Security

Never expose private keys in frontend code
Use environment variables for RPC endpoints
Implement rate limiting for API endpoints
Validate all user inputs before processing
Use secure key management solutions

Cryptography Security

Generate keys with cryptographically secure randomness
Never reuse nonces or ephemeral keys
Implement forward secrecy with key rotation
Use signature verification for group access control
Regularly audit and rotate shared keys
Implement proper access controls for shared key permissions
Store encrypted data with integrity checks

Production Deployment

Use HTTPS for all network communications
Implement proper error handling without exposing sensitive details
Monitor for unusual encryption/decryption patterns
Use hardware security modules (HSMs) for production key storage

📊 Benchmarks

Core Operations

Operation	GorbchainSDK V1.3+	Raw Web3.js	Improvement
Transaction Decoding	45ms	380ms	8.4x faster
Token Creation	2.1s	5.8s	2.7x faster
NFT Minting	1.8s	4.2s	2.3x faster
Portfolio Analysis	120ms	850ms	7.1x faster

Cryptography Operations

Operation	Performance	Memory Usage	Notes
Personal Encryption	~15ms	2KB	AES-256-GCM
Direct Encryption	~25ms	3KB	ECDH + AES-256-GCM
Group Encryption (10 members)	~85ms	8KB	Shared key distribution
Signature Verification	~5ms	1KB	Ed25519
Key Generation	~8ms	1KB	Cryptographically secure

Scalability Tests

Recipients	Direct Encryption	Shared Key	Auto-Scale Choice
1	25ms	N/A	Direct
2	35ms	N/A	Direct
3	45ms	35ms	Shared Key
10	150ms	85ms	Shared Key
100	1.5s	95ms	Shared Key

Benchmarks performed on mainnet-beta with standard RPC endpoints and Node.js 18+

🤝 Contributing

We welcome contributions! See our Contributing Guide for details.

Development Setup

git clone https://github.com/gorbchain/sdk.git
cd sdk
npm install
npm run build
npm test

📄 License

MIT License - see LICENSE for details.

🔗 Resources

🌐 Website: https://gorbchain.xyz
📚 Documentation: https://docs.gorbchain.xyz
🚀 Token Launchpad: https://launch.gorbchain.xyz
💬 Discord: Join our community
🐦 Twitter: @GorbChain
📦 NPM: @gorbchain-xyz/chaindecode

Built by developers, for developers ❤️ Stop writing boilerplate. Start shipping features.

GorbchainSDK V1 - Where every line of code counts.