# Проверка адреса

> Регулярные выражения и код для проверки адресов кошельков по сетям (BTC, ERC20, TRC20, SOL, TON и др.) перед созданием сделки через YellowChanger API.

Source: https://docs.yellowchanger.com/ru/validateAddress

Мы используем эти методы для проверки адресов, но если вы не хотите проверять их через наш сервер, вы можете проверить их самостоятельно этим кодом.

**JavaScript**

```javascript
const B58 = "[1-9A-HJ-NP-Za-km-z]";
const BECH32 = "[ac-hj-np-z02-9]";
const BTC_ALPHABET =
          "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
const XRP_ALPHABET =
          "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz";

const EVM = [{ re: /^0x[0-9a-fA-F]{40}$/ }];

const ADDRESS_FORMATS = {
          ERC20: EVM,
          BEP20: EVM,
          ARBITRUM: EVM,
          OPTIMISM: EVM,
          BASE: EVM,
          LINEA: EVM,
          POLYGON: EVM,
          AVALANCHE: EVM,
          SUI: [{ re: /^0x[0-9a-fA-F]{64}$/ }],
          TRC20: [
                    {
                              re: new RegExp("^T" + B58 + "{33}$"),
                              bytes: 25,
                              versions: [0x41],
                    },
          ],
          SOL: [{ re: new RegExp("^" + B58 + "{32,44}$"), bytes: 32 }],
          TON: [
                    { re: /^[EU][Qf][A-Za-z0-9_-]{46}$/ },
                    { re: /^[EU][Qf][A-Za-z0-9+/]{46}$/ },
          ],
          BTC: [
                    {
                              re: new RegExp("^1" + B58 + "{25,33}$"),
                              bytes: 25,
                              versions: [0x00],
                    },
                    {
                              re: new RegExp("^3" + B58 + "{33}$"),
                              bytes: 25,
                              versions: [0x05],
                    },
                    {
                              re: new RegExp(
                                        "^bc1q(" +
                                                  BECH32 +
                                                  "{38}|" +
                                                  BECH32 +
                                                  "{58})$",
                              ),
                    },
                    { re: new RegExp("^bc1p" + BECH32 + "{58}$") },
          ],
          LTC: [
                    {
                              re: new RegExp("^L" + B58 + "{33}$"),
                              bytes: 25,
                              versions: [0x30],
                    },
                    {
                              re: new RegExp("^M" + B58 + "{33}$"),
                              bytes: 25,
                              versions: [0x32],
                    },
                    {
                              re: new RegExp(
                                        "^ltc1q(" +
                                                  BECH32 +
                                                  "{38}|" +
                                                  BECH32 +
                                                  "{58})$",
                              ),
                    },
                    { re: new RegExp("^ltc1p" + BECH32 + "{58}$") },
          ],
          BCH: [
                    { re: new RegExp("^[qp]" + BECH32 + "{41}$") },
                    {
                              re: new RegExp("^1" + B58 + "{25,33}$"),
                              bytes: 25,
                              versions: [0x00],
                    },
                    {
                              re: new RegExp("^3" + B58 + "{33}$"),
                              bytes: 25,
                              versions: [0x05],
                    },
          ],
          DOGE: [
                    {
                              re: new RegExp("^D" + B58 + "{33}$"),
                              bytes: 25,
                              versions: [0x1e],
                    },
                    {
                              re: new RegExp("^[9A]" + B58 + "{33}$"),
                              bytes: 25,
                              versions: [0x16],
                    },
          ],
          DASH: [
                    {
                              re: new RegExp("^X" + B58 + "{33}$"),
                              bytes: 25,
                              versions: [0x4c],
                    },
                    {
                              re: new RegExp("^7" + B58 + "{33}$"),
                              bytes: 25,
                              versions: [0x10],
                    },
          ],
          XMR: [{ re: new RegExp("^[48][a-zA-Z0-9]{94}([a-zA-Z0-9]{11})?$") }],
          XRP: [
                    {
                              re: new RegExp("^r" + B58 + "{24,34}$"),
                              bytes: 25,
                              versions: [0x00],
                              alphabet: XRP_ALPHABET,
                    },
          ],
          NEAR: [
                    {
                              re: /^(?=.{2,64}$)(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$/,
                    },
          ],
          IOST: [{ re: /^[a-z0-9_]{5,11}$/ }],
};

function base58Decode(str, alphabet) {
          const bytes = [];
          for (const char of str) {
                    let carry = alphabet.indexOf(char);
                    if (carry < 0) return null;
                    for (let i = 0; i < bytes.length; i++) {
                              carry += bytes[i] * 58;
                              bytes[i] = carry & 0xff;
                              carry >>= 8;
                    }
                    while (carry > 0) {
                              bytes.push(carry & 0xff);
                              carry >>= 8;
                    }
          }
          for (const char of str) {
                    if (char !== alphabet[0]) break;
                    bytes.push(0);
          }
          return bytes.reverse();
}

function matchesFormat(format, address) {
          if (!format.re.test(address)) return false;
          if (!format.bytes) return true;
          const bytes = base58Decode(address, format.alphabet || BTC_ALPHABET);
          if (!bytes || bytes.length !== format.bytes) return false;
          return !format.versions || format.versions.includes(bytes[0]);
}

function isValidAddress(network, address) {
          const formats = ADDRESS_FORMATS[String(network || "").toUpperCase()];
          if (!formats) return true;
          if (typeof address !== "string") return false;
          return formats.some((format) => matchesFormat(format, address));
}
```

**Python**

```python
import re

B58 = "[1-9A-HJ-NP-Za-km-z]"
BECH32 = "[ac-hj-np-z02-9]"
BTC_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
XRP_ALPHABET = "rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz"

EVM = [{"re": r"^0x[0-9a-fA-F]{40}$"}]

ADDRESS_FORMATS = {
    "ERC20": EVM,
    "BEP20": EVM,
    "ARBITRUM": EVM,
    "OPTIMISM": EVM,
    "BASE": EVM,
    "LINEA": EVM,
    "POLYGON": EVM,
    "AVALANCHE": EVM,
    "SUI": [{"re": r"^0x[0-9a-fA-F]{64}$"}],
    "TRC20": [{"re": r"^T" + B58 + r"{33}$", "bytes": 25, "versions": [0x41]}],
    "SOL": [{"re": r"^" + B58 + r"{32,44}$", "bytes": 32}],
    "TON": [{"re": r"^[EU][Qf][A-Za-z0-9_-]{46}$"}, {"re": r"^[EU][Qf][A-Za-z0-9+/]{46}$"}],
    "BTC": [
        {"re": r"^1" + B58 + r"{25,33}$", "bytes": 25, "versions": [0x00]},
        {"re": r"^3" + B58 + r"{33}$", "bytes": 25, "versions": [0x05]},
        {"re": r"^bc1q(" + BECH32 + r"{38}|" + BECH32 + r"{58})$"},
        {"re": r"^bc1p" + BECH32 + r"{58}$"},
    ],
    "LTC": [
        {"re": r"^L" + B58 + r"{33}$", "bytes": 25, "versions": [0x30]},
        {"re": r"^M" + B58 + r"{33}$", "bytes": 25, "versions": [0x32]},
        {"re": r"^ltc1q(" + BECH32 + r"{38}|" + BECH32 + r"{58})$"},
        {"re": r"^ltc1p" + BECH32 + r"{58}$"},
    ],
    "BCH": [
        {"re": r"^[qp]" + BECH32 + r"{41}$"},
        {"re": r"^1" + B58 + r"{25,33}$", "bytes": 25, "versions": [0x00]},
        {"re": r"^3" + B58 + r"{33}$", "bytes": 25, "versions": [0x05]},
    ],
    "DOGE": [
        {"re": r"^D" + B58 + r"{33}$", "bytes": 25, "versions": [0x1E]},
        {"re": r"^[9A]" + B58 + r"{33}$", "bytes": 25, "versions": [0x16]},
    ],
    "DASH": [
        {"re": r"^X" + B58 + r"{33}$", "bytes": 25, "versions": [0x4C]},
        {"re": r"^7" + B58 + r"{33}$", "bytes": 25, "versions": [0x10]},
    ],
    "XMR": [
        {"re": r"^[48][a-zA-Z0-9]{94}([a-zA-Z0-9]{11})?$"},
    ],
    "XRP": [{"re": r"^r" + B58 + r"{24,34}$", "bytes": 25, "versions": [0x00], "alphabet": XRP_ALPHABET}],
    "NEAR": [{"re": r"^(?=.{2,64}$)(([a-z\d]+[-_])*[a-z\d]+\.)*([a-z\d]+[-_])*[a-z\d]+$"}],
    "IOST": [{"re": r"^[a-z0-9_]{5,11}$"}],
}


def base58_decode(value, alphabet):
    num = []
    for char in value:
        carry = alphabet.find(char)
        if carry < 0:
            return None
        for i in range(len(num)):
            carry += num[i] * 58
            num[i] = carry & 0xFF
            carry >>= 8
        while carry > 0:
            num.append(carry & 0xFF)
            carry >>= 8
    for char in value:
        if char != alphabet[0]:
            break
        num.append(0)
    return num[::-1]


def matches_format(fmt, address):
    match = re.match(fmt["re"], address)
    if not match or match.end() != len(address):
        return False
    if "bytes" not in fmt:
        return True
    decoded = base58_decode(address, fmt.get("alphabet", BTC_ALPHABET))
    if decoded is None or len(decoded) != fmt["bytes"]:
        return False
    return "versions" not in fmt or decoded[0] in fmt["versions"]


def is_valid_address(network, address):
    formats = ADDRESS_FORMATS.get(str(network or "").upper())
    if formats is None:
        return True
    if not isinstance(address, str):
        return False
    return any(matches_format(fmt, address) for fmt in formats)
```

## Связанные страницы

- [createTrade](https://docs.yellowchanger.com/ru/createTrade.md): Создает новую сделку и возвращает информацию о сделке
- [changeAddress](https://docs.yellowchanger.com/ru/changeAddress.md): Изменить адрес выплаты у обмена. Доступно только если needChangeAddress в getInfo равен true.

---

All methods: https://docs.yellowchanger.com/ru/introduction.md · Index: https://docs.yellowchanger.com/ru/llms.txt · Whole documentation in one file: https://docs.yellowchanger.com/ru/llms-full.txt
