@wireio/stake 0.0.6 → 0.1.1

package/src/networks/solana/program.ts

@@ -1,113 +1,47 @@
-// src/solana/programService.ts
-
 import { AnchorProvider, Program } from '@coral-xyz/anchor';
-import { PublicKey } from '@solana/web3.js';
 
-// 1) pull in all your on-chain IDLs (must match lowercase `src/assets/solana/idl`)
-import depositJson from '../../assets/solana/idl/deposit.json';
-import distributionJson from '../../assets/solana/idl/distribution.json';
-import liqSolTokenJson from '../../assets/solana/idl/liq_sol_token.json';
-import stakeControllerJson from '../../assets/solana/idl/stake_controller.json';
-import stakeRegistryJson from '../../assets/solana/idl/stake_registry.json';
-import treasuryJson from '../../assets/solana/idl/treasury.json';
+import liqsolCoreJson from '../../assets/solana/idl/liqsol_core.json';
+import liqsolTokenJson from '../../assets/solana/idl/liqsol_token.json';
 import validatorLeaderboardJson from '../../assets/solana/idl/validator_leaderboard.json';
-import validatorRegistryJson from '../../assets/solana/idl/validator_registry.json';
-import yieldOracleJson from '../../assets/solana/idl/yield_oracle.json';
 
-// 2) import their companion TS types
-import type { Deposit } from '../../assets/solana/types/deposit';
-import type { Distribution } from '../../assets/solana/types/distribution';
-import type { LiqSolToken } from '../../assets/solana/types/liq_sol_token';
-import type { StakeController } from '../../assets/solana/types/stake_controller';
-import type { StakeRegistry } from '../../assets/solana/types/stake_registry';
-import type { Treasury } from '../../assets/solana/types/treasury';
+import type { LiqsolCore } from '../../assets/solana/types/liqsol_core';
+import type { LiqsolToken } from '../../assets/solana/types/liqsol_token';
 import type { ValidatorLeaderboard } from '../../assets/solana/types/validator_leaderboard';
-import type { ValidatorRegistry } from '../../assets/solana/types/validator_registry';
-import type { YieldOracle } from '../../assets/solana/types/yield_oracle';
 
-type IdlEntry<IDL> = {
+import { PROGRAM_IDS } from './constants';
+
+type Entry<IDL> = {
     idl: IDL & { address: string };
-    address: PublicKey;
+    address: string;
 };
 
-export const PROGRAM_IDLS = {
-    deposit: {
-        idl: depositJson,
-        address: new PublicKey(depositJson.address),
-    } as IdlEntry<Deposit>,
-
-    distribution: {
-        idl: distributionJson,
-        address: new PublicKey(distributionJson.address),
-    } as IdlEntry<Distribution>,
-
-    liqSolToken: {
-        idl: liqSolTokenJson,
-        address: new PublicKey(liqSolTokenJson.address),
-    } as IdlEntry<LiqSolToken>,
-
-    stakeController: {
-        idl: stakeControllerJson,
-        address: new PublicKey(stakeControllerJson.address),
-    } as IdlEntry<StakeController>,
-
-    stakeRegistry: {
-        idl: stakeRegistryJson,
-        address: new PublicKey(stakeRegistryJson.address),
-    } as IdlEntry<StakeRegistry>,
-
-    treasury: {
-        idl: treasuryJson,
-        address: new PublicKey(treasuryJson.address),
-    } as IdlEntry<Treasury>,
-
+const PROGRAMS = {
+    liqsolCore: {
+        idl: liqsolCoreJson,
+        address: PROGRAM_IDS.LIQSOL_CORE.toBase58(),
+    } as Entry<LiqsolCore>,
+    liqsolToken: {
+        idl: liqsolTokenJson,
+        address: PROGRAM_IDS.LIQSOL_TOKEN.toBase58(),
+    } as Entry<LiqsolToken>,
     validatorLeaderboard: {
         idl: validatorLeaderboardJson,
-        address: new PublicKey(validatorLeaderboardJson.address),
-    } as IdlEntry<ValidatorLeaderboard>,
-
-    validatorRegistry: {
-        idl: validatorRegistryJson,
-        address: new PublicKey(validatorRegistryJson.address),
-    } as IdlEntry<ValidatorRegistry>,
+        address: PROGRAM_IDS.VALIDATOR_LEADERBOARD.toBase58(),
+    } as Entry<ValidatorLeaderboard>,
+} as const;
 
-    yieldOracle: {
-        idl: yieldOracleJson,
-        address: new PublicKey(yieldOracleJson.address),
-    } as IdlEntry<YieldOracle>,
-};
+export type SolanaProgramName = keyof typeof PROGRAMS;
 
-/**
- * Factory for Anchor Program clients.
- *
- * Anchor v0.28+ reads the program ID from `idl.address`, so
- * we call the 2-arg constructor: `new Program(idl, provider)`.
- */
 export class SolanaProgramService {
     constructor(private provider: AnchorProvider) { }
 
-    /**
-     * Returns a typed Anchor Program instance for the given key.
-     */
-    getProgram<K extends keyof typeof PROGRAM_IDLS>(
-        name: K
-    ): Program<(typeof PROGRAM_IDLS)[K]['idl']> {
-        const entry = PROGRAM_IDLS[name];
-        // stamp the correct address into a fresh copy of the IDL
-        const idlWithAddr = { ...entry.idl, address: entry.address.toString() };
-        // use the two-arg signature: (idl, provider)
-        return new Program(idlWithAddr as any, this.provider) as Program<
-            (typeof PROGRAM_IDLS)[K]['idl']
-        >;
-    }
-
-    /** List all program keys */
-    listProgramNames(): Array<keyof typeof PROGRAM_IDLS> {
-        return Object.keys(PROGRAM_IDLS) as Array<keyof typeof PROGRAM_IDLS>;
+    getProgram<K extends SolanaProgramName>(name: K): Program<(typeof PROGRAMS)[K]['idl']> {
+        const { idl, address } = PROGRAMS[name];
+        const idlWithAddr = { ...idl, address };
+        return new Program(idlWithAddr, this.provider) as Program<(typeof PROGRAMS)[K]['idl']>;
     }
 
-    /** Raw PublicKey of a program */
-    getProgramId(name: keyof typeof PROGRAM_IDLS): PublicKey {
-        return PROGRAM_IDLS[name].address;
+    listProgramNames(): SolanaProgramName[] {
+        return Object.keys(PROGRAMS) as SolanaProgramName[];
     }
 }

package/src/networks/solana/solana.ts

@@ -1,57 +1,69 @@
 import {
+    Commitment,
     Connection,
+    ConnectionConfig,
     PublicKey as SolPubKey,
     Transaction,
-    VersionedTransaction,
     TransactionSignature,
-    Commitment,
 } from '@solana/web3.js';
 import { AnchorProvider } from '@coral-xyz/anchor';
 import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
-import { IStakingClient, SolanaTransaction, StakerConfig } from '../../staker/types';
+import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
+
 import { ChainID, ExternalNetwork, KeyType, PublicKey } from '@wireio/core';
+import { IStakingClient, Portfolio, StakerConfig } from '../../staker/types';
+
 import { DepositClient } from './clients/deposit.client';
 import { DistributionClient } from './clients/distribution.client';
-import { ValidatorLeaderboardClient } from './clients/leaderboard.client';
+import {
+    deriveLiqsolMintPda,
+    deriveReservePoolPda,
+    deriveVaultPda,
+} from './constants';
+import { SolanaTransaction, UserRecord } from './types';
+import { LeaderboardClient } from './clients/leaderboard.client';
 
 const commitment: Commitment = 'confirmed';
 
 export class SolanaStakingClient implements IStakingClient {
     public pubKey: PublicKey;
-    public network: ExternalNetwork;
-
     public connection: Connection;
     public anchor: AnchorProvider;
 
     private depositClient: DepositClient;
     private distributionClient: DistributionClient;
-    private leaderboardClient: ValidatorLeaderboardClient;
-
-    balanceNative: number = 0;
-    balanceLiquid: number = 0;
+    private leaderboardClient: LeaderboardClient;
 
     get solPubKey(): SolPubKey {
         return new SolPubKey(this.pubKey.data.array);
     }
 
+    get network() {
+        return this.config.network;
+    }
+
     constructor(private config: StakerConfig) {
-        // 1) unwrap & validate wallet adapter
         const adapter = config.provider as BaseSignerWalletAdapter;
         if (!adapter.publicKey) {
             throw new Error('Solana wallet adapter not connected');
         }
+        if (!config.network.rpcUrls.length) {
+            throw new Error('No RPC URLs provided');
+        }
 
-        // 2) sanity‐check wire ↔ solana pubkey
         const publicKey = adapter.publicKey;
         const wirePub = new PublicKey(KeyType.ED, publicKey.toBytes());
         if (!wirePub.equals(config.pubKey)) {
-            throw new Error('Passed-in pubKey doesn\'t match adapter.publicKey');
+            throw new Error("Passed-in pubKey doesn't match adapter.publicKey");
+        }
+
+        const opts: ConnectionConfig = { commitment };
+        if (config.network.rpcUrls.length > 1 && config.network.rpcUrls[1].startsWith('ws')) {
+            opts.wsEndpoint = config.network.rpcUrls[1];
         }
 
-        this.network = config.network;
         this.pubKey = wirePub;
-        this.connection = new Connection(config.network.rpcUrls[0], commitment);
-        this.setBalances();
+        this.connection = new Connection(config.network.rpcUrls[0], opts);
 
         const anchorWallet = {
             publicKey,
@@ -63,27 +75,123 @@ export class SolanaStakingClient implements IStakingClient {
             },
         };
 
-        this.anchor = new AnchorProvider(
-            this.connection,
-            anchorWallet,
-            { commitment }
-        );
+        this.anchor = new AnchorProvider(this.connection, anchorWallet, { commitment });
 
-        // 4) staking clients
         this.depositClient = new DepositClient(this.anchor);
         this.distributionClient = new DistributionClient(this.anchor);
-        this.leaderboardClient = new ValidatorLeaderboardClient(this.anchor);
+        this.leaderboardClient = new LeaderboardClient(this.anchor);
     }
 
     /**
-     * Update the native and liquid balances.
-     * @returns The updated balances.
+     * Resolve the user's liqSOL ATA and balances + key protocol balances.
+     * native = SOL in wallet
+     * actual  = liqSOL token balance (from ATA)
+     * tracked = liqSOL tracked balance (from Distribution.userRecord)
      */
-    async setBalances() {
-        this.balanceNative = await this.connection.getBalance(this.solPubKey);
-        this.balanceLiquid = 0; // TODO fetch liq balance
+    async getPortfolio(): Promise<Portfolio> {
+        try {
+            const user = this.solPubKey;
+            const reservePoolPDA = deriveReservePoolPda();
+            const vaultPDA = deriveVaultPda();
+            const liqsolMint = deriveLiqsolMintPda();
+            const userLiqsolAta = getAssociatedTokenAddressSync(
+                liqsolMint,
+                user,
+                false,
+                TOKEN_2022_PROGRAM_ID,
+            );
+
+            const [nativeLamports, actualBalResp, userRecord] = await Promise.all([
+                this.connection.getBalance(user),
+                this.connection.getTokenAccountBalance(userLiqsolAta).catch(() => null),
+                this.distributionClient.getUserRecord(user).catch(() => null),
+            ]);
+
+            const actualAmountStr = actualBalResp?.value?.amount ?? '0';
+            const actualDecimals = actualBalResp?.value?.decimals ?? 9;
+
+            const trackedAmountStr = userRecord?.trackedBalance
+                ? userRecord.trackedBalance.toString()
+                : '0';
+            const trackedDecimals = actualDecimals;
+
+            const portfolio: Portfolio = {
+                native: {
+                    symbol: 'SOL',
+                    decimals: 9,
+                    amount: BigInt(nativeLamports),
+                },
+                actual: {
+                    symbol: 'LiqSOL',
+                    decimals: actualDecimals,
+                    amount: BigInt(actualAmountStr),
+                },
+                tracked: {
+                    symbol: 'LiqSOL',
+                    decimals: trackedDecimals,
+                    amount: BigInt(trackedAmountStr),
+                },
+                extras: {
+                    userLiqsolAta: userLiqsolAta.toBase58(),
+                    reservePoolPDA: reservePoolPDA.toBase58(),
+                    vaultPDA: vaultPDA.toBase58(),
+                },
+            };
+
+            return portfolio;
+        }
+        catch (error) {
+            console.log('Error in getPortfolio:', error);
+            throw error;
+        }
+    }
 
-        return { native: this.balanceNative, liquid: this.balanceLiquid };
+    /**
+     * Optional: fetch your Distribution program user record
+     * (often contains per-user deposit/claim state).
+     * @returns UserRecord or null
+     */
+    async getUserRecord() {
+        return this.distributionClient.getUserRecord(this.solPubKey);
+    }
+
+    getProtocolFee() {
+        // TODO: wire to pay-rate math once we finalize protocol fee API
+    }
+
+    /**
+     * Build, sign, and submit a single transaction that:
+     *  - Corrects other users (if needed) to free available balance, then
+     *  - Registers the caller’s untracked liqSOL.
+     *
+     * @param amount  Optional: register a smaller amount than your full untracked balance.
+     * @returns signature string
+     */
+    async register(amount?: bigint): Promise<string> {
+        try {
+            const build = await this.distributionClient.buildCorrectRegisterTx({ amount });
+            if (!build.canSucceed || !build.transaction) {
+                throw new Error(build.reason ?? 'Unable to build Correct&Register transaction');
+            }
+
+            const { tx, blockhash, lastValidBlockHeight } = await this.prepareTx(build.transaction);
+            const signed = await this.signTransaction(tx);
+            const result = await this.sendAndConfirmHttp(signed, { blockhash, lastValidBlockHeight });
+
+            console.log('Registered:', {
+                needToRegister: build.needToRegister,
+                freed: build.plan.willFree,
+                corrected: build.plan.selected.map((c) => ({
+                    owner: c.owner?.toBase58(),
+                    delta: c.delta?.toString(),
+                })),
+            });
+
+            return result.signature;
+        } catch (error) {
+            console.error('Error in register:', error);
+            throw error;
+        }
     }
 
     /**
@@ -92,19 +200,56 @@ export class SolanaStakingClient implements IStakingClient {
      * @returns The transaction signature.
      */
     async deposit(lamports: number): Promise<string> {
-        const tx = await this.depositClient.buildDepositTx(
-            this.solPubKey,
-            lamports,
+        const { transaction } = await this.depositClient.buildDepositTx(this.solPubKey, lamports);
+        const { tx, blockhash, lastValidBlockHeight } = await this.prepareTx(transaction);
+        const signed = await this.signTransaction(tx);
+        const result = await this.sendAndConfirmHttp(signed, { blockhash, lastValidBlockHeight });
+        return result.signature;
+    }
+
+    private async sendAndConfirmHttp(
+        signed: SolanaTransaction,
+        ctx: { blockhash: string; lastValidBlockHeight: number },
+    ): Promise<TxResult> {
+        const signature = await this.connection.sendRawTransaction(signed.serialize(), {
+            skipPreflight: false,
+            preflightCommitment: commitment,
+            maxRetries: 3,
+        });
+
+        const conf = await this.connection.confirmTransaction(
+            { signature, blockhash: ctx.blockhash, lastValidBlockHeight: ctx.lastValidBlockHeight },
+            commitment,
         );
-        const signed = await this.signTransaction(tx.transaction);
-        return this.sendTransaction(signed);
+
+        const ok = !conf.value.err;
+        if (!ok) {
+            throw new Error(`Transaction failed: ${JSON.stringify(conf.value.err)}`);
+        }
+        return { signature, slot: conf.context.slot, confirmed: true };
     }
 
     async signTransaction(tx: SolanaTransaction): Promise<SolanaTransaction> {
-        return await this.anchor.wallet.signTransaction(tx);
+        return this.anchor.wallet.signTransaction(tx);
     }
 
     async sendTransaction(signed: SolanaTransaction): Promise<TransactionSignature> {
-        return await this.anchor.sendAndConfirm(signed);
+        return this.anchor.sendAndConfirm(signed);
     }
+
+    async prepareTx(
+        tx: Transaction,
+    ): Promise<{ tx: Transaction; blockhash: string; lastValidBlockHeight: number }> {
+        const { blockhash, lastValidBlockHeight } = await this.connection.getLatestBlockhash('confirmed');
+        tx.recentBlockhash = blockhash;
+        tx.feePayer = this.solPubKey;
+
+        return { tx, blockhash, lastValidBlockHeight };
+    }
+}
+
+export interface TxResult {
+    signature: string;
+    slot: number;
+    confirmed: boolean;
 }

package/src/networks/solana/types.ts

@@ -0,0 +1,47 @@
+import { PublicKey, StakeActivationData, TokenAmount, Transaction, VersionedTransaction } from "@solana/web3.js";
+
+export type SolanaTransaction = Transaction | VersionedTransaction
+
+export type UserRecord = {
+    userAta: PublicKey;
+    trackedBalance: bigint;       // What we think they have (for reward calculations)
+    claimBalance: bigint;         // Accumulated unclaimed rewards
+    lastClaimTimestamp: bigint;  // When they last claimed (unix timestamp)
+    bump: number;
+} 
+
+export type DistributionState = {
+    liqsolMint: PublicKey;
+    availableBalance: bigint;
+    totalTrackedBalance: bigint; 
+    bump: number;
+}
+
+export type ParsedAccountInfo = {
+    extensions: Array<{ extension: string }>;
+    isNative: boolean;
+    mint: string;
+    owner: string;
+    state: string;
+    tokenAmount: TokenAmount
+};
+export interface MismatchCandidate {
+    owner: PublicKey;
+    actual: bigint;
+    tracked: bigint;
+    delta: bigint; // tracked - actual
+}
+
+export interface CorrectRegisterPlan {
+    deficit: bigint;
+    willFree: bigint;
+    selected: MismatchCandidate[];
+}
+
+export interface CorrectRegisterBuildResult {
+    needToRegister: boolean;
+    canSucceed: boolean;
+    reason?: string;
+    transaction?: Transaction;
+    plan: CorrectRegisterPlan;
+}