Networks and amounts

function toAmount(string $minor, int $decimals): string
{
    return bcdiv($minor, bcpow('10', (string) $decimals), $decimals);
}

function toAmount(minor, decimals) {
  const value = BigInt(minor);
  const scale = 10n ** BigInt(decimals);
  const whole = value / scale;
  const fraction = (value % scale).toString().padStart(decimals, "0");
  return decimals === 0 ? whole.toString() : `${whole}.${fraction}`;
}

from decimal import Decimal


def to_amount(minor, decimals):
    return format(Decimal(minor).scaleb(-decimals).quantize(Decimal(1).scaleb(-decimals)), "f")

function toAmount(minor, decimals) {
  const value = BigInt(minor);
  const scale = 10n ** BigInt(decimals);
  const whole = value / scale;
  const fraction = (value % scale).toString().padStart(decimals, "0");
  return decimals === 0 ? whole.toString() : `${whole}.${fraction}`;
}

function tronToEvm(string $address): string
{
    $alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
    $n = gmp_init(0);
    foreach (str_split($address) as $c) {
        $i = strpos($alphabet, $c);
        if ($i === false) {
            throw new InvalidArgumentException("not a Tron address: $address");
        }
        $n = gmp_add(gmp_mul($n, 58), $i);
    }
    $raw = str_pad(gmp_export($n), 25, "\0", STR_PAD_LEFT);
    $check = substr(hash('sha256', hash('sha256', substr($raw, 0, 21), true), true), 0, 4);
    if (strlen($raw) !== 25 || $raw[0] !== "\x41" || $check !== substr($raw, 21)) {
        throw new InvalidArgumentException("not a Tron address: $address");
    }
    return '0x' . bin2hex(substr($raw, 1, 20));
}

const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

export async function tronToEvm(address) {
  let n = 0n;
  for (const c of address) {
    const i = BASE58.indexOf(c);
    if (i < 0) throw new Error(`not a Tron address: ${address}`);
    n = n * 58n + BigInt(i);
  }
  const hex = n.toString(16).padStart(50, "0");
  const raw = Uint8Array.from(hex.match(/../g), (b) => parseInt(b, 16));
  const first = await crypto.subtle.digest("SHA-256", raw.slice(0, 21));
  const check = new Uint8Array(await crypto.subtle.digest("SHA-256", first));
  if (hex.length !== 50 || raw[0] !== 0x41 || check.slice(0, 4).some((b, i) => b !== raw[21 + i])) {
    throw new Error(`not a Tron address: ${address}`);
  }
  return "0x" + hex.slice(2, 42);
}

import hashlib

BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"


def tron_to_evm(address):
    n = 0
    for c in address:
        i = BASE58.find(c)
        if i < 0:
            raise ValueError(f"not a Tron address: {address}")
        n = n * 58 + i
    if n.bit_length() > 200:
        raise ValueError(f"not a Tron address: {address}")
    raw = n.to_bytes(25, "big")
    check = hashlib.sha256(hashlib.sha256(raw[:21]).digest()).digest()[:4]
    if raw[0] != 0x41 or check != raw[21:]:
        raise ValueError(f"not a Tron address: {address}")
    return "0x" + raw[1:21].hex()

import { createHash } from "node:crypto";

const BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
const sha256 = (bytes) => createHash("sha256").update(bytes).digest();

export function tronToEvm(address) {
  let n = 0n;
  for (const c of address) {
    const i = BASE58.indexOf(c);
    if (i < 0) throw new Error(`not a Tron address: ${address}`);
    n = n * 58n + BigInt(i);
  }
  const raw = Buffer.from(n.toString(16).padStart(50, "0"), "hex");
  const check = sha256(sha256(raw.subarray(0, 21))).subarray(0, 4);
  if (raw.length !== 25 || raw[0] !== 0x41 || !check.equals(raw.subarray(21))) {
    throw new Error(`not a Tron address: ${address}`);
  }
  return "0x" + raw.subarray(1, 21).toString("hex");
}