@syncswap/sdk
Version:
SyncSwap TypeScript SDK for building DeFi applications
352 lines • 15 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.TokenRegistry = exports.globalSharedTokenMap = exports.ETH_MAINNET = exports.LINEA_MAINNET = exports.ZKSYNC_SEPOLIA_TESTNET = exports.ZKCANDY_MAINNET = exports.SOPHON_TESTNET = exports.SOPHON_MAINNET = exports.SCROLL_MAINNET = exports.ZKSYNC_MAINNET = exports.ZKSYNC_TESTNET = exports.Token = void 0;
exports.getWETHAddress = getWETHAddress;
exports.getRouteTokens = getRouteTokens;
exports.ensureTokenRegistered = ensureTokenRegistered;
const caseInsensitiveMap_1 = require("../utils/caseInsensitiveMap");
const address_1 = require("../utils/address");
const token_1 = require("./token");
Object.defineProperty(exports, "Token", { enumerable: true, get: function () { return token_1.Token; } });
const tokenListLoader_1 = require("./tokenListLoader");
const fetchToken_1 = __importDefault(require("./fetchToken"));
// Import all network token lists
const zkSyncTestnet_js_1 = __importDefault(require("./zkSyncTestnet.js"));
const zkSyncSepolia_js_1 = __importDefault(require("./zkSyncSepolia.js"));
const zkSyncMainnet_js_1 = __importDefault(require("./zkSyncMainnet.js"));
const scrollMainnet_js_1 = __importDefault(require("./scrollMainnet.js"));
const sophonMainnet_js_1 = __importDefault(require("./sophonMainnet.js"));
const zkCandyMainnet_js_1 = __importDefault(require("./zkCandyMainnet.js"));
const sophonTestnet_js_1 = __importDefault(require("./sophonTestnet.js"));
const ethereumMainnet_js_1 = __importDefault(require("./ethereumMainnet.js"));
const lineaMainnet_js_1 = __importDefault(require("./lineaMainnet.js"));
const statestore_1 = require("../statestore/statestore");
// Network constants (matching main project)
exports.ZKSYNC_TESTNET = 'zkSyncTestnet';
exports.ZKSYNC_MAINNET = 'zkSyncMainnet';
exports.SCROLL_MAINNET = 'scrollMainnet';
exports.SOPHON_MAINNET = 'sophonMainnet';
exports.SOPHON_TESTNET = 'sophonTestnet';
exports.ZKCANDY_MAINNET = 'zkcandyMainnet';
exports.ZKSYNC_SEPOLIA_TESTNET = 'zkSyncSepoliaTestnet';
exports.LINEA_MAINNET = 'lineaMainnet';
exports.ETH_MAINNET = 'ethereumMainnet';
const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
// wETH addresses for different networks (matching main project)
const ZKSYNC_TESTNET_WETH = '0x20b28b1e4665fff290650586ad76e977eab90c5d';
const ZKSYNC_MAINNET_WETH = '0x5aea5775959fbc2557cc8789bc1bf90a239d9a91';
const ZKSYNC_SEPOLIA_TESTNET_WETH = '0x701f3b10b5cc30ca731fb97459175f45e0ac1247';
const LINEA_MAINNET_WETH = '0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f';
const SCROLL_MAINNET_WETH = '0x5300000000000000000000000000000000000004';
const ETH_MAINNET_WETH = '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2';
const SOPHON_MAINNET_WSOPH = '0x2b1a859de6a55c553520d7780bc5805712b128f9';
const SOPHON_TESTNET_WSOPH = '0x9b7ea63ef5062661570afe548e3ad691d5652527';
const ZKCANDY_MAINNET_WETH = '0x1e347256309b4764edd8d7bdf4aa4ecb62b58320';
// Main token addresses for different networks
const ZKSYNC_TESTNET_USDC = '0x0faf6df7054946141266420b43783387a78d82a9';
const ZKSYNC_SEPOLIA_TESTNET_USDCE = '0x75af292c1409e733bae27081c82ba8a9b7408dac';
const ZKSYNC_MAINNET_USDCE = '0x3355df6d4c9c3035724fd0e3914de96a5a83aaf4';
const ZKSYNC_MAINNET_USDT = '0x493257fd37edb34451f62edf8d2a0c418852ba4c';
const ZKSYNC_MAINNET_USDC = '0x1d17cbcf0d6d143135ae902365d2e5e2a16538d4';
const SCROLL_MAINNET_USDC = '0x06efdbff2a14a7c8e15944d1f4a48f9f95f663a4';
const SCROLL_MAINNET_USDT = '0xf55bec9cafdbe8730f096aa55dad6d22d44099df';
const SOPHON_MAINNET_USDC = '0x4ab4a2732fd7eef56557d4e94c8c0a3bf2ac05dd';
const SOPHON_MAINNET_USDT = '0xaaeaecf6aed3e0d46b945d97b0bb3c03e4eaebe6';
const SOPHON_TESTNET_USDC = '0xd5b4f484e4cfa68b59934884a3f9a491b9c53788';
const LINEA_MAINNET_USDC = '0x176211869ca2b568f2a7d4ee941e073a821ee1ff';
const LINEA_MAINNET_USDT = '0xa219439258ca9da29e9cc4ce5596924745e12b93';
// Route tokens for different networks (matching main project)
const ZKSYNC_TESTNET_RTOKENS = [
ZKSYNC_TESTNET_WETH,
ZKSYNC_TESTNET_USDC,
'0x3e7676937a7e96cfb7616f255b9ad9ff47363d4b', // DAI
'0x0bfce1d53451b4a8175dd94e6e029f7d8a701e9c', // wBTC
'0x40609141db628beee3bfab8034fc2d8278d0cc78', // LINK
"0xfced12debc831d3a84931c63687c395837d42c2b", // USDT
"0x26c78bd5901f57da8aa5cf060ab2116d26906b5e", // TEST
"0xb4fbfb7807c31268dc1ac8c26fa4ef41115d0ece", // FRAX
"0x32a50ccc2d287d934ee9f76916dc252f983c52e2", // MKR
];
const ZKSYNC_SEPOLIA_TESTNET_RTOKENS = [
ZKSYNC_SEPOLIA_TESTNET_WETH,
ZKSYNC_SEPOLIA_TESTNET_USDCE,
'0x8C9d66bA3E1D7681cfFFfa3C7d9807adae368E74', // USDT
'0x432bcc3BC62DE9186f9E8763C82d43e418681e6C', // FRAX
'0xe5d006525a045783ca63B1ad7841E9345daA9f99', // TEST
'0xb74855144Be85E823c869905D3B7803348F3cfc4', // AAVE
'0x00D68275e71B094ea0248De15ee3013465872eb9', // MKR
'0x786FA003352ba38B858b500e9B3273bE5ed9C92a', // MLTT
];
const ZKSYNC_MAINNET_RTOKENS = [
ZKSYNC_MAINNET_WETH,
ZKSYNC_MAINNET_USDCE,
ZKSYNC_MAINNET_USDT,
ZKSYNC_MAINNET_USDC, // Native USDC
'0x5a7d6b2f92c77fad6ccabd7ee0624e64907eaf3e', // ZK
];
const LINEA_MAINNET_RTOKENS = [
LINEA_MAINNET_WETH,
LINEA_MAINNET_USDC,
LINEA_MAINNET_USDT,
];
const SCROLL_MAINNET_RTOKENS = [
SCROLL_MAINNET_WETH,
SCROLL_MAINNET_USDC,
SCROLL_MAINNET_USDT,
'0xd29687c813d741e2f938f4ac377128810e217b1b', // SCR
];
const SOPHON_MAINNET_RTOKENS = [
SOPHON_MAINNET_WSOPH,
'0x72af9f169b619d85a47dfa8fefbcd39de55c567d', // ETH
SOPHON_MAINNET_USDC,
SOPHON_MAINNET_USDT,
];
const SOPHON_TESTNET_RTOKENS = [
SOPHON_TESTNET_WSOPH,
SOPHON_TESTNET_USDC,
];
const ZKCANDY_TESTNET_RTOKENS = [
ZKCANDY_MAINNET_WETH,
];
function getWETHAddress(targetNetwork) {
const network = targetNetwork || (0, statestore_1.stateStore)().network;
if (network === exports.ZKSYNC_MAINNET) {
return ZKSYNC_MAINNET_WETH;
}
if (network === exports.SCROLL_MAINNET) {
return SCROLL_MAINNET_WETH;
}
if (network === exports.LINEA_MAINNET) {
return LINEA_MAINNET_WETH;
}
if (network === exports.SOPHON_MAINNET) {
return SOPHON_MAINNET_WSOPH;
}
if (network === exports.SOPHON_TESTNET) {
return SOPHON_TESTNET_WSOPH;
}
if (network === exports.ETH_MAINNET) {
return ETH_MAINNET_WETH;
}
if (network === exports.ZKSYNC_TESTNET) {
return ZKSYNC_TESTNET_WETH;
}
if (network === exports.ZKSYNC_SEPOLIA_TESTNET) {
return ZKSYNC_SEPOLIA_TESTNET_WETH;
}
if (network === exports.ZKCANDY_MAINNET) {
return ZKCANDY_MAINNET_WETH;
}
// Default to zkSync mainnet WETH
return ZKSYNC_MAINNET_WETH;
}
function getRouteTokens(targetNetwork) {
const network = targetNetwork || (0, statestore_1.stateStore)().network;
if (network === exports.ZKSYNC_MAINNET) {
return ZKSYNC_MAINNET_RTOKENS;
}
if (network === exports.SCROLL_MAINNET) {
return SCROLL_MAINNET_RTOKENS;
}
if (network === exports.LINEA_MAINNET) {
return LINEA_MAINNET_RTOKENS;
}
if (network === exports.SOPHON_MAINNET) {
return SOPHON_MAINNET_RTOKENS;
}
if (network === exports.SOPHON_TESTNET) {
return SOPHON_TESTNET_RTOKENS;
}
if (network === exports.ZKSYNC_TESTNET) {
return ZKSYNC_TESTNET_RTOKENS;
}
if (network === exports.ZKSYNC_SEPOLIA_TESTNET) {
return ZKSYNC_SEPOLIA_TESTNET_RTOKENS;
}
if (network === exports.ZKCANDY_MAINNET) {
return ZKCANDY_TESTNET_RTOKENS;
}
// Default to only WETH for unknown networks
return [getWETHAddress(network)];
}
function getDefaultTokenList(network) {
if (!network || network === exports.ZKSYNC_MAINNET) {
return zkSyncMainnet_js_1.default.tokens;
}
if (network === exports.LINEA_MAINNET) {
return lineaMainnet_js_1.default.tokens;
}
if (network === exports.SCROLL_MAINNET) {
return scrollMainnet_js_1.default.tokens;
}
if (network === exports.SOPHON_MAINNET) {
return sophonMainnet_js_1.default.tokens;
}
if (network === exports.ETH_MAINNET) {
return ethereumMainnet_js_1.default.tokens;
}
if (network === exports.SOPHON_TESTNET) {
return sophonTestnet_js_1.default.tokens;
}
if (network === exports.ZKCANDY_MAINNET) {
return zkCandyMainnet_js_1.default.tokens;
}
if (network === exports.ZKSYNC_SEPOLIA_TESTNET) {
return zkSyncSepolia_js_1.default.tokens;
}
if (network === exports.ZKSYNC_TESTNET) {
return zkSyncTestnet_js_1.default.tokens;
}
// Fallback to zkSync mainnet
return zkSyncMainnet_js_1.default.tokens;
}
exports.globalSharedTokenMap = caseInsensitiveMap_1.CaseInsensitiveMap.create();
class TokenRegistry {
static registerToken(token, indexed) {
// Ignore the zero address.
if (address_1.Address.isNullAddress(token.address)) {
console.warn("Registering a token with zero address", token);
return;
}
// Ignores the native ETH.
if (token.address === token_1.Token.ETHER.address) {
return;
}
const registeredToken = this.tokenByAddressMap.get(token.address);
if (!registeredToken) {
this.tokenByAddressMap.set(token.address, token);
this.allTokens.push(token);
}
this.tokenBySymbolMap.set(token.symbol, token);
if (indexed) {
this.indexedTokenMap.set(token.address, registeredToken ?? token);
}
else {
this.hiddenListedTokenMap.set(token.address, registeredToken ?? token);
}
// cross-chain token cache
exports.globalSharedTokenMap.set(token.address, registeredToken ?? token);
}
static resetTokens() {
this.allTokens = [];
this.tokenByAddressMap = caseInsensitiveMap_1.CaseInsensitiveMap.create();
this.indexedTokenMap = caseInsensitiveMap_1.CaseInsensitiveMap.create();
this.hiddenListedTokenMap = caseInsensitiveMap_1.CaseInsensitiveMap.create();
this.verifiedTokenMap = caseInsensitiveMap_1.CaseInsensitiveMap.create();
}
// register tokens from counterparty network for cross-chain bridge using
static async cacheCrossChainTokens(currentNetwork) {
const targetNetwork = currentNetwork === exports.ZKSYNC_MAINNET ? exports.ETH_MAINNET : exports.ZKSYNC_MAINNET;
const tokenList = getDefaultTokenList(targetNetwork);
const tokens = await tokenListLoader_1.TokenListLoader.parseTokenItems(tokenList);
for (const token of tokens) {
exports.globalSharedTokenMap.set(token.address, token);
this.verifiedTokenMap.set(token.address, token);
}
}
// load the default token list, and register default tokens.
static async initialize(targetNetwork) {
this.resetTokens();
const startTime = Date.now();
const network = targetNetwork || exports.ZKSYNC_MAINNET;
const defaultTokenList = getDefaultTokenList(network);
const defaultTokens = await tokenListLoader_1.TokenListLoader.parseTokenItems(defaultTokenList);
for (const token of defaultTokens) {
this.registerToken(token, !token.hidden);
this.verifiedTokenMap.set(token.address, token);
}
// cross-chain cache
await this.cacheCrossChainTokens(network);
console.log('Token registry initialize: cost', (Date.now() - startTime), 'ms');
}
static getTokenByAddress(address) {
// handle ETH
if (address === token_1.Token.ETHER.address) {
return token_1.Token.ETHER;
}
const token = this.tokenByAddressMap.get(address);
return token ?? null;
}
static getTokenBySymbol(symbol) {
return this.tokenBySymbolMap.get(symbol) ?? null;
}
static async lookupTokenByAddress(provider, address, shouldRegister, isIndexed) {
// handle zero address
if (address === ZERO_ADDRESS) {
console.warn("Trying to lookup a token with zero address", address);
return [token_1.Token.ETHER, false];
}
// handle ETH
if (address.toLowerCase() === token_1.Token.ETHER.address) {
return [token_1.Token.ETHER, false];
}
// cross-chain cache
const cached = exports.globalSharedTokenMap.get(address);
if (cached) {
return [cached, false];
}
let token = this.tokenByAddressMap.get(address);
if (token) {
return [token, false];
}
token = await (0, fetchToken_1.default)(provider, address);
if (!token) {
return [null, true];
}
if (shouldRegister) {
this.registerToken(token, isIndexed);
}
return [token, true];
}
static isTokenIndexed(address) {
// handle ETH
if (address === token_1.Token.ETHER.address) {
return true;
}
return this.indexedTokenMap.has(address);
}
static isTokenVerified(address) {
// handle ETH
if (address === token_1.Token.ETHER.address) {
return true;
}
return this.verifiedTokenMap.has(address);
}
static getIndexedTokens() {
return [token_1.Token.ETHER].concat(Array.from(this.indexedTokenMap.values()));
}
static getVerifiedTokens() {
return [token_1.Token.ETHER].concat(Array.from(this.verifiedTokenMap.values()));
}
static getHiddenListedTokens() {
return Array.from(this.hiddenListedTokenMap.values());
}
static getToken(address) {
return this.tokenByAddressMap.get(address) ?? token_1.Token.ETHER;
}
static getAllTokens() {
return [token_1.Token.ETHER].concat(this.allTokens);
}
}
exports.TokenRegistry = TokenRegistry;
TokenRegistry.allTokens = [];
TokenRegistry.tokenByAddressMap = caseInsensitiveMap_1.CaseInsensitiveMap.create();
TokenRegistry.tokenBySymbolMap = caseInsensitiveMap_1.CaseInsensitiveMap.create();
TokenRegistry.indexedTokenMap = caseInsensitiveMap_1.CaseInsensitiveMap.create();
TokenRegistry.verifiedTokenMap = caseInsensitiveMap_1.CaseInsensitiveMap.create();
TokenRegistry.hiddenListedTokenMap = caseInsensitiveMap_1.CaseInsensitiveMap.create();
// Helper function to ensure a token is registered
function ensureTokenRegistered(tokenData) {
if (!tokenData || !tokenData.address) {
return;
}
const existingToken = TokenRegistry.getTokenByAddress(tokenData.address);
if (!existingToken) {
const token = new token_1.Token(tokenData.address, tokenData.decimals || 18, tokenData.symbol || "UNKNOWN", tokenData.name || "Unknown Token", tokenData.logoURI, tokenData.hidden);
TokenRegistry.registerToken(token, !token.hidden);
}
}
//# sourceMappingURL=tokenRegistry.js.map