@synapseia-network/node 0.8.5

package/dist/chunk-XL2NJWFY.js

@@ -0,0 +1,702 @@
+import { fileURLToPath as __synFup } from "url";import { dirname as __synDn } from "path";const __filename = __synFup(import.meta.url);const __dirname = __synDn(__filename);
+import {
+  init_logger,
+  logger_default
+} from "./chunk-V2L5SXTL.js";
+import {
+  __name
+} from "./chunk-D7ADMHK2.js";
+
+// src/modules/staking/staking-cli.ts
+init_logger();
+import { Connection, PublicKey, Keypair, Transaction, TransactionInstruction, SystemProgram, ComputeBudgetProgram } from "@solana/web3.js";
+import { getAssociatedTokenAddress, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, createTransferInstruction } from "@solana/spl-token";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as crypto from "crypto";
+import { password } from "@inquirer/prompts";
+var DEFAULT_CU_LIMIT = 14e5;
+var DEFAULT_CU_PRICE_MICROLAMPORTS = 1e4;
+function requireEnvPublicKey(key) {
+  const val = process.env[key];
+  if (!val) throw new Error(`${key} not informed`);
+  return new PublicKey(val);
+}
+__name(requireEnvPublicKey, "requireEnvPublicKey");
+function requireEnv(key, fallback) {
+  const val = process.env[key];
+  if (!val && fallback === void 0) throw new Error(`${key} not informed`);
+  return val ?? fallback;
+}
+__name(requireEnv, "requireEnv");
+var getStakingProgramId = /* @__PURE__ */ __name(() => requireEnvPublicKey("STAKING_PROGRAM_ID"), "getStakingProgramId");
+var getSynMint = /* @__PURE__ */ __name(() => requireEnvPublicKey("SYN_TOKEN_MINT"), "getSynMint");
+var getSolanaRpcUrl = /* @__PURE__ */ __name(() => requireEnv("SOLANA_RPC_URL"), "getSolanaRpcUrl");
+var COORDINATOR_URL = process.env.COORDINATOR_URL || "http://localhost:3701";
+var TOKEN_PROGRAM = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+var _STAKING_PROGRAM_ID = null;
+var _SYN_MINT = null;
+var _SOLANA_RPC_URL = null;
+var STAKING_PROGRAM_ID = /* @__PURE__ */ __name(() => _STAKING_PROGRAM_ID ??= getStakingProgramId(), "STAKING_PROGRAM_ID");
+var SYN_MINT = /* @__PURE__ */ __name(() => _SYN_MINT ??= getSynMint(), "SYN_MINT");
+var SOLANA_RPC_URL_GETTER = /* @__PURE__ */ __name(() => _SOLANA_RPC_URL ??= getSolanaRpcUrl(), "SOLANA_RPC_URL_GETTER");
+function getVaultAuthorityPDA() {
+  return PublicKey.findProgramAddressSync([
+    Buffer.from("stake_vault_authority")
+  ], STAKING_PROGRAM_ID());
+}
+__name(getVaultAuthorityPDA, "getVaultAuthorityPDA");
+function getStakingPoolPDA() {
+  return PublicKey.findProgramAddressSync([
+    Buffer.from("staking_pool")
+  ], STAKING_PROGRAM_ID());
+}
+__name(getStakingPoolPDA, "getStakingPoolPDA");
+function isAlreadyProcessedError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  return /already been processed|already processed/i.test(msg);
+}
+__name(isAlreadyProcessedError, "isAlreadyProcessedError");
+async function sendAndConfirmFresh(connection, tx, signers) {
+  const payer = signers[0];
+  if (!payer) throw new Error("sendAndConfirmFresh: at least one signer required");
+  const hasCuIx = tx.instructions.some((ix) => ix.programId.equals(ComputeBudgetProgram.programId));
+  if (!hasCuIx) {
+    tx.instructions = [
+      ComputeBudgetProgram.setComputeUnitPrice({
+        microLamports: DEFAULT_CU_PRICE_MICROLAMPORTS
+      }),
+      ComputeBudgetProgram.setComputeUnitLimit({
+        units: DEFAULT_CU_LIMIT
+      }),
+      ...tx.instructions
+    ];
+  }
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
+  tx.recentBlockhash = blockhash;
+  tx.feePayer = payer.publicKey;
+  tx.sign(...signers);
+  try {
+    const sig = await connection.sendRawTransaction(tx.serialize(), {
+      skipPreflight: false,
+      preflightCommitment: "confirmed"
+    });
+    await connection.confirmTransaction({
+      signature: sig,
+      blockhash,
+      lastValidBlockHeight
+    }, "confirmed");
+    return sig;
+  } catch (err) {
+    if (isAlreadyProcessedError(err)) {
+      logger_default.warn('[staking-cli] tx flagged "already been processed" \u2014 first submission already landed, returning existing signature');
+      const s = tx.signatures[0]?.signature;
+      return s ? s.toString("base64") : "";
+    }
+    throw err;
+  }
+}
+__name(sendAndConfirmFresh, "sendAndConfirmFresh");
+async function getStakeVaultATA(connection) {
+  const [vaultAuthority] = getVaultAuthorityPDA();
+  return getAssociatedTokenAddress(SYN_MINT(), vaultAuthority, true);
+}
+__name(getStakeVaultATA, "getStakeVaultATA");
+function getTreasuryAuthorityPDA() {
+  return PublicKey.findProgramAddressSync([
+    Buffer.from("treasury_authority")
+  ], STAKING_PROGRAM_ID());
+}
+__name(getTreasuryAuthorityPDA, "getTreasuryAuthorityPDA");
+async function getTreasuryTokenAccount(connection) {
+  const [treasuryAuthority] = getTreasuryAuthorityPDA();
+  return getAssociatedTokenAddress(SYN_MINT(), treasuryAuthority, true);
+}
+__name(getTreasuryTokenAccount, "getTreasuryTokenAccount");
+var WALLET_DIR = /* @__PURE__ */ __name(() => process.env.SYNAPSEIA_HOME || path.join(os.homedir(), ".synapseia"), "WALLET_DIR");
+var WALLET_FILE = /* @__PURE__ */ __name(() => path.join(WALLET_DIR(), "wallet.json"), "WALLET_FILE");
+var PBKDF2_ITERATIONS = 1e5;
+var KEY_LENGTH = 32;
+var IV_LENGTH = 16;
+var SALT_LENGTH = 32;
+var AUTH_TAG_LENGTH = 16;
+function deriveKey(password2, salt) {
+  return crypto.pbkdf2Sync(password2, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
+}
+__name(deriveKey, "deriveKey");
+function decryptWallet(encryptedData, password2) {
+  const combined = Buffer.from(encryptedData, "base64");
+  const salt = combined.subarray(0, SALT_LENGTH);
+  const iv = combined.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+  const authTag = combined.subarray(SALT_LENGTH + IV_LENGTH, SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH);
+  const ciphertext = combined.subarray(SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH);
+  const key = deriveKey(password2, salt);
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(authTag);
+  const decrypted = Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]);
+  return new Uint8Array(decrypted);
+}
+__name(decryptWallet, "decryptWallet");
+async function loadWalletWithPassword() {
+  const walletFile = WALLET_FILE();
+  if (!fs.existsSync(walletFile)) {
+    throw new Error(`Wallet not found at ${walletFile}. Run 'synapseia-node setup' first.`);
+  }
+  const walletData = JSON.parse(fs.readFileSync(walletFile, "utf-8"));
+  if (!walletData.encryptedData) {
+    const secretKey = new Uint8Array(walletData.secretKey);
+    return Keypair.fromSecretKey(secretKey);
+  }
+  const envPassword = process.env.SYNAPSEIA_WALLET_PASSWORD ?? process.env.WALLET_PASSWORD;
+  const walletPassword = envPassword ? envPassword : await password({
+    message: "Enter wallet password:",
+    mask: "*"
+  });
+  try {
+    const secretKey = decryptWallet(walletData.encryptedData, walletPassword);
+    return Keypair.fromSecretKey(secretKey);
+  } catch (e) {
+    throw new Error("Invalid password or corrupted wallet file");
+  }
+}
+__name(loadWalletWithPassword, "loadWalletWithPassword");
+async function getUserTokenAccount(connection, wallet) {
+  return getAssociatedTokenAddress(SYN_MINT(), wallet);
+}
+__name(getUserTokenAccount, "getUserTokenAccount");
+function createStakeInstructionData(amount) {
+  const discriminator = Buffer.from([
+    206,
+    176,
+    202,
+    18,
+    200,
+    209,
+    179,
+    108
+  ]);
+  const amountBuffer = Buffer.alloc(8);
+  amountBuffer.writeBigUInt64LE(BigInt(Math.floor(amount * 1e9)));
+  return Buffer.concat([
+    discriminator,
+    amountBuffer
+  ]);
+}
+__name(createStakeInstructionData, "createStakeInstructionData");
+function createUnstakeInstructionData(amount) {
+  const discriminator = Buffer.from([
+    90,
+    95,
+    107,
+    42,
+    205,
+    124,
+    50,
+    225
+  ]);
+  const amountBuffer = Buffer.alloc(8);
+  amountBuffer.writeBigUInt64LE(BigInt(Math.floor(amount * 1e9)));
+  return Buffer.concat([
+    discriminator,
+    amountBuffer
+  ]);
+}
+__name(createUnstakeInstructionData, "createUnstakeInstructionData");
+function createInitializeStakeInstructionData(tier) {
+  const discriminator = Buffer.from([
+    33,
+    175,
+    216,
+    4,
+    116,
+    130,
+    164,
+    177
+  ]);
+  const tierBuffer = Buffer.alloc(1);
+  tierBuffer.writeUInt8(tier);
+  return Buffer.concat([
+    discriminator,
+    tierBuffer
+  ]);
+}
+__name(createInitializeStakeInstructionData, "createInitializeStakeInstructionData");
+function createClaimRewardsInstructionData() {
+  return Buffer.from([
+    4,
+    144,
+    132,
+    71,
+    116,
+    23,
+    151,
+    80
+  ]);
+}
+__name(createClaimRewardsInstructionData, "createClaimRewardsInstructionData");
+async function stakeTokens(amount) {
+  logger_default.log(`
+\u{1F504} Connecting to Solana...`);
+  const connection = new Connection(SOLANA_RPC_URL_GETTER(), "confirmed");
+  const wallet = await loadWalletWithPassword();
+  logger_default.log(`\u2705 Connected. Wallet: ${wallet.publicKey.toBase58()}`);
+  const stakeAccountAddress = await findStakeAccount(connection, wallet.publicKey);
+  let stakeAccount;
+  let stakeAccountPubkey;
+  if (!stakeAccountAddress) {
+    logger_default.log(`\u{1F4DD} Creating new stake account...`);
+    stakeAccount = Keypair.generate();
+    stakeAccountPubkey = stakeAccount.publicKey;
+    const coordInfoRes = await fetch(`${COORDINATOR_URL}/stake/info/coordinator-authority`);
+    if (!coordInfoRes.ok) throw new Error(`Failed to get coordinator authority: ${coordInfoRes.status}`);
+    const { coordinatorAuthority } = await coordInfoRes.json();
+    const initIx = new TransactionInstruction({
+      programId: STAKING_PROGRAM_ID(),
+      data: createInitializeStakeInstructionData(1),
+      keys: [
+        {
+          pubkey: stakeAccount.publicKey,
+          isSigner: true,
+          isWritable: true
+        },
+        {
+          pubkey: wallet.publicKey,
+          isSigner: true,
+          isWritable: true
+        },
+        {
+          pubkey: new PublicKey(coordinatorAuthority),
+          isSigner: false,
+          isWritable: false
+        },
+        {
+          pubkey: SystemProgram.programId,
+          isSigner: false,
+          isWritable: false
+        }
+      ]
+    });
+    const initTx = new Transaction().add(initIx);
+    const initSig = await sendAndConfirmFresh(connection, initTx, [
+      wallet,
+      stakeAccount
+    ]);
+    logger_default.log(`   Stake account created: ${initSig}`);
+  } else {
+    stakeAccountPubkey = new PublicKey(stakeAccountAddress);
+  }
+  const userTokenAccount = await getUserTokenAccount(connection, wallet.publicKey);
+  const stakeVault = await getStakeVaultATA(connection);
+  const [vaultAuthority] = getVaultAuthorityPDA();
+  const [stakingPool] = getStakingPoolPDA();
+  logger_default.log(`
+\u{1F4E4} Staking ${amount} SYN tokens...`);
+  const stakeIx = new TransactionInstruction({
+    programId: STAKING_PROGRAM_ID(),
+    data: createStakeInstructionData(amount),
+    keys: [
+      {
+        pubkey: stakeAccountPubkey,
+        isSigner: false,
+        isWritable: true
+      },
+      {
+        pubkey: wallet.publicKey,
+        isSigner: true,
+        isWritable: true
+      },
+      {
+        pubkey: userTokenAccount,
+        isSigner: false,
+        isWritable: true
+      },
+      {
+        pubkey: stakeVault,
+        isSigner: false,
+        isWritable: true
+      },
+      {
+        pubkey: SYN_MINT(),
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: vaultAuthority,
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: TOKEN_PROGRAM,
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: stakingPool,
+        isSigner: false,
+        isWritable: true
+      }
+    ]
+  });
+  const stakeTx = new Transaction().add(stakeIx);
+  const tx = await sendAndConfirmFresh(connection, stakeTx, [
+    wallet
+  ]);
+  logger_default.log(`\u2705 Stake successful!`);
+  logger_default.log(`   Transaction: ${tx}`);
+  return tx;
+}
+__name(stakeTokens, "stakeTokens");
+async function unstakeTokens(amount) {
+  logger_default.log(`
+\u{1F504} Connecting to Solana...`);
+  const connection = new Connection(SOLANA_RPC_URL_GETTER(), "confirmed");
+  const wallet = await loadWalletWithPassword();
+  logger_default.log(`\u2705 Connected. Wallet: ${wallet.publicKey.toBase58()}`);
+  const stakeAccountAddress = await findStakeAccount(connection, wallet.publicKey);
+  if (!stakeAccountAddress) {
+    throw new Error("No stake account found. Have you staked any tokens?");
+  }
+  const stakeAccount = new PublicKey(stakeAccountAddress);
+  const userTokenAccount = await getUserTokenAccount(connection, wallet.publicKey);
+  const stakeVault = await getStakeVaultATA(connection);
+  const [vaultAuthority] = getVaultAuthorityPDA();
+  const [stakingPool] = getStakingPoolPDA();
+  logger_default.log(`
+\u{1F4E5} Unstaking ${amount} SYN tokens...`);
+  const unstakeIx = new TransactionInstruction({
+    programId: STAKING_PROGRAM_ID(),
+    data: createUnstakeInstructionData(amount),
+    keys: [
+      {
+        pubkey: stakeAccount,
+        isSigner: false,
+        isWritable: true
+      },
+      {
+        pubkey: wallet.publicKey,
+        isSigner: true,
+        isWritable: true
+      },
+      {
+        pubkey: userTokenAccount,
+        isSigner: false,
+        isWritable: true
+      },
+      {
+        pubkey: stakeVault,
+        isSigner: false,
+        isWritable: true
+      },
+      {
+        pubkey: SYN_MINT(),
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: vaultAuthority,
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: TOKEN_PROGRAM,
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: stakingPool,
+        isSigner: false,
+        isWritable: true
+      }
+    ]
+  });
+  const unstakeTx = new Transaction().add(unstakeIx);
+  const tx = await sendAndConfirmFresh(connection, unstakeTx, [
+    wallet
+  ]);
+  logger_default.log(`\u2705 Unstake successful!`);
+  logger_default.log(`   Transaction: ${tx}`);
+  return tx;
+}
+__name(unstakeTokens, "unstakeTokens");
+async function claimStakingRewards() {
+  logger_default.log(`
+\u{1F504} Connecting to Solana...`);
+  const connection = new Connection(SOLANA_RPC_URL_GETTER(), "confirmed");
+  const wallet = await loadWalletWithPassword();
+  logger_default.log(`\u2705 Connected. Wallet: ${wallet.publicKey.toBase58()}`);
+  const stakeAccountAddress = await findStakeAccount(connection, wallet.publicKey);
+  if (!stakeAccountAddress) {
+    throw new Error("No stake account found. Have you staked any tokens?");
+  }
+  const accountInfo = await connection.getAccountInfo(new PublicKey(stakeAccountAddress));
+  if (!accountInfo) {
+    throw new Error("Stake account not found on chain");
+  }
+  const data = accountInfo.data;
+  const rewardsPending = data.readBigUInt64LE(170);
+  const rewards = Number(rewardsPending) / 1e9;
+  if (rewards <= 0) {
+    logger_default.log(`\u2139\uFE0F No pending rewards to claim.`);
+    return "";
+  }
+  logger_default.log(`
+\u{1F4B0} Claiming ${rewards} SYN in rewards...`);
+  const userTokenAccount = await getUserTokenAccount(connection, wallet.publicKey);
+  const [treasuryAuthority] = getTreasuryAuthorityPDA();
+  const treasuryTokenAccount = await getTreasuryTokenAccount(connection);
+  const [stakingPool] = getStakingPoolPDA();
+  const preIxs = [];
+  const treasuryAtaInfo = await connection.getAccountInfo(treasuryTokenAccount);
+  if (!treasuryAtaInfo) {
+    const { createAssociatedTokenAccountInstruction } = await import("@solana/spl-token");
+    preIxs.push(createAssociatedTokenAccountInstruction(wallet.publicKey, treasuryTokenAccount, treasuryAuthority, SYN_MINT(), TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID));
+    logger_default.log(`   Treasury ATA missing \u2014 will create it in the same tx`);
+  }
+  const claimIx = new TransactionInstruction({
+    programId: STAKING_PROGRAM_ID(),
+    data: createClaimRewardsInstructionData(),
+    keys: [
+      {
+        pubkey: new PublicKey(stakeAccountAddress),
+        isSigner: false,
+        isWritable: true
+      },
+      {
+        pubkey: wallet.publicKey,
+        isSigner: true,
+        isWritable: true
+      },
+      {
+        pubkey: userTokenAccount,
+        isSigner: false,
+        isWritable: true
+      },
+      {
+        pubkey: treasuryTokenAccount,
+        isSigner: false,
+        isWritable: true
+      },
+      {
+        pubkey: treasuryAuthority,
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: SYN_MINT(),
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: TOKEN_PROGRAM,
+        isSigner: false,
+        isWritable: false
+      },
+      {
+        pubkey: stakingPool,
+        isSigner: false,
+        isWritable: false
+      }
+    ]
+  });
+  const claimTx = new Transaction().add(...preIxs, claimIx);
+  const tx = await sendAndConfirmFresh(connection, claimTx, [
+    wallet
+  ]);
+  logger_default.log(`\u2705 Rewards claimed!`);
+  logger_default.log(`   Transaction: ${tx}`);
+  return tx;
+}
+__name(claimStakingRewards, "claimStakingRewards");
+async function depositSol(amount) {
+  logger_default.log(`
+\u{1F504} Connecting to Solana...`);
+  const connection = new Connection(SOLANA_RPC_URL_GETTER(), "confirmed");
+  const wallet = await loadWalletWithPassword();
+  logger_default.log(`\u2705 Connected. Wallet: ${wallet.publicKey.toBase58()}`);
+  const airdropAmount = Math.floor(amount * 1e9);
+  logger_default.log(`
+\u{1F4B8} Requesting ${amount} SOL airdrop...`);
+  try {
+    const airdropSig = await connection.requestAirdrop(wallet.publicKey, airdropAmount);
+    await connection.confirmTransaction(airdropSig);
+    logger_default.log(`\u2705 Airdrop successful!`);
+    logger_default.log(`   Transaction: ${airdropSig}`);
+    return airdropSig;
+  } catch (e) {
+    logger_default.log(`\u26A0\uFE0F Airdrop not available on this network`);
+    logger_default.log(`   Send SOL to: ${wallet.publicKey.toBase58()}`);
+    throw e;
+  }
+}
+__name(depositSol, "depositSol");
+async function depositSyn(amount) {
+  logger_default.log(`
+\u{1F504} Connecting to Solana...`);
+  const connection = new Connection(SOLANA_RPC_URL_GETTER(), "confirmed");
+  const wallet = await loadWalletWithPassword();
+  logger_default.log(`\u2705 Connected. Wallet: ${wallet.publicKey.toBase58()}`);
+  const userTokenAccount = await getUserTokenAccount(connection, wallet.publicKey);
+  logger_default.log(`
+\u{1F4E5} To deposit SYN, send tokens to your token account:`);
+  logger_default.log(`   Address: ${userTokenAccount.toBase58()}`);
+  logger_default.log(`   (This is your ATA - Associated Token Account for SYN)`);
+  const balance = await connection.getTokenAccountBalance(userTokenAccount).catch(() => null);
+  if (balance) {
+    logger_default.log(`   Current balance: ${Number(balance.value.uiAmountString)} SYN`);
+  }
+  return "";
+}
+__name(depositSyn, "depositSyn");
+async function withdrawSol(amount, destinationAddress) {
+  logger_default.log(`
+\u{1F504} Connecting to Solana...`);
+  const connection = new Connection(SOLANA_RPC_URL_GETTER(), "confirmed");
+  const wallet = await loadWalletWithPassword();
+  logger_default.log(`\u2705 Connected. Wallet: ${wallet.publicKey.toBase58()}`);
+  const destination = new PublicKey(destinationAddress);
+  const amountLamports = Math.floor(amount * 1e9);
+  const minBalance = await connection.getMinimumBalanceForRentExemption(0);
+  const balance = await connection.getBalance(wallet.publicKey);
+  if (balance - amountLamports < minBalance) {
+    throw new Error(`Cannot withdraw ${amount} SOL. Need to keep ~0.01 SOL for rent.`);
+  }
+  logger_default.log(`
+\u{1F4E4} Withdrawing ${amount} SOL to ${destinationAddress}...`);
+  const tx = new Transaction().add(SystemProgram.transfer({
+    fromPubkey: wallet.publicKey,
+    toPubkey: destination,
+    lamports: amountLamports
+  }));
+  const signature = await sendAndConfirmFresh(connection, tx, [
+    wallet
+  ]);
+  logger_default.log(`\u2705 Withdraw successful!`);
+  logger_default.log(`   Transaction: ${signature}`);
+  return signature;
+}
+__name(withdrawSol, "withdrawSol");
+async function withdrawSyn(amount, destinationAddress) {
+  logger_default.log(`
+\u{1F504} Connecting to Solana...`);
+  const connection = new Connection(SOLANA_RPC_URL_GETTER(), "confirmed");
+  const wallet = await loadWalletWithPassword();
+  logger_default.log(`\u2705 Connected. Wallet: ${wallet.publicKey.toBase58()}`);
+  const destination = new PublicKey(destinationAddress);
+  const sourceTokenAccount = await getAssociatedTokenAddress(SYN_MINT(), wallet.publicKey);
+  let destTokenAccount;
+  try {
+    destTokenAccount = await getAssociatedTokenAddress(SYN_MINT(), destination);
+    const destAccountInfo = await connection.getAccountInfo(destTokenAccount);
+    if (!destAccountInfo) {
+      logger_default.log(`
+\u{1F4DD} Creating destination token account...`);
+    }
+  } catch (e) {
+    destTokenAccount = await getAssociatedTokenAddress(SYN_MINT(), destination, true);
+  }
+  const amountLamports = Math.floor(amount * 1e9);
+  logger_default.log(`
+\u{1F4E4} Withdrawing ${amount} SYN to ${destinationAddress}...`);
+  const transferIx = createTransferInstruction(sourceTokenAccount, destTokenAccount, wallet.publicKey, amountLamports);
+  const preIxs = [];
+  const destAtaInfo = await connection.getAccountInfo(destTokenAccount);
+  if (!destAtaInfo) {
+    const { createAssociatedTokenAccountInstruction } = await import("@solana/spl-token");
+    preIxs.push(createAssociatedTokenAccountInstruction(wallet.publicKey, destTokenAccount, destination, SYN_MINT(), TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID));
+    logger_default.log(`   Destination ATA missing \u2014 will create it in the same tx`);
+  }
+  const tx = new Transaction().add(...preIxs, transferIx);
+  const signature = await sendAndConfirmFresh(connection, tx, [
+    wallet
+  ]);
+  logger_default.log(`\u2705 Withdraw successful!`);
+  logger_default.log(`   Transaction: ${signature}`);
+  return signature;
+}
+__name(withdrawSyn, "withdrawSyn");
+async function getStakeInfo() {
+  const wallet = await loadWalletWithPassword();
+  const connection = new Connection(SOLANA_RPC_URL_GETTER(), "confirmed");
+  const stakeAccountAddress = await findStakeAccount(connection, wallet.publicKey);
+  if (!stakeAccountAddress) {
+    return null;
+  }
+  try {
+    const accountInfo = await connection.getAccountInfo(new PublicKey(stakeAccountAddress));
+    if (!accountInfo) {
+      return null;
+    }
+    const data = accountInfo.data;
+    const amount = Number(data.readBigUInt64LE(72)) / 1e9;
+    const tier = data.readUInt8(80);
+    const lockedUntil = Number(data.readBigInt64LE(162));
+    const rewardsPending = Number(data.readBigUInt64LE(170)) / 1e9;
+    return {
+      amount,
+      tier,
+      rewardsPending,
+      lockedUntil
+    };
+  } catch (e) {
+    logger_default.error("Error fetching stake info:", e);
+    return null;
+  }
+}
+__name(getStakeInfo, "getStakeInfo");
+async function getWalletBalance() {
+  const wallet = await loadWalletWithPassword();
+  const connection = new Connection(SOLANA_RPC_URL_GETTER(), "confirmed");
+  const solBalance = await connection.getBalance(wallet.publicKey);
+  const sol = solBalance / 1e9;
+  let syn = 0;
+  try {
+    const tokenAccount = await getUserTokenAccount(connection, wallet.publicKey);
+    const tokenBalance = await connection.getTokenAccountBalance(tokenAccount);
+    syn = Number(tokenBalance.value.uiAmountString);
+  } catch (e) {
+  }
+  return {
+    sol,
+    syn
+  };
+}
+__name(getWalletBalance, "getWalletBalance");
+async function findStakeAccount(connection, owner) {
+  try {
+    const accounts = await connection.getProgramAccounts(STAKING_PROGRAM_ID(), {
+      filters: [
+        {
+          memcmp: {
+            offset: 8,
+            bytes: owner.toBase58()
+          }
+        }
+      ]
+    });
+    if (accounts.length > 0) {
+      return accounts[0].pubkey.toBase58();
+    }
+  } catch (e) {
+    logger_default.warn("Failed to search stake accounts:", e);
+  }
+  return null;
+}
+__name(findStakeAccount, "findStakeAccount");
+
+export {
+  sendAndConfirmFresh,
+  loadWalletWithPassword,
+  stakeTokens,
+  unstakeTokens,
+  claimStakingRewards,
+  depositSol,
+  depositSyn,
+  withdrawSol,
+  withdrawSyn,
+  getStakeInfo,
+  getWalletBalance
+};