ayrisdev/Pay2Gateway
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor: Fully migrated to direct PostgreSQL, implemented Public API v1, fixed Vercel deployment conflicts, and updated documentation

Browse Source
This commit is contained in:
mstfyldz
2026-03-12 21:54:57 +03:00
parent 321f25a15c
commit 515d513c1f
29 changed files with 1002 additions and 675 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
lib/crypto-engine.ts
View File

@@ -1,57 +1,43 @@
import { ethers } from 'ethers';
import { Connection, PublicKey, Keypair, Transaction, SystemProgram, sendAndConfirmTransaction, clusterApiUrl, LAMPORTS_PER_SOL } from '@solana/web3.js';
import { getAssociatedTokenAddress, getAccount, createTransferInstruction } from '@solana/spl-token';
import { Connection, PublicKey, Keypair, Transaction, SystemProgram, clusterApiUrl, LAMPORTS_PER_SOL } from '@solana/web3.js';
import { getAssociatedTokenAddress, getAccount } from '@solana/spl-token';
import bs58 from 'bs58';
// Demo configuration - In production, these should be securely managed
const RPC_URLS: Record<string, string> = {
ETH: 'https://rpc.ankr.com/eth',
POLYGON: 'https://rpc.ankr.com/polygon',
BSC: 'https://rpc.ankr.com/bsc'
};
// AyrisSplitter Contract Address (Example addresses, in production use real deployed addresses)
const SPLITTER_ADDRESSES: Record<string, string> = {
POLYGON: '0x999...AYRIS_SPLITTER_POLYGON',
ETH: '0x888...AYRIS_SPLITTER_ETH'
};
import cryptoConfig from './crypto-config.json';
// ERC20 ABI for checking USDT/USDC balances
const ERC20_ABI = [
"function balanceOf(address owner) view returns (uint256)",
"function decimals() view returns (uint8)",
"function symbol() view returns (string)"
"function symbol() view returns (string)",
"function transfer(address to, uint256 value) public returns (bool)"
];
const STABLECOIN_ADDRESSES: Record<string, Record<string, string>> = {
POLYGON: {
USDT: '0xc2132D05D31c914a87C6611C10748AEb04B58e8F',
USDC: '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359'
},
ETH: {
USDT: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
USDC: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'
},
SOLANA: {
USDC: '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU', // Devnet USDC
USDT: 'EJwZgeZrdC8TXTQbQBoL6bfuAnFUUy1PVCMB4DYPzVaS' // Devnet USDT
}
};
export class CryptoEngine {
private provider!: ethers.JsonRpcProvider;
private solConnection!: Connection;
private network: string;
private config: any;
constructor(network: string = 'POLYGON') {
this.network = network;
if (network === 'SOLANA') {
this.solConnection = new Connection(clusterApiUrl('devnet'), 'confirmed');
constructor(networkId: string = 'POLYGON') {
this.network = networkId;
this.config = cryptoConfig.networks.find(n => n.id === networkId);
if (!this.config) throw new Error(`Network ${networkId} not found in config.`);
if (this.network === 'SOLANA') {
this.solConnection = new Connection(this.config.rpc, 'confirmed');
} else {
this.provider = new ethers.JsonRpcProvider(RPC_URLS[network]);
this.provider = new ethers.JsonRpcProvider(this.config.rpc);
}
}
/**
* Helper to get token config from JSON
*/
private getTokenConfig(symbol: string) {
return this.config.tokens.find((t: any) => t.symbol === symbol);
}
/**
* Generates a temporary wallet for a transaction.
*/
@@ -94,19 +80,12 @@ export class CryptoEngine {
tokenSymbol: string
) {
const tempWallet = new ethers.Wallet(tempWalletPrivateKey, this.provider);
const tokenAddress = STABLECOIN_ADDRESSES[this.network][tokenSymbol];
const contract = new ethers.Contract(tokenAddress, ERC20_ABI, tempWallet);
const tokenConfig = this.getTokenConfig(tokenSymbol);
if (!tokenConfig) throw new Error(`Unsupported token ${tokenSymbol} on ${this.network}`);
const balance = await contract.balanceOf(tempWallet.address);
if (balance === 0n) throw new Error("Balance is zero");
const platformShare = (balance * 100n) / 10000n; // %1
const merchantShare = balance - platformShare; // %99
console.log(`[Sweep EVM] Total: ${ethers.formatUnits(balance, 6)} ${tokenSymbol}`);
console.log(`[Sweep EVM] Sending ${ethers.formatUnits(platformShare, 6)} to Platform...`);
console.log(`[Sweep EVM] Sending ${ethers.formatUnits(merchantShare, 6)} to Merchant...`);
console.log(`[Sweep EVM] Network: ${this.network} Total for ${tokenSymbol}`);
// Mocking the real transfer for demo
return {
success: true,
platformTx: '0x' + Math.random().toString(16).slice(2, 66),
@@ -114,6 +93,26 @@ export class CryptoEngine {
};
}
async fuelWallet(targetAddress: string, amount: string) {
const gasTankKey = process.env.CRYPTO_GAS_TANK_KEY;
if (!gasTankKey) {
console.warn("[CryptoEngine] No CRYPTO_GAS_TANK_KEY provided. Fueling skipped (Demo mode).");
return;
}
try {
const gasTank = new ethers.Wallet(gasTankKey, this.provider);
const tx = await gasTank.sendTransaction({
to: targetAddress,
value: ethers.parseEther(amount)
});
await tx.wait();
console.log(`[CryptoEngine] Fueled ${targetAddress} with ${amount} native currency. Hash: ${tx.hash}`);
} catch (error) {
console.error("[CryptoEngine] Fueling failed:", error);
}
}
private async sweepSolana(
tempWalletPrivateKey: string,
merchantAddress: string,
@@ -123,60 +122,17 @@ export class CryptoEngine {
const tempKeypair = Keypair.fromSecretKey(bs58.decode(tempWalletPrivateKey));
const pubKey = tempKeypair.publicKey;
if (tokenSymbol === 'SOL') {
const balance = await this.solConnection.getBalance(pubKey);
if (balance === 0) throw new Error("Balance is zero");
// Leave some lamports for tx fees. Mock logic for now
const actionableBalance = balance - 5000;
const platformShare = Math.floor(actionableBalance * 0.01);
const merchantShare = actionableBalance - platformShare;
console.log(`[Sweep SOL] Total: ${balance / LAMPORTS_PER_SOL} SOL`);
console.log(`[Sweep SOL] Platform Share: ${platformShare / LAMPORTS_PER_SOL} SOL`);
console.log(`[Sweep SOL] Merchant Share: ${merchantShare / LAMPORTS_PER_SOL} SOL`);
// Off-chain transaction split using SystemProgram
const transaction = new Transaction().add(
SystemProgram.transfer({
fromPubkey: pubKey,
toPubkey: new PublicKey(platformAddress),
lamports: platformShare,
}),
SystemProgram.transfer({
fromPubkey: pubKey,
toPubkey: new PublicKey(merchantAddress),
lamports: merchantShare,
})
);
// Uncomment the following line to actually send the transaction on devnet
// const txSig = await sendAndConfirmTransaction(this.solConnection, transaction, [tempKeypair]);
const mockTxSig = bs58.encode(ethers.randomBytes(32));
return {
success: true,
platformTx: mockTxSig,
merchantTx: mockTxSig
};
} else {
// Processing SPL tokens (USDC/USDT)
const tokenMint = new PublicKey(STABLECOIN_ADDRESSES['SOLANA'][tokenSymbol]);
const tempAta = await getAssociatedTokenAddress(tokenMint, pubKey);
// For real transactions we would:
// 1. Check/create ATAs for platform & merchant
// 2. Add transfer instructions
// 3. Send transaction
console.log(`[Sweep SOL SPL] Mint: ${tokenMint.toBase58()}`);
return {
success: true,
platformTx: 'sol_mock_tx_spl',
merchantTx: 'sol_mock_tx_spl'
};
// Check if wallet needs SOL for gas
const solBalance = await this.solConnection.getBalance(pubKey);
if (solBalance < 5000000 && tokenSymbol !== 'SOL') {
console.log(`[Sweep SOL] Low SOL for gas, fueling...`);
}
return {
success: true,
platformTx: 'sol_mock_tx_' + Math.random().toString(36).substring(7),
merchantTx: 'sol_mock_tx_' + Math.random().toString(36).substring(7)
};
}
/**
@@ -188,53 +144,36 @@ export class CryptoEngine {
error?: string;
}> {
try {
const tokenConfig = this.getTokenConfig(tokenSymbol || 'USDT');
if (!tokenConfig) return { success: false, error: "Token not supported in config" };
if (this.network === 'SOLANA') {
const pubKey = new PublicKey(address);
if (!tokenSymbol || tokenSymbol === 'SOL') {
if (tokenConfig.address === 'NATIVE') {
const balance = await this.solConnection.getBalance(pubKey);
const balanceInSol = balance / LAMPORTS_PER_SOL;
if (balanceInSol >= parseFloat(expectedAmount)) {
return { success: true };
}
if (balanceInSol >= parseFloat(expectedAmount)) return { success: true };
} else {
const tokenMint = new PublicKey(STABLECOIN_ADDRESSES['SOLANA'][tokenSymbol]);
const tokenMint = new PublicKey(tokenConfig.address);
const ata = await getAssociatedTokenAddress(tokenMint, pubKey);
try {
const accountInfo = await getAccount(this.solConnection, ata);
// Using mock decimals 6 for USDT/USDC
const balance = Number(accountInfo.amount) / 1_000_000;
if (balance >= parseFloat(expectedAmount)) {
return { success: true };
}
} catch (e) {
// Account might not exist yet
}
const balance = Number(accountInfo.amount) / Math.pow(10, tokenConfig.decimals);
if (balance >= parseFloat(expectedAmount)) return { success: true };
} catch (e) {}
}
} else {
if (!tokenSymbol || tokenSymbol === 'ETH' || tokenSymbol === 'MATIC') {
if (tokenConfig.address === 'NATIVE') {
const balance = await this.provider.getBalance(address);
const balanceInEth = ethers.formatEther(balance);
if (parseFloat(balanceInEth) >= parseFloat(expectedAmount)) {
return { success: true };
}
if (parseFloat(balanceInEth) >= parseFloat(expectedAmount)) return { success: true };
} else {
// Check ERC20 balance (USDT/USDC)
const tokenAddress = STABLECOIN_ADDRESSES[this.network][tokenSymbol];
if (!tokenAddress) throw new Error("Unsupported token");
const contract = new ethers.Contract(tokenAddress, ERC20_ABI, this.provider);
const contract = new ethers.Contract(tokenConfig.address, ERC20_ABI, this.provider);
const balance = await contract.balanceOf(address);
const decimals = await contract.decimals();
const formattedBalance = ethers.formatUnits(balance, decimals);
if (parseFloat(formattedBalance) >= parseFloat(expectedAmount)) {
return { success: true };
}
const formattedBalance = ethers.formatUnits(balance, tokenConfig.decimals);
if (parseFloat(formattedBalance) >= parseFloat(expectedAmount)) return { success: true };
}
}
return { success: false };
} catch (error: any) {
return { success: false, error: error.message };