Payouts

use kornrunner\Keccak;
use kornrunner\Secp256k1;

final class Eip712
{
    public static function sign(array $typedData, string $privateKeyHex): string
    {
        $digest = self::hash($typedData);
        $signature = (new Secp256k1())->sign(bin2hex($digest), preg_replace('/^0x/i', '', $privateKeyHex));
        $r = str_pad(gmp_strval($signature->getR(), 16), 64, '0', STR_PAD_LEFT);
        $s = str_pad(gmp_strval($signature->getS(), 16), 64, '0', STR_PAD_LEFT);
        return '0x' . $r . $s . dechex(27 + $signature->getRecoveryParam());
    }

    public static function hash(array $typedData): string
    {
        $types = $typedData['types'];
        return self::keccak("\x19\x01"
            . self::hashStruct('EIP712Domain', $typedData['domain'], $types)
            . self::hashStruct($typedData['primaryType'], $typedData['message'], $types));
    }

    private static function keccak(string $data): string
    {
        return hex2bin(Keccak::hash($data, 256));
    }

    private static function hashStruct(string $type, array $data, array $types): string
    {
        $encoded = self::keccak(self::encodeType($type, $types));
        foreach ($types[$type] as $field) {
            $encoded .= self::encodeValue($field['type'], $data[$field['name']], $types);
        }
        return self::keccak($encoded);
    }

    private static function encodeType(string $primary, array $types): string
    {
        $deps = array_values(array_diff(self::dependencies($primary, $types), [$primary]));
        sort($deps);
        $out = '';
        foreach (array_merge([$primary], $deps) as $type) {
            $fields = array_map(fn (array $f) => $f['type'] . ' ' . $f['name'], $types[$type]);
            $out .= $type . '(' . implode(',', $fields) . ')';
        }
        return $out;
    }

    private static function dependencies(string $type, array $types, array $found = []): array
    {
        $type = preg_replace('/\[\]$/', '', $type);
        if (in_array($type, $found, true) || !isset($types[$type])) {
            return $found;
        }
        $found[] = $type;
        foreach ($types[$type] as $field) {
            $found = self::dependencies($field['type'], $types, $found);
        }
        return $found;
    }

    private static function encodeValue(string $type, mixed $value, array $types): string
    {
        if (str_ends_with($type, '[]')) {
            $inner = substr($type, 0, -2);
            return self::keccak(implode('', array_map(fn ($v) => self::encodeValue($inner, $v, $types), $value)));
        }
        if (isset($types[$type])) {
            return self::hashStruct($type, $value, $types);
        }
        return match (true) {
            $type === 'string' => self::keccak($value),
            $type === 'address' => str_pad(hex2bin(substr(strtolower($value), 2)), 32, "\0", STR_PAD_LEFT),
            str_starts_with($type, 'uint') => hex2bin(str_pad(gmp_strval(gmp_init((string) $value, 10), 16), 64, '0', STR_PAD_LEFT)),
            default => throw new InvalidArgumentException("unsupported EIP-712 type $type"),
        };
    }
}

async function signTypedData(typedData, account) {
  return window.ethereum.request({
    method: "eth_signTypedData_v4",
    params: [account, JSON.stringify(typedData)],
  });
}

from eth_account import Account


def _with_ints(types, type_name, value):
    if type_name.endswith("[]"):
        return [_with_ints(types, type_name[:-2], v) for v in value]
    if type_name in types:
        return {f["name"]: _with_ints(types, f["type"], value[f["name"]]) for f in types[type_name]}
    if type_name.startswith(("uint", "int")):
        return int(value)
    return value


def sign_typed_data(typed_data, private_key):
    types = typed_data["types"]
    full = dict(typed_data)
    full["message"] = _with_ints(types, typed_data["primaryType"], typed_data["message"])
    full["domain"] = _with_ints(types, "EIP712Domain", typed_data["domain"])
    signed = Account.sign_typed_data(private_key, full_message=full)
    return "0x" + bytes(signed.signature).hex()

import { ethers } from "ethers";

async function signTypedData(typedData, privateKey) {
  const wallet = new ethers.Wallet(privateKey);
  const { EIP712Domain, ...types } = typedData.types;
  return wallet.signTypedData(typedData.domain, types, typedData.message);
}

$created = $client->call('POST', '/v1/payouts', $withdrawal);
$signature = Eip712::sign($created['typed_data'], getenv('MERCHANT_PRIVATE_KEY'));
$client->call('POST', '/v1/payouts/authorize', ['payout' => $created['payout'], 'signature' => $signature]);

const created = await fetch("/api/payouts", { method: "POST", body: JSON.stringify(withdrawal) }).then((r) => r.json());
const [account] = await window.ethereum.request({ method: "eth_requestAccounts" });
const signature = await signTypedData(created.typed_data, account);
await fetch("/api/payouts/authorize", {
  method: "POST",
  body: JSON.stringify({ payout: created.payout, signature }),
});

created = client.call("POST", "/v1/payouts", withdrawal)
signature = sign_typed_data(created["typed_data"], os.environ["MERCHANT_PRIVATE_KEY"])
client.call("POST", "/v1/payouts/authorize", {"payout": created["payout"], "signature": signature})

const created = await client.call("POST", "/v1/payouts", withdrawal);
const signature = await signTypedData(created.typed_data, process.env.MERCHANT_PRIVATE_KEY);
await client.call("POST", "/v1/payouts/authorize", { payout: created.payout, signature });

$created = $client->call('POST', '/v1/payouts/batch', $batch);
$signature = Eip712::sign($created['typed_data'], getenv('MERCHANT_PRIVATE_KEY'));
$client->call('POST', '/v1/payouts/batch/authorize', ['batch' => $created['batch'], 'signature' => $signature]);

const created = await fetch("/api/payouts/batch", { method: "POST", body: JSON.stringify(batch) }).then((r) => r.json());
const [account] = await window.ethereum.request({ method: "eth_requestAccounts" });
const signature = await signTypedData(created.typed_data, account);
await fetch("/api/payouts/batch/authorize", {
  method: "POST",
  body: JSON.stringify({ batch: created.batch, signature }),
});

created = client.call("POST", "/v1/payouts/batch", batch)
signature = sign_typed_data(created["typed_data"], os.environ["MERCHANT_PRIVATE_KEY"])
client.call("POST", "/v1/payouts/batch/authorize", {"batch": created["batch"], "signature": signature})

const created = await client.call("POST", "/v1/payouts/batch", batch);
const signature = await signTypedData(created.typed_data, process.env.MERCHANT_PRIVATE_KEY);
await client.call("POST", "/v1/payouts/batch/authorize", { batch: created.batch, signature });

function checkBatch(array $typedData, array $want): void
{
    $items = $typedData['message']['items'];
    if (count($items) !== count($want)) {
        throw new RuntimeException('batch size does not match');
    }
    foreach ($items as $i => $item) {
        if (strcasecmp($item['recipient'], tronToEvm($want[$i]['address'])) !== 0
            || $item['amount'] !== $want[$i]['base_units']) {
            throw new RuntimeException("item $i does not match withdrawal {$want[$i]['id']}");
        }
    }
}

async function checkBatch(typedData, want) {
  const { items } = typedData.message;
  if (items.length !== want.length) throw new Error("batch size does not match");
  for (const [i, item] of items.entries()) {
    const recipient = await tronToEvm(want[i].address);
    if (item.recipient.toLowerCase() !== recipient || item.amount !== want[i].baseUnits) {
      throw new Error(`item ${i} does not match withdrawal ${want[i].id}`);
    }
  }
}

def check_batch(typed_data, want):
    items = typed_data["message"]["items"]
    if len(items) != len(want):
        raise ValueError("batch size does not match")
    for i, item in enumerate(items):
        recipient = tron_to_evm(want[i]["address"])
        if item["recipient"].lower() != recipient or item["amount"] != want[i]["base_units"]:
            raise ValueError(f"item {i} does not match withdrawal {want[i]['id']}")

function checkBatch(typedData, want) {
  const { items } = typedData.message;
  if (items.length !== want.length) throw new Error("batch size does not match");
  items.forEach((item, i) => {
    const recipient = tronToEvm(want[i].address);
    if (item.recipient.toLowerCase() !== recipient || item.amount !== want[i].baseUnits) {
      throw new Error(`item ${i} does not match withdrawal ${want[i].id}`);
    }
  });
}

use Web3p\EthereumTx\Transaction;

function signEvmApproval(array $tx, string $privateKey): string
{
    $transaction = new Transaction([
        'nonce' => $tx['nonce'],
        'gasPrice' => $tx['gasPrice'],
        'gas' => $tx['gas'],
        'to' => $tx['to'],
        'value' => $tx['value'],
        'data' => $tx['data'],
        'chainId' => hexdec($tx['chainId']),
    ]);
    return '0x' . $transaction->sign(preg_replace('/^0x/i', '', $privateKey));
}

const built = await fetch("/api/payouts/approval", {
  method: "POST",
  body: JSON.stringify({ network: "bsc", token: "USDT", amount: "100000" }),
}).then((r) => r.json());
const txHash = await window.ethereum.request({
  method: built.wallet_action.method,
  params: built.wallet_action.params,
});

from eth_account import Account


def sign_evm_approval(tx, private_key):
    signed = Account.sign_transaction({
        "to": tx["to"],
        "data": tx["data"],
        "value": int(tx["value"], 16),
        "nonce": int(tx["nonce"], 16),
        "gas": int(tx["gas"], 16),
        "gasPrice": int(tx["gasPrice"], 16),
        "chainId": int(tx["chainId"], 16),
    }, private_key)
    return "0x" + bytes(signed.raw_transaction).hex()

import { ethers } from "ethers";

async function signEvmApproval(tx, privateKey) {
  return new ethers.Wallet(privateKey).signTransaction({
    type: 0,
    to: tx.to,
    data: tx.data,
    value: BigInt(tx.value),
    nonce: Number(tx.nonce),
    gasLimit: BigInt(tx.gas),
    gasPrice: BigInt(tx.gasPrice),
    chainId: BigInt(tx.chainId),
  });
}

$built = $client->call('POST', '/v1/payouts/approval', ['network' => 'bsc', 'token' => 'USDT', 'amount' => '100000']);
$signed = signEvmApproval($built['transaction'], getenv('MERCHANT_PRIVATE_KEY'));
$client->call('POST', '/v1/payouts/approval/broadcast', [
    'network' => 'bsc',
    'token' => 'USDT',
    'amount' => '100000',
    'signed_transaction' => $signed,
]);

built = client.call("POST", "/v1/payouts/approval", {"network": "bsc", "token": "USDT", "amount": "100000"})
signed = sign_evm_approval(built["transaction"], os.environ["MERCHANT_PRIVATE_KEY"])
client.call("POST", "/v1/payouts/approval/broadcast", {
    "network": "bsc", "token": "USDT", "amount": "100000", "signed_transaction": signed,
})

const built = await client.call("POST", "/v1/payouts/approval", { network: "bsc", token: "USDT", amount: "100000" });
const signed = await signEvmApproval(built.transaction, process.env.MERCHANT_PRIVATE_KEY);
await client.call("POST", "/v1/payouts/approval/broadcast", {
  network: "bsc", token: "USDT", amount: "100000", signed_transaction: signed,
});

use kornrunner\Secp256k1;

function signTronTxId(string $txId, string $privateKey): string
{
    $signature = (new Secp256k1())->sign($txId, preg_replace('/^0x/i', '', $privateKey));
    return str_pad(gmp_strval($signature->getR(), 16), 64, '0', STR_PAD_LEFT)
        . str_pad(gmp_strval($signature->getS(), 16), 64, '0', STR_PAD_LEFT)
        . dechex(27 + $signature->getRecoveryParam());
}

const usdt = await window.tronWeb.contract().at("TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t");
await usdt.approve(PAYOUT_ROUTER_T_ADDRESS, "100000000000").send();

from eth_account import Account


def sign_tron_tx_id(tx_id, private_key):
    return bytes(Account.unsafe_sign_hash(bytes.fromhex(tx_id), private_key).signature).hex()

import { ethers } from "ethers";

function signTronTxId(txId, privateKey) {
  return new ethers.SigningKey(privateKey).sign("0x" + txId).serialized;
}

$request = ['network' => 'tron', 'token' => 'USDT', 'amount' => '100000', 'batch' => true];
$built = $client->call('POST', '/v1/payouts/approval', $request);
$client->call('POST', '/v1/payouts/approval/broadcast', $request + [
    'raw_transaction' => $built['transaction']['raw_transaction'],
    'signature' => signTronTxId($built['transaction']['tx_id'], getenv('TRON_PAYOUT_PRIVATE_KEY')),
]);

request = {"network": "tron", "token": "USDT", "amount": "100000", "batch": True}
built = client.call("POST", "/v1/payouts/approval", request)
client.call("POST", "/v1/payouts/approval/broadcast", {
    **request,
    "raw_transaction": built["transaction"]["raw_transaction"],
    "signature": sign_tron_tx_id(built["transaction"]["tx_id"], os.environ["TRON_PAYOUT_PRIVATE_KEY"]),
})

const request = { network: "tron", token: "USDT", amount: "100000", batch: true };
const built = await client.call("POST", "/v1/payouts/approval", request);
await client.call("POST", "/v1/payouts/approval/broadcast", {
  ...request,
  raw_transaction: built.transaction.raw_transaction,
  signature: signTronTxId(built.transaction.tx_id, process.env.TRON_PAYOUT_PRIVATE_KEY),
});

function waitForApproval(Time2payClient $client, string $network, string $token, string $txHash, bool $batch): void
{
    $deadline = time() + 300;
    while (time() < $deadline) {
        $st = $client->call('POST', '/v1/payouts/approval/status', [
            'network' => $network,
            'token' => $token,
            'tx_hash' => $txHash,
            'batch' => $batch,
        ]);
        if ($st['status'] === 'confirmed') {
            return;
        }
        if ($st['status'] === 'failed') {
            throw new RuntimeException("approval $txHash reverted; it granted nothing");
        }
        sleep(3);
    }
    throw new RuntimeException("approval $txHash is still not confirmed; check it before approving again");
}

async function waitForApproval(client, { network, token, txHash, batch = false }) {
  const deadline = Date.now() + 5 * 60_000;
  while (Date.now() < deadline) {
    const st = await client.call("POST", "/v1/payouts/approval/status", { network, token, tx_hash: txHash, batch });
    if (st.status === "confirmed") return;
    if (st.status === "failed") throw new Error(`approval ${txHash} reverted; it granted nothing`);
    await new Promise((r) => setTimeout(r, 3000));
  }
  throw new Error(`approval ${txHash} is still not confirmed; check it before approving again`);
}

import time


def wait_for_approval(client, network, token, tx_hash, batch=False):
    deadline = time.time() + 300
    while time.time() < deadline:
        st = client.call("POST", "/v1/payouts/approval/status",
                         {"network": network, "token": token, "tx_hash": tx_hash, "batch": batch})
        if st["status"] == "confirmed":
            return
        if st["status"] == "failed":
            raise RuntimeError(f"approval {tx_hash} reverted; it granted nothing")
        time.sleep(3)
    raise TimeoutError(f"approval {tx_hash} is still not confirmed; check it before approving again")

async function waitForApproval(client, { network, token, txHash, batch = false }) {
  const deadline = Date.now() + 5 * 60_000;
  while (Date.now() < deadline) {
    const st = await client.call("POST", "/v1/payouts/approval/status", { network, token, tx_hash: txHash, batch });
    if (st.status === "confirmed") return;
    if (st.status === "failed") throw new Error(`approval ${txHash} reverted; it granted nothing`);
    await new Promise((r) => setTimeout(r, 3000));
  }
  throw new Error(`approval ${txHash} is still not confirmed; check it before approving again`);
}