@btc-vision/transaction/build/metadata/tokens.js

OPNet transaction library allows you to create and sign transactions for the OPNet network.

import { ChainId } from '../network/ChainId.js';
import { Address } from '../keypair/Address.js';
function deadAddress() {
    return Address.dead();
}
export const FACTORY_ADDRESS_REGTEST = deadAddress();
export const POOL_ADDRESS_REGTEST = deadAddress();
export const WBTC_ADDRESS_REGTEST = deadAddress();
export const MOTO_ADDRESS_REGTEST = deadAddress();
export const ROUTER_ADDRESS_REGTEST = deadAddress();
export const FACTORY_ADDRESS_TESTNET = deadAddress();
export const POOL_ADDRESS_TESTNET = deadAddress();
export const WBTC_ADDRESS_TESTNET = deadAddress();
export const MOTO_ADDRESS_TESTNET = deadAddress();
export const ROUTER_ADDRESS_TESTNET = deadAddress();
export const FACTORY_ADDRESS_FRACTAL = deadAddress();
export const POOL_ADDRESS_FRACTAL = deadAddress();
export const WBTC_ADDRESS_FRACTAL = deadAddress();
export const MOTO_ADDRESS_FRACTAL = deadAddress();
export const ROUTER_ADDRESS_FRACTAL = deadAddress();
export var OPNetNetwork;
(function (OPNetNetwork) {
    OPNetNetwork["Mainnet"] = "mainnet";
    OPNetNetwork["Testnet"] = "testnet";
    OPNetNetwork["Regtest"] = "regtest";
})(OPNetNetwork || (OPNetNetwork = {}));
export class OPNetTokenAddressManager {
    constructor() {
        this.metadata = {
            [ChainId.Bitcoin]: {
                [OPNetNetwork.Testnet]: {
                    factory: FACTORY_ADDRESS_TESTNET,
                    pool: POOL_ADDRESS_TESTNET,
                    wbtc: WBTC_ADDRESS_TESTNET,
                    moto: MOTO_ADDRESS_TESTNET,
                    router: ROUTER_ADDRESS_TESTNET,
                },
                [OPNetNetwork.Regtest]: {
                    factory: FACTORY_ADDRESS_REGTEST,
                    pool: POOL_ADDRESS_REGTEST,
                    wbtc: WBTC_ADDRESS_REGTEST,
                    moto: MOTO_ADDRESS_REGTEST,
                    router: ROUTER_ADDRESS_REGTEST,
                },
            },
            [ChainId.Fractal]: {
                [OPNetNetwork.Mainnet]: {
                    factory: FACTORY_ADDRESS_FRACTAL,
                    pool: POOL_ADDRESS_FRACTAL,
                    wbtc: WBTC_ADDRESS_FRACTAL,
                    moto: MOTO_ADDRESS_FRACTAL,
                    router: ROUTER_ADDRESS_FRACTAL,
                },
            },
        };
    }
    getFactoryAddress(network, chainId) {
        const address = this.metadata[chainId][network]?.factory;
        if (!address) {
            throw new Error(`Factory address not found for network ${network} and chainId ${chainId}`);
        }
        return address;
    }
    getPoolAddress(network, chainId) {
        const address = this.metadata[chainId][network]?.pool;
        if (!address) {
            throw new Error(`Pool address not found for network ${network} and chainId ${chainId}`);
        }
        return address;
    }
    getWBTCAddress(network, chainId) {
        const address = this.metadata[chainId][network]?.wbtc;
        if (!address) {
            throw new Error(`WBTC address not found for network ${network} and chainId ${chainId}`);
        }
        return address;
    }
    getMOTOAddress(network, chainId) {
        const address = this.metadata[chainId][network]?.moto;
        if (!address) {
            throw new Error(`MOTO address not found for network ${network} and chainId ${chainId}`);
        }
        return address;
    }
    getRouterAddress(network, chainId) {
        const address = this.metadata[chainId][network]?.router;
        if (!address) {
            throw new Error(`Router address not found for network ${network} and chainId ${chainId}`);
        }
        return address;
    }
    getAddresses(network, chainId) {
        const metadata = this.metadata[chainId][network];
        if (!metadata) {
            throw new Error(`Metadata not found for network ${network} and chainId ${chainId}`);
        }
        return metadata;
    }
}
export const OPNetMetadata = new OPNetTokenAddressManager();