@lobstercove/lichen-sdk 1.0.0

package/dist/connection.d.ts

@@ -0,0 +1,482 @@
+import { PublicKey } from './publickey.js';
+import { Keypair } from './keypair.js';
+import { Transaction } from './transaction.js';
+/**
+ * Balance information
+ */
+export interface Balance {
+    spores: number;
+    licn: number;
+    spendable?: number;
+    spendable_licn?: string;
+    staked?: number;
+    staked_licn?: string;
+    locked?: number;
+    locked_licn?: string;
+    moss_staked?: number;
+    moss_staked_licn?: string;
+    moss_value?: number;
+    moss_value_licn?: string;
+}
+/**
+ * Account information
+ */
+export interface Account {
+    spores: number;
+    owner: string;
+    executable: boolean;
+    data: string;
+}
+/**
+ * Block information
+ */
+export interface Block {
+    slot: number;
+    hash: string;
+    parentHash: string;
+    transactions: number;
+    timestamp: number;
+}
+/**
+ * Validator information
+ */
+export interface Validator {
+    pubkey: string;
+    stake: number;
+    reputation: number;
+    blocksProposed: number;
+    votesCast: number;
+    correctVotes: number;
+    lastActiveSlot: number;
+}
+/**
+ * Network information
+ */
+export interface NetworkInfo {
+    chainId: string;
+    networkId: string;
+    version: string;
+    currentSlot: number;
+    validatorCount: number;
+    peerCount: number;
+}
+/**
+ * Chain status
+ */
+export interface ChainStatus {
+    currentSlot: number;
+    validatorCount: number;
+    totalStake: number;
+    tps: number;
+    totalTransactions: number;
+    totalBlocks: number;
+    averageBlockTime: number;
+    isHealthy: boolean;
+}
+/**
+ * Performance metrics
+ */
+export interface Metrics {
+    tps: number;
+    totalTransactions: number;
+    totalBlocks: number;
+    averageBlockTime: number;
+}
+/**
+ * A single step in a Merkle inclusion proof
+ */
+export interface ProofStep {
+    hash: string;
+    direction: 'left' | 'right';
+}
+/**
+ * Merkle inclusion proof for a transaction
+ */
+export interface TransactionProof {
+    slot: number;
+    tx_index: number;
+    tx_hash: string;
+    root: string;
+    proof: ProofStep[];
+}
+/**
+ * Read-only contract call result.
+ */
+export interface ReadonlyContractResult {
+    success: boolean;
+    returnData?: string | null;
+    returnCode?: number | null;
+    logs?: string[];
+    error?: string | null;
+    computeUsed?: number;
+}
+/**
+ * RPC/WebSocket connection to Lichen
+ */
+export declare class Connection {
+    private rpcUrl;
+    private wsUrl?;
+    private ws?;
+    private subscriptions;
+    private nextId;
+    private timeoutMs;
+    constructor(rpcUrl: string, wsUrl?: string, options?: {
+        timeoutMs?: number;
+    });
+    /**
+     * Make an RPC call
+     */
+    private rpc;
+    /**
+     * Get account balance
+     */
+    getBalance(pubkey: PublicKey): Promise<Balance>;
+    /**
+     * Get account information
+     */
+    getAccount(pubkey: PublicKey): Promise<Account>;
+    /**
+     * Get block by slot number
+     */
+    getBlock(slot: number): Promise<Block>;
+    /**
+     * Get latest block
+     */
+    getLatestBlock(): Promise<Block>;
+    /**
+     * Get current slot
+     */
+    getSlot(): Promise<number>;
+    /**
+     * Get recent blockhash for transactions
+     */
+    getRecentBlockhash(): Promise<string>;
+    /**
+     * Get transaction by signature.
+     * For contract calls, response includes: return_code (u32), return_data (base64), contract_logs (string[]).
+     */
+    getTransaction(signature: string): Promise<any>;
+    /**
+     * Get a Merkle inclusion proof for a transaction by its signature.
+     */
+    getTransactionProof(signature: string): Promise<TransactionProof>;
+    /**
+     * Verify a Merkle inclusion proof for a transaction against a root.
+     * Uses SHA-256 with domain-separated leaf (0x00) and internal (0x01) nodes.
+     *
+     * This is a pure static function — no RPC call needed.
+     */
+    static verifyTransactionProof(root: string, txHash: string, proof: ProofStep[]): boolean;
+    /**
+     * Send transaction
+     */
+    sendTransaction(transaction: Transaction): Promise<string>;
+    /**
+     * Get total burned LICN
+     */
+    getTotalBurned(): Promise<Balance>;
+    /**
+     * Get all validators
+     */
+    getValidators(): Promise<Validator[]>;
+    /**
+     * Get performance metrics
+     */
+    getMetrics(): Promise<Metrics>;
+    /**
+     * Health check
+     */
+    health(): Promise<{
+        status: string;
+    }>;
+    /**
+     * Get connected peers
+     */
+    getPeers(): Promise<any[]>;
+    /**
+     * Get network information
+     */
+    getNetworkInfo(): Promise<NetworkInfo>;
+    /**
+     * Get detailed validator information
+     */
+    getValidatorInfo(pubkey: PublicKey): Promise<Validator>;
+    /**
+     * Get validator performance metrics
+     */
+    getValidatorPerformance(pubkey: PublicKey): Promise<any>;
+    /**
+     * Get comprehensive chain status
+     */
+    getChainStatus(): Promise<ChainStatus>;
+    /**
+     * Create stake transaction
+     */
+    stake(from: Keypair, validator: PublicKey, amount: number | bigint): Promise<string>;
+    /**
+     * Create unstake transaction
+     */
+    unstake(from: Keypair, validator: PublicKey, amount: number | bigint): Promise<string>;
+    /**
+     * Get staking status
+     */
+    getStakingStatus(pubkey: PublicKey): Promise<any>;
+    /**
+     * Get staking rewards
+     */
+    getStakingRewards(pubkey: PublicKey): Promise<any>;
+    /**
+     * Transfer native LICN (spores) from one account to another.
+     *
+     * @param from - Sender keypair (signer)
+     * @param to - Recipient public key
+     * @param amount - Amount in spores (1 LICN = 1,000,000,000 spores)
+     * @returns Transaction signature
+     */
+    transfer(from: Keypair, to: PublicKey, amount: number | bigint): Promise<string>;
+    /**
+     * Deploy a WASM smart contract.
+     *
+     * @param deployer - Deployer keypair (signer, pays deploy fee)
+     * @param code - WASM bytecode (must start with \\0asm magic, max 512 KB)
+     * @param initData - Optional initialization data passed to contract init
+     * @returns Transaction signature
+     */
+    deployContract(deployer: Keypair, code: Uint8Array, initData?: Uint8Array): Promise<string>;
+    /**
+     * Call a function on a deployed WASM smart contract.
+     *
+     * @param caller - Caller keypair (signer)
+     * @param contract - Contract account public key
+     * @param functionName - Name of the contract function to invoke
+     * @param args - Serialized function arguments (default: empty)
+     * @param value - Native LICN to send with the call in spores (default: 0)
+     * @returns Transaction signature
+     */
+    callContract(caller: Keypair, contract: PublicKey, functionName: string, args?: Uint8Array, value?: number | bigint): Promise<string>;
+    /**
+     * Upgrade a deployed WASM smart contract (owner only).
+     *
+     * @param owner - Contract owner keypair (signer)
+     * @param contract - Contract account public key
+     * @param code - New WASM bytecode
+     * @returns Transaction signature
+     */
+    upgradeContract(owner: Keypair, contract: PublicKey, code: Uint8Array): Promise<string>;
+    /**
+     * Get enhanced account information
+     */
+    getAccountInfo(pubkey: PublicKey): Promise<any>;
+    /**
+     * Get transaction history
+     */
+    getTransactionHistory(pubkey: PublicKey, limit?: number): Promise<any>;
+    /**
+     * Get program accounts
+     */
+    getProgramAccounts(programId: PublicKey): Promise<any[]>;
+    /**
+     * Simulate transaction (dry run)
+     */
+    simulateTransaction(transaction: Transaction): Promise<any>;
+    /**
+     * Execute a read-only contract call without submitting a transaction.
+     */
+    callReadonlyContract(contractId: PublicKey, functionName: string, args?: Uint8Array, from?: PublicKey): Promise<ReadonlyContractResult>;
+    /**
+     * Get contract information
+     */
+    getContractInfo(contractId: PublicKey): Promise<any>;
+    /**
+     * Get contract logs
+     */
+    getContractLogs(contractId: PublicKey): Promise<any>;
+    /**
+     * Get contract ABI/IDL (machine-readable function and event interface)
+     */
+    getContractAbi(contractId: PublicKey): Promise<any>;
+    /**
+     * Set/update contract ABI (owner only)
+     */
+    setContractAbi(contractId: PublicKey, abi: any): Promise<any>;
+    /**
+     * Get all deployed contracts
+     */
+    getAllContracts(): Promise<any>;
+    /**
+     * Get a symbol-registry entry.
+     */
+    getSymbolRegistry(symbol: string): Promise<any>;
+    /**
+     * Get the complete LichenID profile for an address.
+     */
+    getLichenIdProfile(pubkey: PublicKey): Promise<any>;
+    /**
+     * Get the LichenID reputation summary for an address.
+     */
+    getLichenIdReputation(pubkey: PublicKey): Promise<any>;
+    /**
+     * Get LichenID skills for an address.
+     */
+    getLichenIdSkills(pubkey: PublicKey): Promise<any>;
+    /**
+     * Get LichenID vouches for an address.
+     */
+    getLichenIdVouches(pubkey: PublicKey): Promise<any>;
+    /**
+     * Resolve a .lichen name to its owner.
+     */
+    resolveLichenName(name: string): Promise<any>;
+    /**
+     * Get premium-name auction state for a .lichen label.
+     */
+    getNameAuction(name: string): Promise<any>;
+    /**
+     * Get the LichenID agent directory.
+     */
+    getLichenIdAgentDirectory(options?: {
+        type?: number;
+        available?: boolean;
+        min_reputation?: number;
+        limit?: number;
+        offset?: number;
+    }): Promise<any>;
+    /**
+     * Get aggregated LichenID statistics.
+     */
+    getLichenIdStats(): Promise<any>;
+    /**
+     * Get aggregated SporePay streaming statistics.
+     */
+    getSporePayStats(): Promise<any>;
+    /**
+     * Get aggregated LichenSwap AMM statistics.
+     */
+    getLichenSwapStats(): Promise<any>;
+    /**
+     * Get aggregated ThallLend lending statistics.
+     */
+    getThallLendStats(): Promise<any>;
+    /**
+     * Get aggregated SporeVault yield-vault statistics.
+     */
+    getSporeVaultStats(): Promise<any>;
+    /**
+     * Get aggregated BountyBoard marketplace statistics.
+     */
+    getBountyBoardStats(): Promise<any>;
+    getProgram(programId: PublicKey): Promise<any>;
+    getProgramStats(programId: PublicKey): Promise<any>;
+    getPrograms(): Promise<any>;
+    getProgramCalls(programId: PublicKey): Promise<any>;
+    getProgramStorage(programId: PublicKey): Promise<any>;
+    getCollection(collectionId: PublicKey): Promise<any>;
+    getNFT(collectionId: PublicKey, tokenId: number): Promise<any>;
+    getNFTsByOwner(owner: PublicKey): Promise<any>;
+    getNFTsByCollection(collectionId: PublicKey): Promise<any>;
+    getNFTActivity(collectionId: PublicKey, tokenId: number): Promise<any>;
+    /**
+     * Connect WebSocket
+     */
+    private connectWs;
+    /**
+     * Subscribe to method
+     */
+    private subscribe;
+    /**
+     * Unsubscribe from subscription
+     */
+    private unsubscribe;
+    /**
+     * Subscribe to slot updates
+     */
+    onSlot(callback: (slot: number) => void): Promise<number>;
+    /**
+     * Unsubscribe from slots
+     */
+    offSlot(subscriptionId: number): Promise<boolean>;
+    /**
+     * Subscribe to block updates
+     */
+    onBlock(callback: (block: Block) => void): Promise<number>;
+    /**
+     * Unsubscribe from blocks
+     */
+    offBlock(subscriptionId: number): Promise<boolean>;
+    /**
+     * Subscribe to transaction updates
+     */
+    onTransaction(callback: (transaction: any) => void): Promise<number>;
+    /**
+     * Unsubscribe from transactions
+     */
+    offTransaction(subscriptionId: number): Promise<boolean>;
+    /**
+     * Subscribe to account changes
+     */
+    onAccountChange(pubkey: PublicKey, callback: (account: any) => void): Promise<number>;
+    /**
+     * Unsubscribe from account changes
+     */
+    offAccountChange(subscriptionId: number): Promise<boolean>;
+    /**
+     * Subscribe to contract logs
+     */
+    onLogs(callback: (log: any) => void, contractId?: PublicKey): Promise<number>;
+    /**
+     * Unsubscribe from logs
+     */
+    offLogs(subscriptionId: number): Promise<boolean>;
+    /**
+     * Subscribe to program updates
+     */
+    onProgramUpdates(callback: (event: any) => void): Promise<number>;
+    /**
+     * Unsubscribe from program updates
+     */
+    offProgramUpdates(subscriptionId: number): Promise<boolean>;
+    /**
+     * Subscribe to program calls
+     */
+    onProgramCalls(callback: (event: any) => void, programId?: PublicKey): Promise<number>;
+    /**
+     * Unsubscribe from program calls
+     */
+    offProgramCalls(subscriptionId: number): Promise<boolean>;
+    /**
+     * Subscribe to NFT mints
+     */
+    onNftMints(callback: (event: any) => void, collectionId?: PublicKey): Promise<number>;
+    /**
+     * Unsubscribe from NFT mints
+     */
+    offNftMints(subscriptionId: number): Promise<boolean>;
+    /**
+     * Subscribe to NFT transfers
+     */
+    onNftTransfers(callback: (event: any) => void, collectionId?: PublicKey): Promise<number>;
+    /**
+     * Unsubscribe from NFT transfers
+     */
+    offNftTransfers(subscriptionId: number): Promise<boolean>;
+    /**
+     * Subscribe to marketplace listings
+     */
+    onMarketListings(callback: (event: any) => void): Promise<number>;
+    /**
+     * Unsubscribe from marketplace listings
+     */
+    offMarketListings(subscriptionId: number): Promise<boolean>;
+    /**
+     * Subscribe to marketplace sales
+     */
+    onMarketSales(callback: (event: any) => void): Promise<number>;
+    /**
+     * Unsubscribe from marketplace sales
+     */
+    offMarketSales(subscriptionId: number): Promise<boolean>;
+    /**
+     * Close connection
+     */
+    close(): void;
+}