Delegate LAYER

import { BridgeClient, Chain } from "@solayer-labs/bridge-sdk";
import {
  Connection, Keypair, PublicKey, sendAndConfirmTransaction,
} from "@solana/web3.js";
import { getAssociatedTokenAddressSync } from "@solana/spl-token";
import * as anchor from "@coral-xyz/anchor";

const l1 = new Connection("https://api.devnet.solana.com", "confirmed");

// Your wallet (load from file in real usage; same pubkey is your L2 address).
const wallet = Keypair.fromSecretKey(/* ... */);

// Wrapped LAYER mint on L1 (devnet). This is what gets burned.
const L1_WRAPPED_LAYER = new PublicKey(
  "CJYj22nRQ7uQAV6Rmvn4sy2NduBiFwLNqdqkmH6hWDEF",
);

const bridge = new BridgeClient({
  connection: l1,
  userPublicKey: wallet.publicKey,
  chain: Chain.Solana,                  // bridging FROM Solana
  commitment: "confirmed",
});

const params = {
  bridgeProofNonce: new anchor.BN(Date.now()),   // any unique nonce
  amount: new anchor.BN(1_000_000_000),          // base units — respect decimals
  recipient: wallet.publicKey,                   // who receives on L2 (you)
  additionalSolGas: new anchor.BN(5_000_000),    // optional: seed ~0.005 SOL on L2
};

const accounts = {
  mint: L1_WRAPPED_LAYER,
  signerVault: getAssociatedTokenAddressSync(L1_WRAPPED_LAYER, wallet.publicKey),
};

const tx = await bridge.createBridgeAssetSourceChainTransaction(params, accounts);
const l1Sig = await sendAndConfirmTransaction(l1, tx, [wallet]);
console.log("L1 bridge tx:", l1Sig);

import { getTargetChainBridgeTxIdFromSourceTxId } from "@solayer-labs/bridge-sdk";

const l2 = new Connection("https://devnet-rpc.solayer.org", "confirmed");

let l2Sig: string | null = null;
while (!l2Sig) {
  l2Sig = await getTargetChainBridgeTxIdFromSourceTxId(l1Sig, Chain.Solana, l2);
  if (!l2Sig) await new Promise((r) => setTimeout(r, 3000));
}
console.log("Bridged! L2 completion tx:", l2Sig);

import { getAssociatedTokenAddressSync, getAccount } from "@solana/spl-token";

// Native LAYER mint on the L2 (devnet). Once the staking program is
// initialized, read the canonical value from Config.stake_mint instead.
const L2_LAYER_MINT = new PublicKey(
  "LAYER4xPpTCb3QL8S9u41EAhAX7mhBn8Q6xMTwY2Yzc",
);

const l2Ata = getAssociatedTokenAddressSync(L2_LAYER_MINT, wallet.publicKey);
console.log("Balance:", (await getAccount(l2, l2Ata)).amount.toString());
// The mint you received MUST equal Config.stake_mint. If not, you
// bridged the wrong token and cannot stake it.

import * as anchor from "@coral-xyz/anchor";
import { Connection, Keypair, PublicKey, SystemProgram } from "@solana/web3.js";
import {
  TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync,
} from "@solana/spl-token";
import IDL from "./infini_stake.json"; // download: /documentation/staking/infini_stake.json

const STAKE_PROGRAM_ID = new PublicKey(
  "mi7DC6qnESgL6TWdQn7xJBKqWwv2YiZVeoVuhpXhLvz",
);
const l2 = new Connection("https://devnet-rpc.solayer.org", "confirmed");

const wallet = new anchor.Wallet(Keypair.fromSecretKey(/* ... */));
const provider = new anchor.AnchorProvider(l2, wallet, { commitment: "confirmed" });

// infini-stake is built with Anchor v2: the program ID comes from the IDL's
// `address` field, so the constructor takes (idl, provider). On older Anchor
// (0.29) use `new anchor.Program(IDL, STAKE_PROGRAM_ID, provider)` instead.
const program = new anchor.Program(IDL as anchor.Idl, provider);

const me = wallet.publicKey;

// --- PDAs ---
const [configPda] = PublicKey.findProgramAddressSync(
  [Buffer.from("config")], STAKE_PROGRAM_ID);

const validatorPda = (identity: PublicKey) =>
  PublicKey.findProgramAddressSync(
    [Buffer.from("validator"), identity.toBuffer()], STAKE_PROGRAM_ID)[0];

const delegationPda = (owner: PublicKey, identity: PublicKey) =>
  PublicKey.findProgramAddressSync(
    [Buffer.from("delegation"), owner.toBuffer(), identity.toBuffer()],
    STAKE_PROGRAM_ID)[0];

// Read config to learn the stake mint + vault (don't hardcode).
const config = await program.account.config.fetch(configPda);
const stakeMint = config.stakeMint as PublicKey;
const stakeVault = config.stakeVault as PublicKey; // = ATA(configPda, stakeMint)
const myAta = getAssociatedTokenAddressSync(stakeMint, me);

const VALIDATOR_IDENTITY = new PublicKey("<validator identity pubkey>"); // TBD

const amount = new anchor.BN(1_000_000_000); // base units; must be > 0

await program.methods
  .delegate(amount)
  .accounts({
    config: configPda,
    validator: validatorPda(VALIDATOR_IDENTITY),
    delegation: delegationPda(me, VALIDATOR_IDENTITY),
    ownerTokenAccount: myAta,
    stakeVault,
    stakeMint,
    owner: me,
    systemProgram: SystemProgram.programId,
    tokenProgram: TOKEN_PROGRAM_ID,
  })
  .rpc();

await program.methods
  .claimRewards()
  .accounts({
    config: configPda,
    validator: validatorPda(VALIDATOR_IDENTITY),
    delegation: delegationPda(me, VALIDATOR_IDENTITY),
    ownerTokenAccount: myAta,
    stakeMint,
    owner: me,
    tokenProgram: TOKEN_PROGRAM_ID,
  })
  .rpc();

const unstakeAmount = new anchor.BN(500_000_000); // ≤ delegation.amount

await program.methods
  .requestUnstake(unstakeAmount)
  .accounts({
    config: configPda,
    validator: validatorPda(VALIDATOR_IDENTITY),
    delegation: delegationPda(me, VALIDATOR_IDENTITY),
    ownerTokenAccount: myAta,
    stakeMint,
    owner: me,
    tokenProgram: TOKEN_PROGRAM_ID,
  })
  .rpc();

await program.methods
  .completeUnstake()
  .accounts({
    config: configPda,
    delegation: delegationPda(me, VALIDATOR_IDENTITY),
    stakeVault,
    ownerTokenAccount: myAta,
    owner: me,
    tokenProgram: TOKEN_PROGRAM_ID,
  })
  .rpc();

// Global config — APY, cooldown, the canonical stake mint/vault, totals.
const config = await program.account.config.fetch(configPda);
console.log("APY (bps):", config.apyBps);
console.log("Cooldown (s):", config.cooldownSeconds.toString());
console.log("Stake mint:", config.stakeMint.toBase58());
// ↑ the native L2 LAYER mint — the token you hold/received must equal it
console.log("Total active stake:", config.totalActiveStake.toString());

// A validator — is it active, its commission, how much is delegated to it.
const v = await program.account.validator.fetch(validatorPda(VALIDATOR_IDENTITY));
console.log("Validator active:", v.active, "total stake:", v.totalStake.toString());
console.log("Commission (bps):", v.commissionBps); // effective APY = apy * (1 - commissionBps/10000)

// Your position with this validator.
const d = await program.account.stakeDelegation.fetch(delegationPda(me, VALIDATOR_IDENTITY));
console.log("Staked:", d.amount.toString());
console.log("Pending unstake:", d.pendingUnstake.toString());
console.log("Unstake ready at (unix):", d.unstakeReadyTs.toString());