@wireio/stake 2.7.4 → 3.0.0

package/src/networks/solana/solana.ts

@@ -44,6 +44,7 @@ import {
 
 import { ConvertClient } from './clients/convert.client';
 import { DistributionClient } from './clients/distribution.client';
+import { SolanaInstaswapClient } from './clients/instaswap.client';
 import { LeaderboardClient } from './clients/leaderboard.client';
 import { OutpostClient } from './clients/outpost.client';
 import { TokenClient } from './clients/token.client';
@@ -82,6 +83,7 @@ export class SolanaStakingClient implements IStakingClient {
 
     public convertClient: ConvertClient;
     public distributionClient: DistributionClient;
+    public instaswapClient: SolanaInstaswapClient;
     public leaderboardClient: LeaderboardClient;
     public outpostClient: OutpostClient;
     public tokenClient: TokenClient;
@@ -213,6 +215,11 @@ export class SolanaStakingClient implements IStakingClient {
 
         this.convertClient = new ConvertClient(this.anchor, this.program);
         this.distributionClient = new DistributionClient(this.anchor, this.program);
+        this.instaswapClient = new SolanaInstaswapClient(
+            this.anchor,
+            this.program,
+            this.buildAndSendIx.bind(this),
+        );
         this.leaderboardClient = new LeaderboardClient(this.anchor, this.program);
         this.outpostClient = new OutpostClient(this.anchor, this.program);
         this.tokenClient = new TokenClient(this.anchor, this.program);
@@ -232,10 +239,27 @@ export class SolanaStakingClient implements IStakingClient {
             throw new Error('Deposit amount must be greater than zero.');
 
         try {
-            const ix = await this.convertClient.buildDepositTx(amountLamports, this.squadsVaultPDA)
-            return !!this.squadsX
-                ? await this.sendSquadsIxs(ix)
-                : await this.buildAndSendIx(ix)
+            const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+            const submit = async (ix: TransactionInstruction | TransactionInstruction[]) => (
+                !!this.squadsX
+                    ? await this.sendSquadsIxs(ix)
+                    : await this.buildAndSendIx(ix)
+            );
+
+            try {
+                const ix = await this.convertClient.buildDepositTx(amountLamports, user);
+                return await submit(ix);
+            } catch (err) {
+                if (!this.isLegacyUserRecordMigrationRequired(err)) {
+                    throw err;
+                }
+
+                const registerIx = await this.convertClient.buildRegisterUserIx(user);
+                await submit(registerIx);
+
+                const retryIx = await this.convertClient.buildDepositTx(amountLamports, user);
+                return await submit(retryIx);
+            }
 
         } catch (err) {
             console.log(`Failed to deposit Solana: ${err}`);
@@ -299,6 +323,85 @@ export class SolanaStakingClient implements IStakingClient {
         }
     }
 
+    getLiqsolDestinationOwner(owner?: SolPubKey): SolPubKey {
+        return owner ?? this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
+    }
+
+    getLiqsolDestinationAta(owner?: SolPubKey): SolPubKey {
+        const destinationOwner = this.getLiqsolDestinationOwner(owner);
+        const mint = this.program.deriveLiqsolMintPda();
+        return getAssociatedTokenAddressSync(
+            mint,
+            destinationOwner,
+            true,
+            TOKEN_2022_PROGRAM_ID,
+            ASSOCIATED_TOKEN_PROGRAM_ID,
+        );
+    }
+
+    async getLiqsolDestinationAtaState(owner?: SolPubKey): Promise<{
+        owner: SolPubKey;
+        mint: SolPubKey;
+        ata: SolPubKey;
+        exists: boolean;
+    }> {
+        const destinationOwner = this.getLiqsolDestinationOwner(owner);
+        const mint = this.program.deriveLiqsolMintPda();
+        const ata = this.getLiqsolDestinationAta(destinationOwner);
+        const accountInfo = await this.connection.getAccountInfo(ata, 'confirmed');
+
+        return {
+            owner: destinationOwner,
+            mint,
+            ata,
+            exists: !!accountInfo,
+        };
+    }
+
+    async maybeBuildCreateLiqsolDestinationAtaIx(
+        owner?: SolPubKey,
+    ): Promise<TransactionInstruction | null> {
+        const state = await this.getLiqsolDestinationAtaState(owner);
+        if (state.exists) {
+            return null;
+        }
+
+        return createAssociatedTokenAccountInstruction(
+            this.feePayer,
+            state.ata,
+            state.owner,
+            state.mint,
+            TOKEN_2022_PROGRAM_ID,
+            ASSOCIATED_TOKEN_PROGRAM_ID,
+        );
+    }
+
+    async ensureLiqsolDestinationAta(owner?: SolPubKey): Promise<string | null> {
+        this.ensureUser();
+        const createAtaIx = await this.maybeBuildCreateLiqsolDestinationAtaIx(owner);
+        if (!createAtaIx) {
+            return null;
+        }
+
+        try {
+            return await this.buildAndSendIx(createAtaIx);
+        } catch (error) {
+            if (!this.isAtaAlreadyCreatedError(error)) {
+                throw error;
+            }
+            return null;
+        }
+    }
+
+    private async prependLiqsolDestinationAtaIx(
+        ix: TransactionInstruction | TransactionInstruction[],
+        owner?: SolPubKey,
+    ): Promise<TransactionInstruction[]> {
+        const ixs = Array.isArray(ix) ? [...ix] : [ix];
+        const createAtaIx = await this.maybeBuildCreateLiqsolDestinationAtaIx(owner);
+        return createAtaIx ? [createAtaIx, ...ixs] : ixs;
+    }
+
     /**
      * Claim accrued liqSOL distribution rewards (liqsol_core::claim_rewards).
      */
@@ -308,9 +411,10 @@ export class SolanaStakingClient implements IStakingClient {
 
         try {
             const ix = await this.distributionClient.buildClaimRewardsIx(owner);
+            const ixs = await this.prependLiqsolDestinationAtaIx(ix, owner);
             return !!this.squadsX
-                ? await this.sendSquadsIxs(ix)
-                : await this.buildAndSendIx(ix);
+                ? await this.sendSquadsIxs(ixs)
+                : await this.buildAndSendIx(ixs);
         } catch (err) {
             console.log(`Failed to claim liqSOL rewards on Solana: ${err}`);
             throw err;
@@ -320,13 +424,17 @@ export class SolanaStakingClient implements IStakingClient {
     /**
      * Stake liqSOL into Outpost (liqSOL → pool) via liqsol_core::synd.
      */
-    async stake(amountLamports: bigint): Promise<string> {
+    async stake(amountLamports: bigint, wireAccount?: string): Promise<string> {
         this.ensureUser();
         if (!amountLamports || amountLamports <= BigInt(0))
             throw new Error('Stake amount must be greater than zero.');
 
         try {
-            const ix = await this.outpostClient.buildStakeIx(amountLamports, this.squadsVaultPDA)
+            const ix = await this.outpostClient.buildStakeIx(
+                amountLamports,
+                this.squadsVaultPDA,
+                wireAccount,
+            )
             return !!this.squadsX
                 ? await this.sendSquadsIxs(ix)
                 : await this.buildAndSendIx(ix)
@@ -346,10 +454,12 @@ export class SolanaStakingClient implements IStakingClient {
             throw new Error('Unstake amount must be greater than zero.');
 
         try {
+            const owner = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
             const ix = await this.outpostClient.buildUnstakeIx(amountLamports, this.squadsVaultPDA)
+            const ixs = await this.prependLiqsolDestinationAtaIx(ix, owner);
             return !!this.squadsX
-                ? await this.sendSquadsIxs(ix)
-                : await this.buildAndSendIx(ix)
+                ? await this.sendSquadsIxs(ixs)
+                : await this.buildAndSendIx(ixs)
         }
         catch (err) {
             console.log(`Failed to unstake Solana: ${err}`);
@@ -381,7 +491,7 @@ export class SolanaStakingClient implements IStakingClient {
     }
 
     /** Deposit SOL to liqSOL, then syndicate that liqSOL in one transaction. Requires enough SOL for the deposit fee. */
-    async depositAndStake(amountLamports: bigint): Promise<string> {
+    async depositAndStake(amountLamports: bigint, wireAccount?: string): Promise<string> {
         this.ensureUser();
         if (!amountLamports || amountLamports <= BigInt(0))
             throw new Error('Amount must be greater than zero.');
@@ -389,7 +499,11 @@ export class SolanaStakingClient implements IStakingClient {
         try {
             const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
             const depositIx = await this.convertClient.buildDepositTx(amountLamports, user);
-            const stakeIx = await this.outpostClient.buildStakeIx(amountLamports, user);
+            const stakeIx = await this.outpostClient.buildStakeIx(
+                amountLamports,
+                user,
+                wireAccount,
+            );
 
             return !!this.squadsX
                 ? await this.sendSquadsIxs([depositIx, stakeIx])
@@ -430,10 +544,11 @@ export class SolanaStakingClient implements IStakingClient {
             const user = this.squadsVaultPDA ?? this.anchor.wallet.publicKey;
             const unstakeIx = await this.outpostClient.buildUnstakeIx(amountLamports, user);
             const withdrawIx = await this.convertClient.buildWithdrawTx(amountLamports, user);
+            const ixs = await this.prependLiqsolDestinationAtaIx([unstakeIx, withdrawIx], user);
 
             return !!this.squadsX
-                ? await this.sendSquadsIxs([unstakeIx, withdrawIx])
-                : await this.buildAndSendIx([unstakeIx, withdrawIx]);
+                ? await this.sendSquadsIxs(ixs)
+                : await this.buildAndSendIx(ixs);
         } catch (err) {
             console.log(`Failed to unstake and withdraw: ${err}`);
             throw err;
@@ -857,6 +972,21 @@ export class SolanaStakingClient implements IStakingClient {
         // }
     }
 
+    private isLegacyUserRecordMigrationRequired(error: unknown): boolean {
+        const message = error instanceof Error ? error.message : String(error ?? '');
+        const normalized = message.toLowerCase();
+        return normalized.includes('legacyuserrecordmigrationrequired')
+            || normalized.includes('legacy user record must be migrated')
+            || normalized.includes('custom program error: 0x1784');
+    }
+
+    private isAtaAlreadyCreatedError(error: unknown): boolean {
+        const message = error instanceof Error ? error.message : String(error ?? '');
+        const normalized = message.toLowerCase();
+        return normalized.includes('already in use')
+            || normalized.includes('already exists');
+    }
+
     // ---------------------------------------------------------------------
     // READ-ONLY Public Methods
     // ---------------------------------------------------------------------
@@ -924,7 +1054,7 @@ export class SolanaStakingClient implements IStakingClient {
      * de-scaled using PAY_RATE_SCALE_FACTOR (1e12).
      */
     private async getEpochRateDecimalFromProgram(): Promise<number> {
-        const liqSolCoreProgram = this.program.getProgram('liqsolCore');
+        const liqSolCoreProgram: any = this.program.getProgram('liqsolCore');
         const payRateHistoryPda = this.program.derivePayRateHistoryPda();
 
         const payRateHistory =

package/src/networks/solana/types.ts

@@ -644,11 +644,10 @@ export type LeaderboardState = {
     bump: number; // u8 on-chain
 
     /**
-     * !DEPRECATED - to be removed
      * Reserved padding / future-proofing on-chain (u64[8]).
      * Not used by client logic, but surfaced for completeness.
      */
-    // padding: number[];
+    padding: number[];
 };
 
 /**

package/src/networks/solana/utils.ts

@@ -1,5 +1,4 @@
 import { Program, BN, AnchorProvider } from '@coral-xyz/anchor';
-
 import {
     Connection,
     Keypair,
@@ -19,7 +18,6 @@ import {
     CHAINLINK_PROGRAM,
 } from './constants';
 
-import { LiqsolCore } from '../../assets/solana/devnet/types/liqsol_core';
 import { GlobalState, TrancheState } from './types';
 import { TrancheLadderItem, TrancheSnapshot } from '../../types';
 import { ChainID } from '@wireio/core';
@@ -281,6 +279,15 @@ export interface OutpostAccounts {
 
     // New
     pretokenPurchaseHistory: PublicKey;
+
+    // OPP (outpost protocol pipeline)
+    globalConfig: PublicKey;
+    oppEpochState: PublicKey;
+    pendingAttestations: PublicKey;
+    bridgeState: PublicKey;
+    bridgeAuthority: PublicKey;
+    bridgeVaultAta: PublicKey;
+    bridgeUserRecord: PublicKey;
 }
 
 export async function buildOutpostAccounts(
@@ -330,12 +337,30 @@ export async function buildOutpostAccounts(
 
     const pretokenPurchaseHistory = pgs.derivePretokenPurchaseHistoryPda(poolAuthority);
 
+    // OPP (outpost protocol pipeline)
+    const globalConfig = pgs.deriveGlobalConfigPda();
+    const oppEpochState = pgs.deriveOppEpochStatePda();
+    const epochNumber = await pgs.fetchOppEpochNumber(connection);
+    const pendingAttestations = pgs.derivePendingAttestationsPda(epochNumber);
+    const bridgeState = pgs.deriveOppBridgeStatePda();
+    const bridgeAuthority = PublicKey.findProgramAddressSync(
+        [Buffer.from('opp_bridge_vault')],
+        pgs.PROGRAM_IDS.LIQSOL_CORE,
+    )[0];
+    const bridgeVaultAta = await getAssociatedTokenAddress(
+        liqsolMint,
+        bridgeAuthority,
+        true,
+        TOKEN_2022_PROGRAM_ID,
+    );
+    const bridgeUserRecord = pgs.deriveUserRecordPda(bridgeVaultAta);
+
     // Chainlink program feeds
     let chainLinkFeed = CHAINLINK_FEED;
     let chainLinkProgram = CHAINLINK_PROGRAM;
 
     try {
-        const program = pgs.getProgram('liqsolCore');
+        const program: any = pgs.getProgram('liqsolCore');
         const ts: TrancheState =
             await program.account.trancheState.fetch(trancheState);
 
@@ -371,7 +396,14 @@ export async function buildOutpostAccounts(
         chainLinkFeed,
         chainLinkProgram,
         extraAccountMetaList,
-        pretokenPurchaseHistory
+        pretokenPurchaseHistory,
+        globalConfig,
+        oppEpochState,
+        pendingAttestations,
+        bridgeState,
+        bridgeAuthority,
+        bridgeVaultAta,
+        bridgeUserRecord,
     };
 }
 // -----------------------------------------------------------------------------

package/src/staker.ts

@@ -1,9 +1,8 @@
-// src/staker/staker.ts
-
-import { ChainID, EvmChainID, SolChainID } from '@wireio/core';
+import { ChainID } from '@wireio/core';
+import { getSdkChainConfig } from './chains';
 import { IStakingClient, StakerConfig } from './types';
 import { SolanaStakingClient } from './networks/solana/solana';
-import { EthereumStakingClient } from './networks/ethereum/ethereum';
+import { EvmStakingClient } from './networks/evm/evm';
 
 export class Staker {
     public selectedChainID?: ChainID;
@@ -32,24 +31,27 @@ export class Staker {
         if (!config) throw new Error('StakerConfig is required');
         if (!Array.isArray(config)) config = [config];
 
-        // console.log('STAKER INIT', config);
-
         config.forEach((cfg) => {
-            switch (cfg.network.chainId) {
-                case SolChainID.Mainnet:
-                case SolChainID.Devnet:
-                    this.clients.set(cfg.network.chainId, new SolanaStakingClient(cfg));
-                    break;
+            const chain = getSdkChainConfig(cfg.network.chainId);
+            if (!chain) {
+                throw new Error(`Unsupported SDK chain: ${cfg.network.name} (${cfg.network.chainId})`);
+            }
 
-                case EvmChainID.Ethereum:
-                case EvmChainID.Hoodi:
-                    this.clients.set(cfg.network.chainId, new EthereumStakingClient(cfg));
-                    break;
+            if (!chain.capabilities.staking) {
+                return;
+            }
 
-                default:
-                    console.log(`No staking client available for chain ${cfg.network.chainId}`);
-                    throw new Error(`Unsupported network curve: ${cfg.network.name}`);
+            if (chain.family === 'solana') {
+                this.clients.set(cfg.network.chainId, new SolanaStakingClient(cfg));
+                return;
             }
+
+            if (chain.family === 'evm') {
+                this.clients.set(cfg.network.chainId, new EvmStakingClient(cfg));
+                return;
+            }
+
+            throw new Error(`Unsupported SDK chain family: ${chain.family}`);
         });
 
         this.selectedChainID = selectedChainID;
@@ -61,13 +63,13 @@ export class Staker {
      */
     setChain(chainID: ChainID): boolean {
         const hasClient = this.clients.has(chainID);
+        this.selectedChainID = chainID;
 
         if (!hasClient) {
             console.warn(`[Staker] setChain: no client configured for chain ${chainID}`);
             return false;
         }
 
-        this.selectedChainID = chainID;
         return true;
     }
-}
+}