hbengine 0.2.3

package/engine-sdk/kit/wallet-format.js

@@ -0,0 +1,423 @@
+/* THE KIT'S CORE. This file is the source of the money rule for every game.
+
+   Brought over from dice on 07.09.2026 WITHOUT changing the rule: dice goes first
+   and serves as the reference, so the kit takes its module as it is instead of
+   rewriting it. The version taken is the one from `main` — the blackjack branch
+   carried an older copy, without the `viewUnitCrypto` fix (the wallet's own
+   currency name is asked for first, because in a fiat display the platform
+   renames `symbol`). Divergences exactly like that are what the kit is for.
+
+   Dice itself still keeps its own copy and will move onto the kit in its next
+   assembly (ADR-004): touching an almost finished game for the sake of tidiness
+   costs more than waiting. While there are two copies, the stand's gate
+   `scripts/kit-drift-contract.mjs` holds them together — one and the same set of
+   cases runs through both and the answers are compared, so they cannot drift
+   apart silently.
+
+   Design decisions and the threat review — `docs/DESIGN.md`. */
+
+import { fiatCoinSrc } from './fiat-coins.js';
+
+/* The host wallet's contract: unit, precision, format, parsing, conversion.
+   ---------------------------------------------------------------------------
+   WHY THIS MODULE EXISTS. A game has two lives. On a standalone page it is its
+   own platform: the player switches the display currency (USD / BTC / ETH) and
+   the game takes rates from its own table. On a platform it is the other way
+   round — the money, the wallet, the rate and the precision belong to the host,
+   and a table of our own can only disagree with his data. And so it did: the host
+   sent "USDT is worth exactly 1", the table said 1.0011990, and the bet field
+   lost money on it — 1 USDT typed in came back as 0.99880245.
+
+   Hence the simple rule: THERE IS A HOST WALLET — every currency fact is his,
+   our own table takes no part. No wallet — the old standalone path.
+
+   The rules below are not invented: this is the contract the platform already
+   implements on its side (its `getBetInputPlaceholder` /
+   `formatWalletBetTopText`, which repeat the format of the older games).
+   Counting differently means disagreeing with it again:
+
+     crypto display (isFiat: false)
+       field    — the wallet's currency, min(betPrecision ?? decimals ?? 8, 8)
+                  decimals, the coin icon from the platform
+       caption  — none: in this mode the platform gives no fiat and sends rate 1
+     fiat display (isFiat: true)
+       field    — the CHOSEN fiat, precision as in its header (JPY whole, two
+                  decimals for most), with that fiat's flag
+       caption  — the wallet's currency, at its own precision
+
+   Corrected on 22.09.2026 against the platform's own answers: the caption used to
+   be in dollars and the field always carried two decimals and a dollar sign —
+   which is true only for a USD display.
+
+   Inside the game the amount is ALWAYS in the wallet's units: that is what the
+   server takes (`amount` + `currency`). The fiat mode is presentation only: the
+   dollars typed in are converted at the host's rate, and the crypto amount is
+   what goes to the server.
+
+   No rate — no conversion shown. Inventing a rate is not allowed, and a wrong
+   number is worse than none: limits and settlement are the server's anyway. What
+   to do about a rate that never loaded is the platform's concern, not the game's.
+
+   The module is deliberately dependency-free: a separate test from the stand
+   checks it, and dragging Svelte stores along for that is unnecessary. */
+
+/** Crypto precision is cut at eight decimals — as on the platform. */
+var MAX_DECIMALS = 8;
+
+function toNumber(v) {
+    var n = typeof v === 'number' ? v : parseFloat(String(v == null ? '' : v).replace(/[\s,]/g, ''));
+    return isFinite(n) ? n : 0;
+}
+
+function toWholeNumber(v) {
+    var n = Number(v);
+    return isFinite(n) ? Math.max(0, Math.trunc(n)) : null;
+}
+
+/** Is there a host wallet at all? The answer to this switches every rule below. */
+export function hasWallet(wallet) {
+    return !!(wallet && typeof wallet === 'object');
+}
+
+/** Is the WALLET ITSELF a fiat one (not merely a fiat display)?
+
+    Telling the two apart is mandatory. The platform's `isFiat` means "show in
+    fiat", and the wallet may well stay crypto: symbol BTC, display fiat USD.
+    Whoever confuses the two states converts limits wrongly — they arrive in
+    dollars, and a crypto wallet has to divide them by the rate while a fiat one
+    does not. The mark: a fiat display AND the wallet's currency matching the
+    display currency (or a display with no currency named). */
+export function walletIsFiat(wallet) {
+    if (!hasWallet(wallet) || wallet.isFiat !== true) return false;
+    var shown = (typeof wallet.fiat === 'string' && wallet.fiat) ||
+                (typeof wallet.currentFiat === 'string' && wallet.currentFiat) || '';
+    var own = (typeof wallet.symbol === 'string' && wallet.symbol) ||
+              (typeof wallet.name === 'string' && wallet.name) || '';
+    return !shown || shown.toUpperCase() === own.toUpperCase();
+}
+
+/** Are we showing fiat instead of the wallet's currency? */
+export function isFiatView(wallet) {
+    return !!(wallet && wallet.isFiat === true);
+}
+
+/* A fiat amount is shown EXACTLY AS IN THE PLATFORM'S HEADER (owner's decision,
+   22.09.2026): Intl en-US with its signs and with no fractional part for the
+   currencies it prints whole. Taken from its header; a sign it does not override
+   is the Intl en-US one. */
+var HEADER_SIGNS = {
+    EUR: '€', GBP: '£', JPY: '¥', CHF: 'CHF', USD: '$', CAD: 'CA$',
+    AUD: 'A$', CNY: 'CN¥', MXN: 'MX$', TWD: 'NT$', ARS: 'AR$'
+};
+var WHOLE_FIATS = { CLP: true, IDR: true, JPY: true, KRW: true, VND: true };
+
+/** How many decimals the platform's header gives a fiat: zero for CLP, IDR, JPY,
+    KRW and VND, otherwise as many as Intl gives that currency (two for most). */
+export function fiatPrecision(code) {
+    var upper = String(code == null ? '' : code).trim().toUpperCase();
+    if (WHOLE_FIATS[upper]) return 0;
+    try {
+        var digits = new Intl.NumberFormat('en-US', { style: 'currency', currency: upper })
+            .resolvedOptions().maximumFractionDigits;
+        return typeof digits === 'number' ? digits : 2;
+    } catch (e) {
+        return 2;
+    }
+}
+
+/** A fiat's sign by its code — the way the platform's header prints it: $ for
+    USD, € for EUR, CA$ for CAD. No sign for the code (or the code is not ISO) —
+    we return the code itself: it is more honest than an invented sign. */
+export function fiatSymbol(code) {
+    var upper = String(code == null ? '' : code).trim().toUpperCase();
+    if (!upper) return '';
+    if (HEADER_SIGNS[upper]) return HEADER_SIGNS[upper];
+    try {
+        var parts = new Intl.NumberFormat('en-US', {
+            style: 'currency',
+            currency: upper,
+            currencyDisplay: 'symbol'
+        }).formatToParts(0);
+        for (var i = 0; i < parts.length; i++) {
+            if (parts[i].type === 'currency' && parts[i].value) return parts[i].value;
+        }
+    } catch (e) { /* the code is not ISO — we return it as it is below */ }
+    return upper;
+}
+
+/** The platform's picture for a fiat — the round flag its header and its "Wallet
+    settings" draw (`/img/flags/round/<code>.svg`, served by the storefront the
+    game is mounted into). Empty when the code is not three letters. */
+export function fiatFlagSrc(code) {
+    var lower = String(code == null ? '' : code).trim().toLowerCase();
+    return /^[a-z]{3}$/.test(lower) ? '/img/flags/round/' + lower + '.svg' : '';
+}
+
+/** THE PICTURE OF A FIAT IS OUR OWN COIN (owner, 2026-10-08: the flags "look
+    silly"). `fiat-coins.js` carries a struck coin for every fiat the platform
+    offers; a fiat outside that set still gets the platform's round flag. */
+export function fiatMarkSrc(code) {
+    return fiatCoinSrc(code) || fiatFlagSrc(code);
+}
+
+/* IS THIS CURRENCY A FIAT — we ask the world's list, not one of our own.
+
+   The wallet names its currency, and the game needs to know whether that is a
+   country's money (EUR, JPY) or a coin (BTC, USDT): a fiat's picture is the
+   platform's round flag, a coin's is its icon. A list of our own would be a copy
+   of the platform's set of wallets: it drifts the moment a currency appears
+   there, and it drifts silently. `Intl.supportedValuesOf('currency')` is the
+   ISO-4217 list the browser already carries: every fiat is in it and not a single
+   coin. Where the browser does not have it, nobody counts as fiat here and the
+   old coin path works: an old engine loses the flag, not the game. */
+var ISO_CURRENCIES = null;
+
+export function isFiatCode(code) {
+    var upper = String(code == null ? '' : code).trim().toUpperCase();
+    if (!/^[A-Z]{3}$/.test(upper)) return false;
+    if (ISO_CURRENCIES == null) {
+        try {
+            ISO_CURRENCIES = new Set(Intl.supportedValuesOf('currency'));
+        } catch (e) {
+            ISO_CURRENCIES = new Set();
+        }
+    }
+    return ISO_CURRENCIES.has(upper);
+}
+
+/** The currency mark in the panel's FIELDS when the fiat display is on.
+
+    WHY. The mark used to be chosen by the currency code, and in a fiat display
+    the platform sends `symbol: "USD"` — so the chain of checks reached the final
+    "well, let it be USDT". Next to an amount of 0.00 stood a crypto mark: a fiat
+    amount with a crypto sign. The rule is the opposite and simple: showing fiat
+    means a fiat mark.
+
+    THE PLATFORM DRAWS THE ICON, AND ONLY IT. It does have a set of fiat icons —
+    usd.svg, eur.svg, jpy.svg, inr.svg, cad.svg are visible in its wallet — and
+    the channel for passing one is described by the launch contract: `iconFiat`.
+    The game takes what lies in that channel and substitutes NOTHING for it.
+
+    WHY THERE IS NO FALLBACK SIGN. A "$" of our own drawn where the picture never
+    arrived would look like a working state, and the disagreement with the
+    platform would live unnoticed. Let it be visible that the picture did not
+    load: a breakage has to be visible at once to whoever looks at the game, not
+    only to whoever reads the code.
+
+    What lies in that channel right now is a question for the platform: on dev
+    2026-09-05 USDT's `iconFiat` and `icon` point at the same 10.png, that is, in
+    a fiat display a crypto coin stands next to the amount "0.00". That is its
+    data and it is fixed on its side; the game only shows what was passed.
+
+    THE ROUND RECEIPT DOES NOT COME HERE, and that is not an oversight. In the
+    history popup the mark is the currency the round was PLAYED in: a fact of a
+    finished round. So the crypto icon stays there and only the number becomes
+    fiat, with the sign after the amount. The reference does the same.
+
+    THE CRYPTO DISPLAY TAKES THE PLATFORM'S ICON TOO (21.09.2026): `icon`, the
+    picture of the wallet's coin. Before that the field drew signs of its own, and
+    one wallet was shown with one picture in the platform's header and another one
+    in the game.
+
+    THE CHOSEN FIAT'S FLAG, NOT THE DOLLAR (owner's decision, 22.09.2026). The
+    platform sends the same `iconFiat` for every fiat — the dollar picture 10.png
+    — and a player counting in euro saw a dollar sign. The field takes the
+    platform's own flag of the chosen fiat (the picture its header and "Wallet
+    settings" draw), and `iconFiat` stays as the fallback in case the flag does
+    not load. A coin has its fallback too: the platform's picture did not load (on
+    dev its host answers 522 for ETH and BTC) — the field draws the built-in mark
+    (`fallback: null`) rather than a broken picture. */
+export function coinMark(wallet) {
+    if (!hasWallet(wallet)) return null;
+    var fallback = typeof wallet.iconFiat === 'string' ? wallet.iconFiat : '';
+    if (isFiatView(wallet)) {
+        var flag = fiatMarkSrc(viewUnit(wallet));
+        return flag ? { host: flag, fallback: fallback } : { host: fallback, fallback: '' };
+    }
+    /* A FIAT WALLET STAYS FIAT WITH THE DISPLAY OFF TOO (owner, 22.09.2026: "the
+       fiat equivalent is off right now, so the fields must carry the euro mark;
+       had it been on, the dollar"). The rule above was written for crypto: with
+       the display off the platform sends the wallet coin's icon, and for a cash
+       wallet that is a picture its own host does not have — EUR asks for
+       `coin/17/39.png`, the host answers 522, the field stood empty for twenty
+       seconds and then took the built-in mark, which gave tether to everything
+       except BTC and ETH. A euro wallet wore the USDT mark. The platform's header
+       draws such a wallet a flag — now the field draws the same one; `iconFiat`
+       stays as the fallback. */
+    var own = viewUnitCrypto(wallet);
+    if (isFiatCode(own)) {
+        var ownFlag = fiatMarkSrc(own);
+        if (ownFlag) return { host: ownFlag, fallback: fallback };
+    }
+    var icon = typeof wallet.icon === 'string' ? wallet.icon.trim() : '';
+    return icon ? { host: icon, fallback: null } : null;
+}
+
+/** The precision of the WALLET ITSELF — the amount lives in it inside the game
+    and goes to the server in it. */
+export function walletPrecision(wallet) {
+    if (!hasWallet(wallet)) return 2;
+    var bp = toWholeNumber(wallet.betPrecision);
+    if (bp != null) return Math.min(bp, MAX_DECIMALS);
+    var dec = toWholeNumber(wallet.decimals);
+    if (dec != null) return Math.min(dec, MAX_DECIMALS);
+    var p = toWholeNumber(wallet.precision);
+    if (p != null) return Math.min(p, MAX_DECIMALS);
+    return MAX_DECIMALS;
+}
+
+/** A round's payout at the wallet's precision — the number money is moved by.
+ *
+ * A function of its own rather than a `round2` on the spot, because the dice
+ * multiplier is not a round one: at 2.0002 and a stake of 0.1 the payout is
+ * 0.20002, and rounding to cents loses 0.00002. The loss is not cosmetic — the
+ * platform's header keeps its own count from what it was told, and that
+ * difference stays in it forever: a measurement taken on 2026-09-04 showed the
+ * server at 199968.89446929 against 199968.89444929 in the header.
+ *
+ * Rounding to the NEAREST, not down as for a stake: a stake is truncated so that
+ * the player does not bet more than they typed, while a payout is a result the
+ * server has already computed, and it may be neither lowered nor raised.
+ */
+export function payoutAtWalletPrecision(amount, mult, wallet) {
+    var n = Number(amount) * Number(mult);
+    if (!isFinite(n) || n <= 0) return 0;
+    var dp = walletPrecision(wallet);
+    var f = Math.pow(10, dp);
+    /* The same scrub of floating noise as in `truncate`: 0.1 × 2.0002 in binary
+       fractions gives 0.20002000000000002. */
+    return Math.round(parseFloat((n * f).toPrecision(15))) / f;
+}
+
+/** The FIELD's precision: in fiat mode the fiat's own precision, as the
+    platform's header prints it (zero for JPY, two for most), otherwise the
+    wallet's precision. */
+export function viewPrecision(wallet) {
+    if (!hasWallet(wallet)) return 2;
+    return isFiatView(wallet) ? fiatPrecision(viewUnit(wallet)) : walletPrecision(wallet);
+}
+
+/** The label of the field's unit. */
+export function viewUnit(wallet) {
+    if (!hasWallet(wallet)) return 'USD';
+    if (isFiatView(wallet)) {
+        return (typeof wallet.fiat === 'string' && wallet.fiat) ||
+               (typeof wallet.currentFiat === 'string' && wallet.currentFiat) || 'USD';
+    }
+    return (typeof wallet.symbol === 'string' && wallet.symbol) ||
+           (typeof wallet.name === 'string' && wallet.name) || '';
+}
+
+/** The fiat sign the amount fields put before the number in a fiat view —
+    $ for USD, € for EUR, £ for GBP, CA$ for CAD — the same sign the platform's
+    header prints. `''` in a crypto view: there the coin's own mark says it. */
+export function fieldSign(wallet) {
+    return isFiatView(wallet) ? fiatSymbol(viewUnit(wallet)) : '';
+}
+
+/** The host's rate, when there is one. NOT "how many dollars a unit costs": in a
+    fiat display this is the rate to the CHOSEN fiat (the unit's price in $ ÷ the
+    fiat's price in $), and with the display off the platform sends 1 — there is
+    no fiat there at all. */
+export function hostRate(wallet) {
+    if (!hasWallet(wallet)) return null;
+    var r = Number(wallet.rate);
+    return isFinite(r) && r > 0 ? r : null;
+}
+
+/* ---------- conversion between the wallet amount and the field ---------- */
+
+/** Wallet amount → the field's value (dollars in fiat mode). */
+export function viewFromWallet(amount, wallet) {
+    var n = toNumber(amount);
+    if (!isFiatView(wallet)) return n;
+    var rate = hostRate(wallet);
+    return rate == null ? n : n * rate;
+}
+
+/** The field's value → the wallet amount (what goes to the server). */
+export function walletFromView(value, wallet) {
+    var n = toNumber(value);
+    if (!isFiatView(wallet)) return truncate(n, walletPrecision(wallet));
+    var rate = hostRate(wallet);
+    if (rate == null) return truncate(n, walletPrecision(wallet));
+    return truncate(n / rate, walletPrecision(wallet));
+}
+
+/* We truncate DOWN rather than round: a stake has no right to become larger than
+   the one typed — otherwise the player bets less than they see while the server
+   takes more. */
+function truncate(n, dp) {
+    if (!isFinite(n)) return 0;
+    var f = Math.pow(10, dp);
+    /* A scrub of floating noise before truncating: 1.23456789 * 1e8 gives
+       123456788.99999999, and without it the last decimal would be lost. */
+    return Math.floor(parseFloat((n * f).toPrecision(15))) / f;
+}
+
+/* ---------- strings ---------- */
+
+function groupThousands(wholePart) {
+    return wholePart.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
+}
+
+/** A number → a string with a fixed number of decimals and grouped thousands. */
+export function fmtFixed(n, dp) {
+    var v = toNumber(n);
+    var sign = v < 0 ? '-' : '';
+    var parts = Math.abs(v).toFixed(dp).split('.');
+    return sign + groupThousands(parts[0]) + (parts[1] ? '.' + parts[1] : '');
+}
+
+/** The field's value as a string — at the field's precision. Zero too:
+    `0.00000000`, not `0.00`. */
+export function fmtView(amount, wallet) {
+    return fmtFixed(viewFromWallet(amount, wallet), viewPrecision(wallet));
+}
+
+/** The caption above the field: the opposite unit.
+
+    Fiat in the field — the caption names the wallet's currency. The wallet's
+    currency in the field — THERE IS NO CAPTION: with the display off the platform
+    gives no fiat and sends rate 1, and the old "$… USD" printed a coin amount as
+    dollars (1 BTC as "$1.00 USD"). Its own header shows only the coin in this
+    mode as well. */
+export function counterText(amount, wallet) {
+    if (!hasWallet(wallet)) return null;
+    if (!isFiatView(wallet)) return null;
+    /* The amount is kept in the wallet's currency anyway, no rate is needed here. */
+    return fmtFixed(toNumber(amount), walletPrecision(wallet)) + ' ' + viewUnitCrypto(wallet);
+}
+
+/* The currency of the WALLET ITSELF — the one the money is kept in.
+
+   The name is asked for FIRST, and that is not a matter of taste. In a fiat
+   display the platform renames `symbol` into the fiat (its
+   `normalizeHousegamesCurrencySymbol`: with `isFiat` it takes baseCurrencySymbol
+   → currentFiat → name) and leaves the wallet's currency in `name`. While
+   `symbol` stood first here, the caption above the field named the fiat instead
+   of the crypto: on dev 2026-09-05 in a fiat display it read "0.00000000 USD" —
+   eight decimals of crypto precision with a fiat name.
+
+   On the stand this was invisible: it did not rename `symbol`, and the caption
+   looked right. The stand has since been brought to the platform's rule. */
+function viewUnitCrypto(wallet) {
+    return (typeof wallet.name === 'string' && wallet.name) ||
+           (typeof wallet.symbol === 'string' && wallet.symbol) || '';
+}
+
+/** Parsing what was typed: the field's string → a wallet amount.
+
+    A positive amount smaller than one wallet unit is NOT zero. Zero is a free
+    round, and a player who typed 0.00001 dollars on a bitcoin wallet meant to
+    bet, not to play for free (live check 22.09.2026: a bet of 0 went out). One
+    smallest unit is returned — it is below any minimum, so the game refuses it as
+    "below the minimum" and offers the minimum (owner's decision, 22.09.2026: a
+    refusal, not a free round). */
+export function parseView(text, wallet) {
+    var raw = String(text == null ? '' : text).replace(/[\s,]/g, '');
+    if (raw === '' || raw === '.') return 0;
+    var amount = walletFromView(raw, wallet);
+    if (amount === 0 && toNumber(raw) > 0) return Math.pow(10, -walletPrecision(wallet));
+    return amount;
+}

package/engine-sdk/marks.js

@@ -0,0 +1,22 @@
+/* GENERATED by tools/sync-kit.mjs --site <arbitrium-frontend>: do not edit.
+   The site's own coin pictures (apps/web/public/img/crypto, the ones its
+   header and wallet draw), carried as data: URIs so a game frame needs no
+   network to show them. */
+export const COIN_MARKS = Object.freeze({
+    BTC: 'data:image/svg+xml;base64,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',
+    BNB: 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBvdmVyZmxvdz0idmlzaWJsZSIgc3R5bGU9ImRpc3BsYXk6IGJsb2NrOyIgdmlld0JveD0iMCAwIDMxLjk5NjQgMzIiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxnIGlkPSJCaW5hbmNlIENvaW4gKEJOQikiPgo8cGF0aCBpZD0iQmluYW5jZSBDb2luIChCTkIpXzIiIGQ9Ik0zMS41MTc3IDE5Ljg3MDVDMjkuMzgwOCAyOC40NDIgMjAuNjk5MiAzMy42NTg0IDEyLjEyNjcgMzEuNTIxQzMuNTU3NzggMjkuMzg0MSAtMS42NTg2OCAyMC43MDIgMC40NzkxNzcgMTIuMTMxMkMyLjYxNTE1IDMuNTU4NyAxMS4yOTY3IC0xLjY1ODE0IDE5Ljg2NjYgMC40Nzg3NzVDMjguNDM4NSAyLjYxNTY5IDMzLjY1NDYgMTEuMjk4NyAzMS41MTc1IDE5Ljg3MDZMMzEuNTE3NiAxOS44NzA1SDMxLjUxNzdaIiBmaWxsPSJ2YXIoLS1maWxsLTAsICNGM0JBMkYpIi8+CjxwYXRoIGlkPSJCaW5hbmNlIENvaW4gKEJOQilfMyIgZmlsbC1ydWxlPSJldmVub2RkIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik0xNiAxMC4xNTQ3TDExLjg1NjkgMTQuMjk3OEwxMS44NTcgMTQuMjk3Nkw5LjQ0NjQgMTEuODg2OUwxNiA1LjMzMzMzTDIyLjU1NTcgMTEuODg4OUwyMC4xNDUxIDE0LjI5OTZMMTYgMTAuMTU0N1pNNy43NDQwOSAxMy41ODg5TDUuMzMzMzMgMTZMNy43NDM5MiAxOC40MTAyTDEwLjE1NDcgMTUuOTk5NUw3Ljc0NDA5IDEzLjU4ODlaTTExLjg1NjkgMTcuNzAyNUwxNiAyMS44NDUzTDIwLjE0NSAxNy43MDA1TDIyLjU1NjkgMjAuMTA5OUwyMi41NTU3IDIwLjExMTJMMTYgMjYuNjY2N0w5LjQ0NjQgMjAuMTEzMUw5LjQ0Mjk5IDIwLjEwOTdMMTEuODU2OSAxNy43MDI1Wk0yNC4yNTYxIDEzLjU5MDNMMjEuODQ1MyAxNi4wMDFMMjQuMjU2IDE4LjQxMTZMMjYuNjY2NyAxNi4wMDA5TDI0LjI1NjEgMTMuNTkwM1oiIGZpbGw9InZhcigtLWZpbGwtMCwgd2hpdGUpIi8+CjxwYXRoIGlkPSJCaW5hbmNlIENvaW4gKEJOQilfNCIgZD0iTTE4LjQ0NSAxNS45OTg3SDE4LjQ0NkwxNiAxMy41NTI2TDE0LjE5MiAxNS4zNlYxNS4zNkwxMy45ODQzIDE1LjU2NzhMMTMuNTU2IDE1Ljk5NjJMMTMuNTUyNiAxNS45OTk2TDEzLjU1NiAxNi4wMDMxTDE2IDE4LjQ0NzRMMTguNDQ2MiAxNi4wMDEzTDE4LjQ0NzQgMTUuOTk5OUwxOC40NDUxIDE1Ljk5ODciIGZpbGw9InZhcigtLWZpbGwtMCwgd2hpdGUpIi8+CjwvZz4KPC9zdmc+Cg==',
+    DOGE: 'data:image/webp;base64,UklGRiQDAABXRUJQVlA4WAoAAAAQAAAALwAALwAAQUxQSN4AAAABgBDbbt3oQRAEQQqDiokFwQxaBi2DlIGXgcNAENS/7bcEImICMC5Wrz0ys+/VFKul7DnYTFdIiZx51mklcnaZoy0Xdp1wilwa21DJ5WWgJGH5aUvK0w8aHKHfepK2LyVp/YMmb8jbhSgdgCZzCGBU6UDj2qFJLsZmla3ubLeDrSd70P3DoDvY+o3tXtmqsZmwKXauBjiXARJUCsCZzgAgQaRvcB7H58bS8VWDI/QbjGPDr87g+N3XOUa3WBOGce0rmmKqTwvHbL1MCRcsVPsbubtgtVq9H5kZx62aYBxWUDggIAIAANAKAJ0BKjAAMAA+bS6TR6QiIaEuNAgAgA2JZAC7M1o8qVYHGjZ2TDPjQamqCGheSjohe7WnA7fj/0Yfrfq/xwmmI044BVGaXT0P4bJ9D0MQndJ33GXlCm0Qber6lYAAAP7vtGYAgQgfiOzs/k49sG5Lx+2iWXHiWme69fs+89krX2rek7pPIPn16M5XA/9G6vIJPv66ue7syJA0xsuS7aHym9kjjBT5lXEY1x6Zu/Qd9k/YLW20+HMO5e2lXvh6xMTBQRnjwyyJKwsLWaiQ+LuhPuf0bm5XmGk5WscP8OJpqFDouAhc8lFU/gBra6dql1gkPs2PE9FnfedRVjaC74IwvDEAhDHxiIFCxo0oEuFQeusbLyCsem2YJu2uu9c+NXDmsssbvWClPVRlifjHQvCEm7+GAkCTDHXKt2Bh1MaKq1OL3k20nAI6yPNAI51DqY82FL8Ig2LPhCsbWMEFSu+dXQ9ahmO8mhb878iQzqf4+qzjJFknHZzqqlVJL1CiIDCEN6mPhpcrBNPnTMK5qRyIF1cxE/0QwZNNKKGBYybQ+k3eR1F3iopmwbQrFy4tbE6WmSfLe8ZykgHGiN83nmqFca78gzlvRTzzUJrzI61HdFQQTFlP1iPekwwnI1BgHM9CwZ8ooUTJADfcblrCrtsSCCehM2fypUqsHt6Rk8vwCMQldZi0+zmAxVh+tqgYW0iWeaJvpB7a/WaDZeuGAAA=',
+    ETH: 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBvdmVyZmxvdz0idmlzaWJsZSIgc3R5bGU9ImRpc3BsYXk6IGJsb2NrOyIgdmlld0JveD0iMCAwIDMyIDMyIiBmaWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgo8ZyBpZD0iRXRoZXJldW0gKEVUSCkiPgo8Y2lyY2xlIGlkPSJFdGhlcmV1bSAoRVRIKV8yIiBjeD0iMTYiIGN5PSIxNiIgcj0iMTYiIGZpbGw9InZhcigtLWZpbGwtMCwgIzZDODBEQykiLz4KPGcgaWQ9IkV0aGVyZXVtIChFVEgpXzMiPgo8cGF0aCBpZD0iRXRoZXJldW0gKEVUSClfNCIgZD0iTTE1Ljk1NjQgNi40TDE1LjgyOTEgNi44MzIzNFYxOS4zNzY4TDE1Ljk1NjQgMTkuNTAzOEwyMS43NzkyIDE2LjA2MThMMTUuOTU2NCA2LjRaIiBmaWxsPSJ2YXIoLS1maWxsLTAsIHdoaXRlKSIvPgo8cGF0aCBpZD0iRXRoZXJldW0gKEVUSClfNSIgZD0iTTE1Ljk1NjQgNi40TDEwLjEzMzMgMTYuMDYxOEwxNS45NTY0IDE5LjUwMzhWMTMuNDE1VjYuNFoiIGZpbGw9InZhcigtLWZpbGwtMCwgd2hpdGUpIi8+CjxwYXRoIGlkPSJFdGhlcmV1bSAoRVRIKV82IiBkPSJNMTUuOTU2NCAyMC42MDYyTDE1Ljg4NDYgMjAuNjkzN1YyNS4xNjIyTDE1Ljk1NjQgMjUuMzcxN0wyMS43ODI4IDE3LjE2NjFMMTUuOTU2NCAyMC42MDYyWiIgZmlsbD0idmFyKC0tZmlsbC0wLCB3aGl0ZSkiLz4KPHBhdGggaWQ9IkV0aGVyZXVtIChFVEgpXzciIGQ9Ik0xNS45NTY0IDI1LjM3MTdWMjAuNjA2MkwxMC4xMzMzIDE3LjE2NjFMMTUuOTU2NCAyNS4zNzE3WiIgZmlsbD0idmFyKC0tZmlsbC0wLCB3aGl0ZSkiLz4KPHBhdGggaWQ9IkV0aGVyZXVtIChFVEgpXzgiIGQ9Ik0xNS45NTY0IDE5LjUwMzhMMjEuNzc5MiAxNi4wNjE4TDE1Ljk1NjQgMTMuNDE1VjE5LjUwMzhaIiBmaWxsPSJ2YXIoLS1maWxsLTAsIHdoaXRlKSIvPgo8cGF0aCBpZD0iRXRoZXJldW0gKEVUSClfOSIgZD0iTTEwLjEzMzMgMTYuMDYxOEwxNS45NTY0IDE5LjUwMzhWMTMuNDE1TDEwLjEzMzMgMTYuMDYxOFoiIGZpbGw9InZhcigtLWZpbGwtMCwgd2hpdGUpIi8+CjwvZz4KPC9nPgo8L3N2Zz4K',
+    LTC: 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBvdmVyZmxvdz0idmlzaWJsZSIgc3R5bGU9ImRpc3BsYXk6IGJsb2NrOyIgdmlld0JveD0iMCAwIDMxLjk5OTkgMzIiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxnIGlkPSJMaXRlY29pbiAoTFRDKSI+CjxjaXJjbGUgaWQ9IkxpdGVjb2luIChMVEMpXzIiIGN4PSIxNi4xMzMzIiBjeT0iMTUuODY2NyIgcj0iMTQuMjY2NyIgZmlsbD0idmFyKC0tZmlsbC0wLCB3aGl0ZSkiLz4KPHBhdGggaWQ9IkxpdGVjb2luIChMVEMpXzMiIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNMCAxNkMwIDcuMTYzNDQgNy4xNjM0MSAwIDE1Ljk5OTkgMEgxNi4wOTI5QzIwLjMyNCAwLjAxMjMxMTcgMjQuMzc3IDEuNzA0OTQgMjcuMzYwMSA0LjcwNTUzQzMwLjM0MzIgNy43MDYxMSAzMi4wMTIyIDExLjc2ODkgMzEuOTk5OSAxNkMzMS45OTk5IDI0LjgzNjYgMjQuODM2NSAzMiAxNS45OTk5IDMyQzcuMTYzNDEgMzIgMCAyNC44MzY2IDAgMTZaTTE0LjYwNTMgMjIuMTU5OEwxNi4yNzExIDE2LjU0MjRMMTguODY2NyAxNS44MDYzTDE5LjQwOTEgMTMuOTQ2N0wxNi44NTIyIDE0LjcyMTVMMTkuNTY0MSA1LjUwMTIxVjUuMzU0QzE5LjU2IDUuMjM0NzggMTkuNTA4OCA1LjEyMjA3IDE5LjQyMTYgNS4wNDA2OEMxOS4zMzQ0IDQuOTU5MyAxOS4yMTg0IDQuOTE1OTIgMTkuMDk5MiA0LjkyMDFIMTUuNjUxM0MxNS4zODI3IDQuOTExODIgMTUuMTQzIDUuMDg3NTkgMTUuMDcwMiA1LjM0NjI1TDExLjg1NDcgMTYuMjcxMkw5LjI5Nzc4IDE3LjA0Nkw4LjcxNjY3IDE4LjgyODFMMTEuMjczNiAxOC4wNTMzTDguOTg3ODYgMjUuODQwMkgyMi42MjQ2QzIyLjg5NDEgMjUuODUxMyAyMy4xMzU0IDI1LjY3NDQgMjMuMjA1NyAyNS40MTRMMjMuOTgwNSAyMi43NDA5VjIyLjU5MzdDMjMuOTc2NSAyMi40NzQ1IDIzLjkyNTIgMjIuMzYxOCAyMy44MzggMjIuMjgwNEMyMy43NTA4IDIyLjE5OSAyMy42MzQ4IDIyLjE1NTYgMjMuNTE1NiAyMi4xNTk4SDE0LjYwNTNaIiBmaWxsPSJ2YXIoLS1maWxsLTAsICMzNDVEOUQpIi8+CjwvZz4KPC9zdmc+Cg==',
+    POL: 'data:image/svg+xml;base64,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',
+    SHIB: 'data:image/svg+xml;base64,<svg width="100%" height="100%" overflow="visible" style="display: block;" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
<g id="SHIBA INU (SHIB)">
<path id="SHIBA INU (SHIB)_2" fill-rule="evenodd" clip-rule="evenodd" d="M16 32C7.2 32 0 24.8001 0 15.9203C0.08 7.12051 7.2 -0.0793381 16.08 0.000660272C24.88 0.0806586 32 7.20051 32 16.1603C31.92 24.8801 24.8 32 16 32" fill="var(--fill-0, #E42D04)"/>
<g id="SHIBA INU (SHIB)_3">
<path id="SHIBA INU (SHIB)_4" fill-rule="evenodd" clip-rule="evenodd" d="M16.3117 27.7333C17.473 27.7333 20.452 27.2098 23.0776 25.1156C26.0967 22.7076 26.3812 21.3646 26.5647 20.4987C26.5806 20.4233 26.5958 20.3516 26.612 20.283C26.6426 20.1532 26.6605 19.977 26.6667 19.7676C26.0325 19.6649 25.1436 19.6061 24.1063 19.7293C22.4098 19.9306 21.0768 21.0884 20.6224 21.6422C20.3699 20.3837 19.1379 17.8667 16.2296 17.8667C13.3213 17.8667 11.7526 20.3837 11.3319 21.6422C11.0626 21.1723 10.0595 20.132 8.20138 19.7293C7.05251 19.4803 6.05035 19.6033 5.33333 19.8128C5.38994 20.7486 5.69754 21.7468 6.51624 22.8C7.92496 24.6122 10.1108 25.7313 11.086 26.2306C11.1943 26.2861 11.2877 26.3339 11.3635 26.3742C12.1208 26.7769 14.191 27.7333 16.3117 27.7333Z" fill="var(--fill-0, white)"/>
<path id="SHIBA INU (SHIB)_5" fill-rule="evenodd" clip-rule="evenodd" d="M26.6643 19.7308C26.0304 19.6284 25.1421 19.5698 24.1054 19.6925C22.4099 19.8933 21.0776 21.0478 20.6235 21.6C20.3712 20.3451 19.1399 17.8353 16.2332 17.8353C13.3266 17.8353 11.7589 20.3451 11.3384 21.6C11.0692 21.1315 10.0667 20.0941 8.2097 19.6925C7.06149 19.4443 6.05991 19.567 5.34331 19.776C5.29172 18.925 5.44872 18.1257 5.6172 17.3835C5.89979 16.1387 6.60963 14.4889 6.92923 13.8196C6.64327 13.1336 5.98053 11.1893 5.6172 8.90039C5.25387 6.61145 5.86951 5.06876 6.22275 4.58353C6.79466 4.73412 8.16052 5.20596 9.04866 5.88863C9.9368 6.57129 11.3026 8.08052 11.8746 8.7498C12.6147 8.54902 14.5188 8.14745 16.2144 8.14745C17.9099 8.14745 19.5449 8.54902 20.1504 8.7498C20.6551 8.14745 21.8964 6.73192 22.825 5.88863C23.7535 5.04533 25.2639 4.63373 25.9032 4.53333C26.0713 4.75085 26.428 5.38667 26.5087 6.1898C26.6096 7.19373 26.3069 9.30196 25.9032 10.7075C25.5802 11.8318 25.163 13.1503 24.9948 13.669C25.0789 13.8531 25.3683 14.4521 25.8527 15.3757C26.3664 16.3551 26.6985 18.5626 26.6643 19.7308Z" fill="var(--fill-0, #FFAA35)"/>
<path id="SHIBA INU (SHIB)_6" d="M18.3833 24.1979C18.2633 24.3584 18.1333 24.6662 18.0833 24.8V24.7498L17.9333 23.5456C17.65 23.579 16.9133 23.6459 16.2333 23.6459C15.5533 23.6459 14.75 23.579 14.4333 23.5456L14.3833 24.7498C14.35 24.6996 14.2633 24.5591 14.1833 24.3986C14.0833 24.1979 13.7333 23.8968 13.7333 23.7463C13.7333 23.6258 13.5667 23.3616 13.4833 23.2445L13.3333 23.0438H14.2333L14.4333 23.1943C14.6 23.1776 15.0233 23.1642 15.3833 23.2445C15.7433 23.3248 15.9666 23.0104 16.0333 22.8431V22.0402C15.8833 21.9399 15.5133 21.709 15.2333 21.5886C14.8833 21.4381 14.5333 20.836 14.6333 20.2338C14.7333 19.6317 15.0333 19.431 15.2333 19.4812C15.4333 19.5313 16.7333 19.431 16.9333 19.4812C17.1333 19.5313 17.4833 19.6317 17.6333 19.8826C17.7833 20.1335 17.6833 21.137 17.3833 21.4883C17.1433 21.7693 16.6833 21.9733 16.4833 22.0402V22.8431C16.4833 22.9434 16.8333 23.1943 16.8833 23.2445C16.9333 23.2947 17.6833 23.2445 17.8333 23.2445C17.9533 23.2445 18.05 23.1441 18.0833 23.094H18.9333V23.2947C18.9333 23.395 18.7833 23.8466 18.7333 23.8968C18.6833 23.947 18.5333 23.9972 18.3833 24.1979Z" fill="var(--fill-0, black)"/>
<path id="SHIBA INU (SHIB)_7" d="M16.7746 23.8667L16.2667 24.2667L15.8603 23.8667L15.5048 24.0444L15.2 23.7333H17.3333L17.0286 24.0889L16.7746 23.8667Z" fill="var(--fill-0, black)"/>
<path id="SHIBA INU (SHIB)_8" d="M11.3081 15.6615C10.713 15.4154 10.0683 15.2513 9.8204 15.2C9.75428 15.2342 9.62204 15.3436 9.62204 15.5077C9.62204 15.7128 9.57245 15.9179 9.62204 16.3282C9.67163 16.7385 10.0683 16.9949 10.7626 17.3026C11.4569 17.6103 12.647 17.8667 13.4901 17.8667C14.3331 17.8667 13.5396 16.9949 13.2421 16.7897C12.9446 16.5846 12.0519 15.9692 11.3081 15.6615Z" fill="var(--fill-0, black)"/>
<path id="SHIBA INU (SHIB)_9" d="M12.1225 14.3006C11.6778 14.3801 11.0612 14.4 10.8086 14.4C10.5559 14.3669 10.0202 14.2111 9.89894 13.8533C9.74733 13.4059 10.1516 12.9089 10.657 12.6604C11.1623 12.4118 11.8193 12.5112 12.2236 13.1077C12.6278 13.7041 12.6784 14.2012 12.1225 14.3006Z" fill="var(--fill-0, white)"/>
<path id="SHIBA INU (SHIB)_10" d="M21.2252 15.3949C21.8203 15.1487 22.465 14.9846 22.7129 14.9333C22.7791 14.9675 22.9113 15.0769 22.9113 15.241C22.9113 15.4462 22.9609 15.6513 22.9113 16.0615C22.8617 16.4718 22.465 16.7282 21.7707 17.0359C21.0765 17.3436 19.8863 17.6 19.0433 17.6C18.2003 17.6 18.9937 16.7282 19.2912 16.5231C19.5888 16.3179 20.4814 15.7026 21.2252 15.3949Z" fill="var(--fill-0, black)"/>
<path id="SHIBA INU (SHIB)_11" d="M19.6108 14.3006C20.0556 14.3801 20.6721 14.4 20.9248 14.4C21.1774 14.3669 21.7131 14.2111 21.8344 13.8533C21.986 13.4059 21.5817 12.9089 21.0764 12.6604C20.571 12.4118 19.9141 12.5112 19.5098 13.1077C19.1055 13.7041 19.055 14.2012 19.6108 14.3006Z" fill="var(--fill-0, white)"/>
<path id="SHIBA INU (SHIB)_12" d="M8.6478 10.5798C8.28441 10.9767 7.5879 11.8698 7.28507 12.2667C7.08318 11.8367 6.63903 10.689 6.47752 9.53798C6.31601 8.38698 6.44388 6.61085 6.52799 5.86667C6.74671 5.88321 7.38601 6.06512 8.19356 6.66047C9.0011 7.25581 10.1788 8.36383 10.6667 8.84341C10.1451 9.25685 9.0112 10.1829 8.6478 10.5798Z" fill="var(--fill-0, #FF8C30)"/>
<path id="SHIBA INU (SHIB)_13" fill-rule="evenodd" clip-rule="evenodd" d="M6.4 6.81171C7.19372 7.14293 8.23851 7.64925 8.67636 8.10686C9.12051 8.57107 9.51125 9.18557 9.74322 9.6C10.0915 9.31125 10.4375 9.03386 10.6667 8.8536C10.1733 8.37237 8.98256 7.26057 8.16602 6.66318C7.34949 6.0658 6.70307 5.88326 6.48192 5.86667C6.45551 6.09847 6.42485 6.43007 6.4 6.81171Z" fill="var(--fill-0, #FF9A32)"/>
<path id="SHIBA INU (SHIB)_14" d="M23.0855 10.5798C23.4489 10.9767 24.1454 11.8698 24.4483 12.2667C24.6502 11.8367 25.0943 10.689 25.2558 9.53798C25.4173 8.38698 25.2894 6.61085 25.2053 5.86667C24.9866 5.88321 24.3473 6.06512 23.5398 6.66047C22.7322 7.25581 21.5545 8.36383 21.0667 8.84341C21.5882 9.25685 22.7221 10.1829 23.0855 10.5798Z" fill="var(--fill-0, #FF8C30)"/>
<path id="SHIBA INU (SHIB)_15" fill-rule="evenodd" clip-rule="evenodd" d="M25.3333 6.81171C24.5396 7.14293 23.4948 7.64925 23.057 8.10686C22.6128 8.57107 22.2221 9.18557 21.9902 9.6C21.6419 9.31125 21.2958 9.03386 21.0667 8.8536C21.56 8.37237 22.7508 7.26057 23.5673 6.66318C24.3838 6.0658 25.0302 5.88326 25.2514 5.86667C25.2778 6.09847 25.3084 6.43007 25.3333 6.81171Z" fill="var(--fill-0, #FF9A32)"/>
</g>
</g>
</svg>
',
+    SOL: 'data:image/svg+xml;base64,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',
+    TON: 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjM3IiBoZWlnaHQ9IjIzNyIgdmlld0JveD0iMCAwIDIzNyAyMzciIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxwYXRoIGQ9Ik0xMTguMjA0IDAuMDAwMjkyNDM2QzE4My40ODYgMC4wMDAyOTI0MzYgMjM2LjQwOCA1Mi45MjI0IDIzNi40MDggMTE4LjIwNUMyMzYuNDA4IDE4My40ODcgMTgzLjQ4NiAyMzYuNDA4IDExOC4yMDQgMjM2LjQwOEM1Mi45MjE2IDIzNi40MDggMC4wMDAxODQwMDcgMTgzLjQ4NyAwIDExOC4yMDVDMCA1Mi45MjI1IDUyLjkyMTUgMC4wMDA0NTIwMTIgMTE4LjIwNCAwLjAwMDI5MjQzNlpNNzQuMTAxMSA2Mi4xOTY1QzU3LjY3OTkgNjIuMTk2NSA0Ny4yNjggNzkuOTEyIDU1LjUzMDggOTQuMjM0N0wxMDkuOTY0IDE4OC41ODJDMTEzLjYxOSAxOTQuOTIyIDEyMi43ODEgMTk0LjkyMiAxMjYuNDM2IDE4OC41ODJMMTgwLjg4IDk0LjIzNDdDMTg5LjEzMiA3OS45MzQzIDE3OC43MiA2Mi4xOTY2IDE2Mi4zMSA2Mi4xOTY1SDc0LjEwMTFaTTE2Mi4yODggNzguODQxMkMxNjYuMDMxIDc4Ljg0MTIgMTY4LjIzNCA4Mi44MTIxIDE2Ni40NSA4NS45MDc1TDEzNy44NTYgMTM3LjA5MUwxMzcuODUxIDEzNy4wOTlMMTI2LjUwNiAxNTkuMDQ2Vjc4Ljg0MTJIMTYyLjI4OFpNMTA5Ljg3MiA3OC44NTE3VjE1OS4wMjRMOTguNTM3NiAxMzcuMDg4TDk4LjUzMzQgMTM3LjA4TDY5LjkyOTQgODUuOTIxNUw2OS44NDY4IDg1Ljc3MjVDNjguMjEzNCA4Mi42OTk3IDcwLjQwNSA3OC44NTE3IDc0LjA4OTkgNzguODUxN0gxMDkuODcyWiIgZmlsbD0iIzREQjhGRiIvPgo8L3N2Zz4K',
+    TRX: 'data:image/svg+xml;base64,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',
+    USDC: 'data:image/svg+xml;base64,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',
+    USDT: 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBvdmVyZmxvdz0idmlzaWJsZSIgc3R5bGU9ImRpc3BsYXk6IGJsb2NrOyIgdmlld0JveD0iMCAwIDMxLjk5NjQgMzIiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxnIGlkPSJUZXRoZXIgKFVTRFQpIj4KPHBhdGggaWQ9IlRldGhlciAoVVNEVClfMiIgZD0iTTMxLjUxNzcgMTkuODcwNUMyOS4zODA4IDI4LjQ0MiAyMC42OTkyIDMzLjY1ODQgMTIuMTI2NyAzMS41MjFDMy41NTc3OCAyOS4zODQxIC0xLjY1ODY4IDIwLjcwMiAwLjQ3OTE3NyAxMi4xMzEyQzIuNjE1MTUgMy41NTg3IDExLjI5NjcgLTEuNjU4MTQgMTkuODY2NiAwLjQ3ODc3NUMyOC40Mzg1IDIuNjE1NjkgMzMuNjU0NiAxMS4yOTg3IDMxLjUxNzUgMTkuODcwNkwzMS41MTc2IDE5Ljg3MDVIMzEuNTE3N1oiIGZpbGw9InZhcigtLWZpbGwtMCwgIzUwQUY5NSkiLz4KPHBhdGggaWQ9IlRldGhlciAoVVNEVClfMyIgZmlsbC1ydWxlPSJldmVub2RkIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik0xOC4wMjQ2IDE3LjgxMzlWMTcuODEzOUMxNy45MTE1IDE3LjgyMjQgMTcuMzI3IDE3Ljg1NzMgMTYuMDIzMSAxNy44NTczQzE0Ljk4NiAxNy44NTczIDE0LjI0OTcgMTcuODI2MiAxMy45OTE0IDE3LjgxMzlWMTcuODEzOUM5Ljk4MzYgMTcuNjM3NiA2Ljk5MjE0IDE2Ljk0IDYuOTkyMTQgMTYuMTA0NkM2Ljk5MjE0IDE1LjI2OTMgOS45ODM2IDE0LjU3MjYgMTMuOTkxNCAxNC4zOTM1VjE3LjExOTFDMTQuMjUzNSAxNy4xMzc5IDE1LjAwMzkgMTcuMTgyMyAxNi4wNDEgMTcuMTgyM0MxNy4yODU1IDE3LjE4MjMgMTcuOTA4NyAxNy4xMzA0IDE4LjAyMDkgMTcuMTJWMTQuMzk1NEMyMi4wMjAyIDE0LjU3MzYgMjUuMDA1IDE1LjI3MTIgMjUuMDA1IDE2LjEwNDZDMjUuMDA1IDE2LjkzODEgMjIuMDIxMSAxNy42MzU3IDE4LjAyMDkgMTcuODEzVjE3LjgxM0wxOC4wMjQ2IDE3LjgxMzlaTTE4LjAyNDYgMTQuMTEzNVYxMS42NzQ1SDIzLjYwNTlWNy45NTUxOUg4LjQxMDA5VjExLjY3NDVIMTMuOTkwNFYxNC4xMTI1QzkuNDU0NyAxNC4zMjA5IDYuMDQzNjkgMTUuMjE5NCA2LjA0MzY5IDE2LjI5NkM2LjA0MzY5IDE3LjM3MjcgOS40NTQ3IDE4LjI3MDIgMTMuOTkwNCAxOC40Nzk1VjI2LjI5NTJIMTguMDIzN1YxOC40NzY3QzIyLjU0OTEgMTguMjY4MyAyNS45NTQ0IDE3LjM3MDggMjUuOTU0NCAxNi4yOTUxQzI1Ljk1NDQgMTUuMjE5NCAyMi41NTE5IDE0LjMyMTggMTguMDIzNyAxNC4xMTI1VjE0LjExMjVMMTguMDI0NiAxNC4xMTM1WiIgZmlsbD0idmFyKC0tZmlsbC0wLCB3aGl0ZSkiLz4KPC9nPgo8L3N2Zz4K',
+    XRP: 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTIxIiBoZWlnaHQ9IjEyMSIgdmlld0JveD0iMCAwIDEyMSAxMjEiIGZpbGw9Im5vbmUiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+CjxwYXRoIGQ9Ik0xMTguNjkyIDc1LjAxNDRDMTEwLjY3OCAxMDcuMTU4IDc4LjEyMjMgMTI2LjcxOSA0NS45NzUzIDExOC43MDRDMTMuODQxOCAxMTAuNjkgLTUuNzE5OTIgNzguMTMyNSAyLjI5NzAzIDQ1Ljk5MkMxMC4zMDY5IDEzLjg0NTMgNDIuODYyOCAtNS43MTc5MSA3NC45OTk4IDIuMjk1NTJDMTA3LjE0NCAxMC4zMDkgMTI2LjcwNSA0Mi44NzAzIDExOC42OTEgNzUuMDE1TDExOC42OTEgNzUuMDE0NEgxMTguNjkyWiIgZmlsbD0iIzIzMjkyRiIgc3Ryb2tlPSJ3aGl0ZSIgc3Ryb2tlLW9wYWNpdHk9IjAuMiIvPgo8cGF0aCBkPSJNOTAuMDAyMiAyNS41MDAxSDEwMi4xMUw3Ni45MTI2IDUwLjQ0ODlDNjcuNzg3NSA1OS40NzkxIDUyLjk5MjkgNTkuNDc5MSA0My44NjEzIDUwLjQ0ODlMMTguNjUzOSAyNS41MDAxSDMwLjc3MTZMNDkuOTE1MiA0NC40NTIzQzU1LjcxODkgNTAuMTcyMyA2NS4wNDAyIDUwLjE3MjMgNzAuODQzOSA0NC40NTIzTDkwLjAwMjIgMjUuNTAwMVoiIGZpbGw9IndoaXRlIi8+CjxwYXRoIGQ9Ik0zMC42MTYyIDk0Ljg3NTFIMTguNTAwMUw0My44NjEzIDY5Ljc3MjVDNTIuOTg2NCA2MC43NDIzIDY3Ljc4MDkgNjAuNzQyMyA3Ni45MTI2IDY5Ljc3MjVMMTAyLjI3NCA5NC44NzUxSDkwLjE2NThMNzAuODU4NiA3NS43NjkyQzY1LjA1NDkgNzAuMDQ5MSA1NS43MzM3IDcwLjA0OTEgNDkuOTI5OSA3NS43NjkyTDMwLjYxNjIgOTQuODc1MVoiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPgo=',
+    LINK: 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzIiIGhlaWdodD0iMzIiIHZpZXdCb3g9IjAgMCAzMiAzMiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8IS0tIE9mZmljaWFsIENoYWlubGluayBzeW1ib2w6IGh0dHBzOi8vY2hhaW4ubGluay9icmFuZC1hc3NldHMgLS0+CiAgPGNpcmNsZSBjeD0iMTYiIGN5PSIxNiIgcj0iMTYiIGZpbGw9IiMwODQ3RjciLz4KICA8c3ZnIHg9IjcuMyIgeT0iNiIgd2lkdGg9IjE3LjQiIGhlaWdodD0iMjAiIHZpZXdCb3g9IjAgMCAyNDcgMjg0Ij4KICAgIDxwYXRoIGQ9Ik0xMjMuNSAwTDAgNzAuOTcyNlYyMTIuOTE4TDEyMy41IDI4My44OUwyNDcgMjEyLjkxOFY3MC45NzI2TDEyMy41IDBaTTE5NC42NzkgMTgyLjgzN0wxMjMuNTIzIDIyMy43MjhMNTIuMzY2MyAxODIuODM3VjEwMS4wNTRMMTIzLjUyMyA2MC4xNjIxTDE5NC42NzkgMTAxLjA1NFYxODIuODM3WiIgZmlsbD0id2hpdGUiLz4KICA8L3N2Zz4KPC9zdmc+Cg==',
+});
+
+export const LOGO_MARK = 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9Ii0xMCAtMTAgNDggNDgiPjxjaXJjbGUgY3g9IjE0IiBjeT0iMTQiIHI9IjIzIiBmaWxsPSIjMDgxNDFhIiBzdHJva2U9IiMwYTNhNDciIHN0cm9rZS13aWR0aD0iMiIvPjxwYXRoIGQ9Ik0yOCAwVjI4SDE4LjA0NDRWMTguNDUxOUMxOC4wNDQ0IDE3LjQ4NzkgMTcuNTgxMSAxNi41ODI2IDE2Ljc5OTIgMTYuMDE4N0wxNS4xNjk4IDE0Ljg0MzZDMTQuNDcxMyAxNC4zMzk5IDEzLjUyODcgMTQuMzM5OSAxMi44MzAyIDE0Ljg0MzZMMTEuMjAwOCAxNi4wMTg3QzEwLjQxODkgMTYuNTgyNiA5Ljk1NTU2IDE3LjQ4NzkgOS45NTU1NiAxOC40NTE5VjI4SDBWMC4wMDQzMTc1NEg5Ljk1NTU2VjEwLjM5ODhIMTguMDQ0NFYwSDI4WiIgZmlsbD0iIzAyRjhGOCIvPjwvc3ZnPg==';