@wireio/stake 0.0.1

package/src/networks/solana/program.ts

@@ -0,0 +1,113 @@
+// 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 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 { 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> = {
+    idl: IDL & { address: string };
+    address: PublicKey;
+};
+
+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>,
+
+    validatorLeaderboard: {
+        idl: validatorLeaderboardJson,
+        address: new PublicKey(validatorLeaderboardJson.address),
+    } as IdlEntry<ValidatorLeaderboard>,
+
+    validatorRegistry: {
+        idl: validatorRegistryJson,
+        address: new PublicKey(validatorRegistryJson.address),
+    } as IdlEntry<ValidatorRegistry>,
+
+    yieldOracle: {
+        idl: yieldOracleJson,
+        address: new PublicKey(yieldOracleJson.address),
+    } as IdlEntry<YieldOracle>,
+};
+
+/**
+ * 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>;
+    }
+
+    /** Raw PublicKey of a program */
+    getProgramId(name: keyof typeof PROGRAM_IDLS): PublicKey {
+        return PROGRAM_IDLS[name].address;
+    }
+}

package/src/networks/solana/solana.ts

@@ -0,0 +1,84 @@
+import {
+    Connection,
+    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 { KeyType, PublicKey } from '@wireio/core';
+import { DepositClient } from './clients/deposit.client';
+import { DistributionClient } from './clients/distribution.client';
+import { ValidatorLeaderboardClient } from './clients/leaderboard.client';
+
+const commitment: Commitment = 'confirmed';
+
+export class SolanaStakingClient implements IStakingClient {
+    public pubKey: PublicKey;
+    
+    private connection: Connection;
+    private anchorProvider: AnchorProvider;
+
+    private depositClient: DepositClient;
+    private distributionClient: DistributionClient;
+    private leaderboardClient: ValidatorLeaderboardClient;
+
+    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');
+        }
+
+        // 2) sanity‐check wire ↔ solana pubkey
+        const solPub = adapter.publicKey;
+        const wirePub = new PublicKey(KeyType.ED, solPub.toBytes());
+        if (!wirePub.equals(config.pubKey)) {
+            throw new Error('Passed-in pubKey doesn’t match adapter.publicKey');
+        }
+        
+        this.pubKey = wirePub;
+        this.connection = new Connection(config.network.rpcUrls[0], commitment);
+
+        const anchorWallet = {
+            publicKey: solPub,
+            async signTransaction<T extends SolanaTransaction>(tx: T): Promise<T> {
+                return adapter.signTransaction(tx);
+            },
+            async signAllTransactions<T extends SolanaTransaction>(txs: T[]): Promise<T[]> {
+                return Promise.all(txs.map((tx) => adapter.signTransaction(tx)));
+            },
+        };
+
+        this.anchorProvider = new AnchorProvider(
+            this.connection,
+            anchorWallet,
+            { commitment }
+        );
+
+        // 4) staking clients
+        this.depositClient = new DepositClient(this.anchorProvider);
+        this.distributionClient = new DistributionClient(this.anchorProvider);
+        this.leaderboardClient = new ValidatorLeaderboardClient(this.anchorProvider);
+    }
+
+    async deposit(amount: number): Promise<string> {
+        const tx = await this.depositClient.buildDepositTx(
+            new SolPubKey(this.pubKey.data.array),
+            amount,
+        );
+        const signed = await this.signTransaction(tx.transaction);
+        return this.sendTransaction(signed);
+    }
+
+    async signTransaction(tx: SolanaTransaction): Promise<SolanaTransaction> {
+        return await this.anchorProvider.wallet.signTransaction(tx);
+    }
+
+    async sendTransaction(signed: SolanaTransaction): Promise<TransactionSignature> {
+        return await this.anchorProvider.sendAndConfirm(signed);
+    }
+}

package/src/networks/solana/utils.ts

@@ -0,0 +1,122 @@
+// src/solana/utils.ts
+import { AnchorProvider, Program } from '@coral-xyz/anchor'
+import { PublicKey } from '@solana/web3.js'
+import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import {
+    DEPOSIT_PROGRAM_ID,
+    DISTRIBUTION_PROGRAM_ID,
+    STAKE_CONTROLLER_PROGRAM_ID,
+    VALIDATOR_LEADERBOARD_PROGRAM_ID,
+    LIQSOL_MINT_ADDRESS,
+    DepositIDL,
+    Deposit
+} from './constants'
+
+// -- Program factories ------------------------------------------------------
+/**
+ * Create an Anchor Program client for the Deposit program
+ */
+export function getDepositProgram(provider: AnchorProvider): Program<Deposit> {
+    // Ensure the IDL has the correct program address
+    const idlWithAddress = {
+        ...JSON.parse(JSON.stringify(DepositIDL)),
+        address: DEPOSIT_PROGRAM_ID.toString(),
+    }
+    return new Program(idlWithAddress as any, provider) as Program<Deposit>
+}
+
+// (Other program factories can go here if needed)
+
+// -- PDA derivation helpers ------------------------------------------------
+export function deriveDepositAuthorityPDA(
+    programId: PublicKey = DEPOSIT_PROGRAM_ID
+): [PublicKey, number] {
+    return PublicKey.findProgramAddressSync(
+        [Buffer.from('program_authority')],
+        programId
+    )
+}
+
+export function deriveLiqsolMintAuthorityPDA(
+    programId: PublicKey = LIQSOL_MINT_ADDRESS
+): [PublicKey, number] {
+    return PublicKey.findProgramAddressSync(
+        [Buffer.from('mint_authority')],
+        programId
+    )
+}
+
+export function deriveStakeControllerVaultPDA(): [PublicKey, number] {
+    return PublicKey.findProgramAddressSync(
+        [Buffer.from('vault')],
+        STAKE_CONTROLLER_PROGRAM_ID
+    )
+}
+
+export function deriveStakeControllerReservePoolPDA(): [PublicKey, number] {
+    return PublicKey.findProgramAddressSync(
+        [Buffer.from('reserve_pool')],
+        STAKE_CONTROLLER_PROGRAM_ID
+    )
+}
+
+export function deriveStakeControllerStatePDA(): [PublicKey, number] {
+    return PublicKey.findProgramAddressSync(
+        [Buffer.from('stake_controller')],
+        STAKE_CONTROLLER_PROGRAM_ID
+    )
+}
+
+export function deriveDistributionStatePDA(): [PublicKey, number] {
+    return PublicKey.findProgramAddressSync(
+        [Buffer.from('distribution_state')],
+        DISTRIBUTION_PROGRAM_ID
+    )
+}
+
+export function deriveUserRecordPDA(
+    user: PublicKey
+): [PublicKey, number] {
+    return PublicKey.findProgramAddressSync(
+        [Buffer.from('user_record'), user.toBuffer()],
+        DISTRIBUTION_PROGRAM_ID
+    )
+}
+
+export function deriveLeaderboardHeadPDA(): [PublicKey, number] {
+    return PublicKey.findProgramAddressSync(
+        [Buffer.from('leaderboard_head')],
+        VALIDATOR_LEADERBOARD_PROGRAM_ID
+    )
+}
+
+export function deriveValidatorRecordPDA(
+    voteAccount: PublicKey
+): [PublicKey, number] {
+    return PublicKey.findProgramAddressSync(
+        [Buffer.from('validator_record'), voteAccount.toBuffer()],
+        VALIDATOR_LEADERBOARD_PROGRAM_ID
+    )
+}
+
+export function deriveTop10CachePDA(): [PublicKey, number] {
+    return PublicKey.findProgramAddressSync(
+        [Buffer.from('top_10_cache')],
+        VALIDATOR_LEADERBOARD_PROGRAM_ID
+    )
+}
+
+// -- SPL Token helper -------------------------------------------------------
+export function getUserLiqsolATA(
+    user: PublicKey
+): PublicKey {
+    return getAssociatedTokenAddressSync(
+        LIQSOL_MINT_ADDRESS,
+        user,
+        false,
+        TOKEN_2022_PROGRAM_ID,
+        ASSOCIATED_TOKEN_PROGRAM_ID
+    )
+}
+
+// seedToPID(seed: string): PublicKey 

package/src/staker/staker.ts

@@ -0,0 +1,38 @@
+// src/staker/staker.ts
+
+import { ChainID, Curve, EvmChainID, SolChainID } from '@wireio/core';
+import { IStakingClient, StakerConfig } from './types';
+import { SolanaStakingClient } from '../networks/solana/solana';
+import { EthereumStakingClient } from '../networks/ethereum/ethereum';
+
+export class Staker {
+    private clients: Map<ChainID, IStakingClient> = new Map();
+
+    constructor(config: StakerConfig | StakerConfig[]) {
+        if (!Array.isArray(config)) config = [config];
+
+        config.forEach((cfg) => {
+            switch (cfg.network.chainId) {
+                case SolChainID.Testnet:
+                    this.clients.set(SolChainID.Testnet, new SolanaStakingClient(cfg));
+                    break;
+
+                // case EvmChainID.Sepolia:
+                //     this.clients.set(EvmChainID.Sepolia, new EthereumStakingClient(cfg));
+                //     break;
+            default:
+                throw new Error(`Unsupported network curve: ${cfg.network.name}`);
+
+            }
+        });
+    }
+
+    deposit(amount: number): Promise<string> {
+        if (!this.clients.has(SolChainID.Testnet)) {
+            throw new Error('Staker not initialized for Solana Testnet');
+        }
+        return this.clients.get(SolChainID.Testnet)!.deposit(amount);
+    }
+
+    // …withdraw, claimRewards, etc…
+}

package/src/staker/types.ts

@@ -0,0 +1,26 @@
+// types.ts
+
+import { BaseSignerWalletAdapter } from '@solana/wallet-adapter-base';
+import { Transaction, VersionedTransaction } from '@solana/web3.js';
+import { Curve, ExternalNetwork, ProviderType, PublicKey } from '@wireio/core';
+import { ethers } from 'ethers';
+
+export type SolanaTransaction = Transaction | VersionedTransaction
+export interface IStakingClient{
+    pubKey: PublicKey;
+
+    deposit(amount: number): Promise<string>;
+    // TODO add more shared functions to implement 
+
+    // signTransaction<T, R>(tx: T): Promise<R>;
+    // sendTransaction<T, R>(signed: T): Promise<R>;
+}
+
+/**
+ * Union config for our unified Staker
+ */
+export type StakerConfig = {
+    network: ExternalNetwork;
+    provider: BaseSignerWalletAdapter | ethers.providers.Web3Provider;
+    pubKey: PublicKey;
+}

package/src/utils.ts

@@ -0,0 +1,9 @@
+/**
+ * Static utility functions for working with Wire Network Staking Protocol.
+ * 
+ * @module utils
+ */
+
+export const hi = (name: string): string => {
+    return `Hello, ${name}!`;
+}