Files
SHiNE-server/shine-UI/js/services/solana-wallet-service.js
T

391 lines
14 KiB
JavaScript

import { t } from '../i18n/index.js';
import { formatNumber } from '../i18n/format.js';
import { confirmSolanaTransactionHttp, sendAndConfirmSolanaHttp } from './solana-rpc-gateway.js';
import { extractEd25519Seed32FromStoredValue } from './client-key-utils.js';
import { base64ToBytes } from './crypto-utils.js';
import { loadEncryptedUserSecrets } from './key-vault.js';
import { SOLANA_ENDPOINT_DEFAULT } from '../solana-programs.js';
import { loadSolanaWeb3 } from '../vendor/solana-web3-loader.js';
const DEFAULT_SOLANA_ENDPOINT = SOLANA_ENDPOINT_DEFAULT;
const TOPUP_SITE_URL = '/devnet-topup';
let solanaLibPromise = null;
const BASE58_RE = /^[1-9A-HJ-NP-Za-km-z]+$/;
const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
const BASE58_MAP = (() => {
const out = Object.create(null);
for (let i = 0; i < BASE58_ALPHABET.length; i += 1) {
out[BASE58_ALPHABET[i]] = i;
}
return out;
})();
function encodeBase58(bytesLike) {
const bytes = bytesLike instanceof Uint8Array ? bytesLike : Uint8Array.from(bytesLike || []);
if (!bytes.length) return '';
const digits = [0];
for (let i = 0; i < bytes.length; i += 1) {
let carry = bytes[i];
for (let j = 0; j < digits.length; j += 1) {
const value = (digits[j] << 8) + carry;
digits[j] = value % 58;
carry = (value / 58) | 0;
}
while (carry > 0) {
digits.push(carry % 58);
carry = (carry / 58) | 0;
}
}
let out = '';
for (let i = 0; i < bytes.length && bytes[i] === 0; i += 1) {
out += BASE58_ALPHABET[0];
}
for (let i = digits.length - 1; i >= 0; i -= 1) {
out += BASE58_ALPHABET[digits[i]];
}
return out;
}
export function solanaAddressFromPublicKeyBase64(publicKeyB64) {
const clean = String(publicKeyB64 || '').trim();
if (!clean) return '';
const bytes = base64ToBytes(clean);
if (bytes.length !== 32) {
throw new Error(t('remaining.solana_wallet_errors.solana_public_key_must_contain_32_bytes'));
}
return encodeBase58(bytes);
}
function normalizeEndpoint(url) {
const raw = String(url || '').trim();
if (!raw) return DEFAULT_SOLANA_ENDPOINT;
return raw;
}
async function loadSolanaLib() {
if (!solanaLibPromise) {
solanaLibPromise = loadSolanaWeb3();
}
return solanaLibPromise;
}
function decodeBase58(input) {
const text = String(input || '').trim();
if (!text) return new Uint8Array(0);
const bytes = [0];
for (let i = 0; i < text.length; i += 1) {
const ch = text[i];
const value = BASE58_MAP[ch];
if (value == null) {
throw new Error(t('remaining.solana_wallet_errors.invalid_base58_character'));
}
let carry = value;
for (let j = 0; j < bytes.length; j += 1) {
const x = (bytes[j] * 58) + carry;
bytes[j] = x & 0xff;
carry = x >> 8;
}
while (carry > 0) {
bytes.push(carry & 0xff);
carry >>= 8;
}
}
for (let i = 0; i < text.length && text[i] === '1'; i += 1) {
bytes.push(0);
}
bytes.reverse();
return Uint8Array.from(bytes);
}
async function keypairFromPkcs8(pkcs8B64) {
const solana = await loadSolanaLib();
const seed32 = extractEd25519Seed32FromStoredValue(pkcs8B64);
try {
return solana.Keypair.fromSeed(seed32);
} finally {
seed32.fill(0);
}
}
async function keypairFromStoredSecret(storedSecret) {
const solana = await loadSolanaLib();
const seed32 = extractEd25519Seed32FromStoredValue(storedSecret);
try {
return solana.Keypair.fromSeed(seed32);
} finally {
seed32.fill(0);
}
}
export async function getSolanaWalletFromStoredSecret(storedSecret) {
const clean = String(storedSecret || '').trim();
if (!clean) throw new Error(t('remaining.solana_wallet_errors.private_key_was_not_provided'));
const keypair = await keypairFromStoredSecret(clean);
return {
address: keypair.publicKey.toBase58(),
keypair,
};
}
export async function createRandomSolanaWallet() {
const solana = await loadSolanaLib();
const keypair = solana.Keypair.generate();
const privateKey32Base58 = encodeBase58(keypair.secretKey.slice(0, 32));
return {
address: keypair.publicKey.toBase58(),
privateKey32Base58,
keypair,
};
}
export async function createSolanaWalletFromPrivateBase58(privateKey32Base58) {
const solana = await loadSolanaLib();
const clean = String(privateKey32Base58 || '').trim();
if (!clean) throw new Error(t('remaining.solana_wallet.enter_a_private_key'));
if (!BASE58_RE.test(clean)) throw new Error(t('remaining.solana_wallet.only_base58_characters_are_allowed'));
const privateBytes = decodeBase58(clean);
if (privateBytes.length !== 32) {
throw new Error(t('remaining.solana_wallet_errors.private_key_must_be_exactly_32_bytes_in_base58'));
}
const keypair = solana.Keypair.fromSeed(privateBytes);
return {
address: keypair.publicKey.toBase58(),
privateKey32Base58: clean,
keypair,
};
}
export async function getWalletFromStoredClientKey({ login, storagePwd }) {
const cleanLogin = String(login || '').trim();
const cleanPwd = String(storagePwd || '').trim();
if (!cleanLogin || !cleanPwd) {
throw new Error(t('remaining.solana_wallet.no_active_session_to_access_client_key'));
}
const secrets = await loadEncryptedUserSecrets(cleanLogin, cleanPwd);
const clientPrivate = String(secrets?.clientKey || '').trim();
if (!clientPrivate) {
throw new Error(t('remaining.solana_wallet.client_key_not_found_on_this_device'));
}
const keypair = await keypairFromStoredSecret(clientPrivate);
return {
address: keypair.publicKey.toBase58(),
keypair,
clientPrivatePkcs8B64: clientPrivate,
};
}
export async function getWalletFromStoredBlockchainKey({ login, storagePwd }) {
const cleanLogin = String(login || '').trim();
const cleanPwd = String(storagePwd || '').trim();
if (!cleanLogin || !cleanPwd) {
throw new Error(t('remaining.solana_wallet.no_active_session_to_access_blockchain_key'));
}
const secrets = await loadEncryptedUserSecrets(cleanLogin, cleanPwd);
const blockchainPrivate = String(secrets?.blockchainKey || '').trim();
if (!blockchainPrivate) {
throw new Error(t('remaining.solana_wallet.blockchain_key_not_found_on_this_device'));
}
const keypair = await keypairFromStoredSecret(blockchainPrivate);
return {
address: keypair.publicKey.toBase58(),
keypair,
blockchainPrivatePkcs8B64: blockchainPrivate,
};
}
export async function getWalletFromStoredRootKey({ login, storagePwd }) {
const cleanLogin = String(login || '').trim();
const cleanPwd = String(storagePwd || '').trim();
if (!cleanLogin || !cleanPwd) {
throw new Error(t('remaining.solana_wallet.no_active_session_to_access_root_key'));
}
const secrets = await loadEncryptedUserSecrets(cleanLogin, cleanPwd);
const rootPrivate = String(secrets?.rootKey || '').trim();
if (!rootPrivate) {
throw new Error(t('remaining.solana_wallet.root_key_not_found_on_this_device'));
}
const keypair = await keypairFromStoredSecret(rootPrivate);
return {
address: keypair.publicKey.toBase58(),
keypair,
rootPrivatePkcs8B64: rootPrivate,
};
}
export async function getStoredSolanaWalletChoices({ login, storagePwd } = {}) {
const cleanLogin = String(login || '').trim();
const cleanPwd = String(storagePwd || '').trim();
if (!cleanLogin || !cleanPwd) throw new Error(t('remaining.solana_wallet_errors.no_active_session_to_access_keys'));
const wallet = await getWalletFromStoredBlockchainKey({ login: cleanLogin, storagePwd: cleanPwd });
return [{
id: 'blockchain-key',
keySource: 'blockchain',
label: t('remaining.solana_wallet.blockchain_key'),
address: wallet.address,
keypair: wallet.keypair,
}];
}
export async function encodeSolanaSecretKeyBase58(secretKey) {
const bytes = secretKey instanceof Uint8Array ? secretKey : Uint8Array.from(secretKey || []);
if (!bytes.length) throw new Error(t('remaining.solana_wallet_errors.empty_solana_secret_key'));
return encodeBase58(bytes);
}
export async function getBalanceSol({ endpoint, address }) {
const solana = await loadSolanaLib();
const rpc = normalizeEndpoint(endpoint);
const conn = new solana.Connection(rpc, 'confirmed');
const pubkey = new solana.PublicKey(String(address || '').trim());
const lamports = await conn.getBalance(pubkey, 'confirmed');
return {
endpoint: rpc,
lamports,
sol: lamports / solana.LAMPORTS_PER_SOL,
};
}
export async function requestAirdropSol({ endpoint, address, amountSol = 1 }) {
const solana = await loadSolanaLib();
const rpc = normalizeEndpoint(endpoint);
const conn = new solana.Connection(rpc, 'confirmed');
const pubkey = new solana.PublicKey(String(address || '').trim());
const lamports = Math.max(1, Math.floor(Number(amountSol) * solana.LAMPORTS_PER_SOL));
const signature = await conn.requestAirdrop(pubkey, lamports);
await confirmSolanaTransactionHttp(conn, signature);
return { endpoint: rpc, signature, lamports };
}
export async function transferSol({ endpoint, fromKeypair, toAddress, amountSol }) {
const solana = await loadSolanaLib();
const rpc = normalizeEndpoint(endpoint);
const cleanTo = String(toAddress || '').trim();
const amount = Number(amountSol);
if (!cleanTo) throw new Error(t('remaining.solana_wallet.recipient_address_missing'));
if (!Number.isFinite(amount) || amount <= 0) throw new Error(t('remaining.solana_wallet.transfer_amount_must_be_greater_than_zero'));
const conn = new solana.Connection(rpc, 'confirmed');
const lamports = Math.floor(amount * solana.LAMPORTS_PER_SOL);
if (lamports <= 0) throw new Error(t('remaining.solana_wallet.amount_is_too_small'));
const tx = new solana.Transaction().add(
solana.SystemProgram.transfer({
fromPubkey: fromKeypair.publicKey,
toPubkey: new solana.PublicKey(cleanTo),
lamports,
}),
);
const signature = await sendAndConfirmSolanaHttp(conn, tx, [fromKeypair]);
return { endpoint: rpc, signature, lamports };
}
/** Прямой перевод точной суммы в lamports, без преобразований через дробный SOL. */
export async function transferSolLamports({ endpoint, fromKeypair, toAddress, amountLamports }) {
const solana = await loadSolanaLib();
const amount = BigInt(amountLamports);
if (amount <= 0n || amount > BigInt(Number.MAX_SAFE_INTEGER)) throw new Error('Сумма вне безопасного диапазона прямого перевода');
const connection = new solana.Connection(normalizeEndpoint(endpoint), 'confirmed');
const tx = new solana.Transaction().add(solana.SystemProgram.transfer({
fromPubkey: fromKeypair.publicKey,
toPubkey: new solana.PublicKey(String(toAddress || '').trim()),
lamports: Number(amount),
}));
const signature = await sendAndConfirmSolanaHttp(connection, tx, [fromKeypair]);
return { signature, lamports: amount };
}
export async function transferAllSol({ endpoint, fromKeypair, toAddress }) {
const solana = await loadSolanaLib();
const rpc = normalizeEndpoint(endpoint);
const cleanTo = String(toAddress || '').trim();
if (!fromKeypair?.publicKey) throw new Error(t('remaining.solana_wallet.previous_solana_wallet_was_not_provided'));
if (!cleanTo) throw new Error(t('remaining.solana_wallet.new_wallet_address_missing'));
if (fromKeypair.publicKey.toBase58() === cleanTo) {
throw new Error(t('remaining.solana_wallet.old_and_new_wallet_addresses_are_the_same'));
}
const conn = new solana.Connection(rpc, 'confirmed');
const balanceLamports = await conn.getBalance(fromKeypair.publicKey, 'confirmed');
if (balanceLamports <= 0) {
return { endpoint: rpc, signature: '', lamports: 0, feeLamports: 0, balanceLamports, skipped: true };
}
const latest = await conn.getLatestBlockhash('confirmed');
const probeTx = new solana.Transaction({
feePayer: fromKeypair.publicKey,
recentBlockhash: latest.blockhash,
}).add(solana.SystemProgram.transfer({
fromPubkey: fromKeypair.publicKey,
toPubkey: new solana.PublicKey(cleanTo),
lamports: 1,
}));
const feeResult = await conn.getFeeForMessage(probeTx.compileMessage(), 'confirmed');
const feeLamports = Number(feeResult?.value ?? 5000);
const transferLamports = balanceLamports - feeLamports;
if (transferLamports <= 0) {
return {
endpoint: rpc,
signature: '',
lamports: 0,
feeLamports,
balanceLamports,
skipped: true,
};
}
const tx = new solana.Transaction({
feePayer: fromKeypair.publicKey,
recentBlockhash: latest.blockhash,
}).add(solana.SystemProgram.transfer({
fromPubkey: fromKeypair.publicKey,
toPubkey: new solana.PublicKey(cleanTo),
lamports: transferLamports,
}));
tx.sign(fromKeypair);
const signature = await conn.sendRawTransaction(tx.serialize(), { skipPreflight: false });
await confirmSolanaTransactionHttp(conn, signature, { lastValidBlockHeight: latest.lastValidBlockHeight });
return {
endpoint: rpc,
signature,
lamports: transferLamports,
feeLamports,
balanceLamports,
skipped: false,
};
}
export function formatSol(value, digits = 6) {
const n = Number(value);
if (!Number.isFinite(n)) return '0';
return formatNumber(n, {
minimumFractionDigits: 0,
maximumFractionDigits: digits,
});
}
export function getTopupSiteUrl(walletAddress = '') {
const cleanWallet = String(walletAddress || '').trim();
if (!cleanWallet) return TOPUP_SITE_URL;
try {
const base = typeof window !== 'undefined' && window.location?.origin
? window.location.origin
: 'http://localhost:8088';
const url = new URL(TOPUP_SITE_URL, base);
url.searchParams.set('wallet', cleanWallet);
return url.toString();
} catch {
return `${TOPUP_SITE_URL}?wallet=${encodeURIComponent(cleanWallet)}`;
}
}