Démonstrations de code pour Farm / Staking

import { Connection, Keypair, clusterApiUrl, PublicKey } from "@solana/web3.js";
import { Raydium, TxVersion } from "@raydium-io/raydium-sdk-v2";
import BN from "bn.js";
import fs from "node:fs";

const connection = new Connection(process.env.RPC_URL ?? clusterApiUrl("mainnet-beta"));
const owner = Keypair.fromSecretKey(
  new Uint8Array(JSON.parse(fs.readFileSync(process.env.KEYPAIR!, "utf8"))),
);
const raydium = await Raydium.load({
  owner,
  connection,
  cluster: "mainnet",
  disableFeatureCheck: true,
  blockhashCommitment: "finalized",
});
export const txVersion = TxVersion.V0;

const farmId = "CHYrUBX2RKX8iBg7gYTkccoGNBzP44LdaazMHCLcdEgS"; // RAY-USDC farm

const farmInfo = (await raydium.api.fetchFarmInfoById({ ids: farmId }))[0];
if (!farmInfo) throw new Error("farm not found");

console.log("LP mint:", farmInfo.lpMint.address);
console.log("TVL:", farmInfo.tvl);
for (const r of farmInfo.rewardInfos) {
  console.log("  -", r.mint.address, r.mint.symbol);
}

// La démo stake le solde LP entier du portefeuille ; tout BN en unités brutes fonctionne.
const amount = raydium.account.tokenAccountRawInfos.find(
  (a) => a.accountInfo.mint.toBase58() === farmInfo.lpMint.address,
)?.accountInfo.amount;

if (!amount || amount.isZero()) throw new Error("user does not have an LP balance");

const { execute } = await raydium.farm.deposit({
  farmInfo,
  amount,
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Deposit tx:", txId);

const farmIds = [farmId, "<ANOTHER_FARM_ID>"];
const farmInfos = await raydium.api.fetchFarmInfoById({ ids: farmIds.join(",") });

const { execute } = await raydium.farm.harvestAllRewards({
  farmInfoList: Object.fromEntries(farmInfos.map((f) => [f.id, f])),
  txVersion: TxVersion.V0,
});

const { txIds } = await execute({ sequentially: true });
console.log("harvest txs:", txIds);

const { execute } = await raydium.farm.withdraw({
  farmInfo,
  amount: new BN(0),        // 0 = harvest-only path
  txVersion: TxVersion.V0,
});
await execute({ sendAndConfirm: true });

const amount = new BN(500_000_000);   // 0.5 LP, raw units

const { execute } = await raydium.farm.withdraw({
  farmInfo,
  amount,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

import type { ApiV3PoolInfoStandardItem, FarmRewardInfo } from "@raydium-io/raydium-sdk-v2";
import { RAYMint } from "@raydium-io/raydium-sdk-v2";

// Le pool que vous possédez dont le mint LP sera le mint de staking.
const poolInfo = (
  await raydium.api.fetchPoolById({ ids: "<POOL_ID>" })
)[0] as ApiV3PoolInfoStandardItem;
if (!poolInfo) throw new Error("pool not found");

const rewardMint = await raydium.token.getTokenInfo(RAYMint);

// Utilisez l'heure de la chaîne, pas l'heure murale — le programme valide par rapport à la première.
const openTime = Math.floor((await raydium.currentBlockChainTime()) / 1000);
const endTime  = openTime + 60 * 60 * 24 * 7; // 7 days

const rewardInfos: FarmRewardInfo[] = [
  {
    mint:       new PublicKey(rewardMint.address),
    perSecond:  "1",              // string, in raw units per second
    openTime,                      // seconds, not BN
    endTime,
    rewardType: "Standard SPL",   // "Option tokens" is the only other value
  },
];

const { execute, extInfo } = await raydium.farm.create({
  poolInfo,
  rewardInfos,
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Farm:", extInfo.farmId.toBase58(), "createTx:", txId);

import { USDCMint } from "@raydium-io/raydium-sdk-v2";

const added = await raydium.token.getTokenInfo(USDCMint);
const openTime = Math.floor((await raydium.currentBlockChainTime()) / 1000);

const { execute } = await raydium.farm.addNewRewardsToken({
  farmInfo,
  newRewardInfos: [
    {
      mint:       new PublicKey(added.address),
      perSecond:  "1",
      openTime,
      endTime:    openTime + 60 * 60 * 24 * 7,
      rewardType: "Standard SPL",
    },
  ],
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

import type { FarmRewardInfo } from "@raydium-io/raydium-sdk-v2";

// Réarmez le slot de récompense existant en premier de la farm.
const existing = await raydium.token.getTokenInfo(farmInfo.rewardInfos[0].mint.address);
const openTime = Math.floor((await raydium.currentBlockChainTime()) / 1000);

const newRewardInfos: FarmRewardInfo[] = [
  {
    mint:       new PublicKey(existing.address),
    perSecond:  "1",
    openTime,
    endTime:    openTime + 60 * 60 * 24 * 14,
    rewardType: "Standard SPL",
  },
];

const { execute } = await raydium.farm.restartRewards({
  farmInfo,
  newRewardInfos,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });