@mememax/sdk-core 0.0.1

package/dist/clients/ETHClient.d.ts

@@ -0,0 +1,101 @@
+import OrbixSDK, { Orbix } from "../OrbixSDK";
+import { EthNetworkConfig, NetworkConfig, NetworkConfigProvider } from "../constant";
+import { BlockchainV2, EVMChain } from "../util/blockchain";
+import { TokenInitInfo, TokensWithExternalBalance } from "../util/external";
+import BigNumber from "bignumber.js";
+import { ethers } from "ethers";
+import TokenClient from "./TokenClient";
+export interface ETHClientOpts {
+    configProvider: NetworkConfigProvider;
+    tokenClient: TokenClient;
+    blockchain: BlockchainV2;
+    rpcURL: string;
+}
+interface ETHTxParams {
+    gasPriceGwei?: BigNumber;
+    gasLimit?: BigNumber;
+    ethAddress: string;
+    signer: ethers.Signer;
+    nonce?: number;
+}
+export interface BridgeParams {
+    fromToken: Orbix.Coin.Token;
+    toToken: Orbix.Coin.Token;
+    amount: BigNumber;
+    fromAddress: string;
+    recoveryAddress: string;
+    toAddress: string;
+    feeAmount: BigNumber;
+    gasPriceGwei?: BigNumber;
+    gasLimit?: BigNumber;
+    signer: ethers.Signer;
+    signCompleteCallback?: () => void;
+    nonce?: number;
+}
+export interface LockParams extends ETHTxParams {
+    address: Uint8Array;
+    amount: BigNumber;
+    token: Orbix.Coin.Token;
+    signCompleteCallback?: () => void;
+}
+export interface ApproveERC20Params extends ETHTxParams {
+    token: Orbix.Coin.Token;
+    spenderAddress?: string;
+    amount?: BigNumber;
+    signCompleteCallback?: () => void;
+}
+export interface EthersTransactionResponse extends ethers.Transaction {
+    wait: () => Promise<ethers.Transaction>;
+}
+export declare const FEE_MULTIPLIER: ethers.BigNumber;
+export declare class ETHClient {
+    readonly configProvider: NetworkConfigProvider;
+    readonly blockchain: EVMChain;
+    readonly tokenClient: TokenClient;
+    readonly rpcURL: string;
+    private constructor();
+    static instance(opts: ETHClientOpts): OrbixSDK.ETHClient;
+    getExternalBalances(api: OrbixSDK, address: string, whitelistDenoms?: string[], version?: string): Promise<TokensWithExternalBalance[]>;
+    approveERC20(params: ApproveERC20Params): Promise<EthersTransactionResponse>;
+    checkAllowanceERC20(token: Orbix.Coin.Token, owner: string, spender: string): Promise<BigNumber>;
+    bridgeTokens(params: BridgeParams): Promise<EthersTransactionResponse>;
+    lockDeposit(params: LockParams): Promise<EthersTransactionResponse>;
+    getDepositContractAddress(swthBech32Address: string, ownerEthAddress: string): Promise<string>;
+    sendDeposit(tokenWithExternalBalances: TokensWithExternalBalance, swthAddress: string, ethAddress: string, getSignatureCallback: (msg: string) => Promise<{
+        address: string;
+        signature: string;
+    }>, overrideFee?: ethers.BigNumber): Promise<Response | "insufficient balance">;
+    getDepositFeeAmount(token: Orbix.Coin.Token, depositAddress: string): Promise<ethers.BigNumber>;
+    isContract(address: string): Promise<boolean>;
+    retrieveERC20Info(address: string): Promise<TokenInitInfo>;
+    static formatWithdrawalAddress(address: string): string;
+    getEthSigner(privateKey: ethers.utils.BytesLike): ethers.Wallet;
+    sign(message: string, privateKey: ethers.utils.BytesLike): Promise<{
+        address: string;
+        signature: string;
+    }>;
+    /**
+     * TargetProxyHash is a hash of token originator address that is used
+     * for lockproxy asset registration and identification
+     *
+     * @param token
+     */
+    getTargetProxyHash(token: Orbix.Coin.Token): string;
+    getProvider(): ethers.providers.JsonRpcProvider;
+    getNetworkConfig(): NetworkConfig;
+    getConfig(): EthNetworkConfig;
+    getPayerUrl(): string;
+    getProviderUrl(): string;
+    getLockProxyAddress(): string;
+    getBalanceReaderAddress(): string;
+    getWalletBytecodeHash(): string;
+    getBridgeEntranceAddr(): string;
+    /**
+     * verify that address is a valid checksum.
+     * Returns checksum address if valid, returns undefined if invalid
+     * @input address to be verified
+     */
+    verifyChecksum(input: string): string | undefined;
+    getTxNonce(ethAddress: string, customNonce?: number, provider?: ethers.providers.JsonRpcProvider): Promise<number>;
+}
+export default ETHClient;

package/dist/clients/ETHClient.js

@@ -0,0 +1,344 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ETHClient = exports.FEE_MULTIPLIER = void 0;
+const constant_1 = require("../constant");
+const eth_1 = require("../eth");
+const util_1 = require("../util");
+const address_1 = require("../util/address");
+const blockchain_1 = require("../util/blockchain");
+const generic_1 = require("../util/generic");
+const number_1 = require("../util/number");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ethers_1 = require("ethers");
+exports.FEE_MULTIPLIER = ethers_1.ethers.BigNumber.from(2);
+class ETHClient {
+    constructor(configProvider, blockchain, tokenClient, rpcURL) {
+        this.configProvider = configProvider;
+        this.blockchain = blockchain;
+        this.tokenClient = tokenClient;
+        this.rpcURL = rpcURL;
+    }
+    static instance(opts) {
+        const { configProvider, blockchain, tokenClient, rpcURL } = opts;
+        if (!util_1.BlockchainUtils.isEvmChain(blockchain) || blockchain === 'Orbix') {
+            throw new Error(`unsupported blockchain - ${blockchain}`);
+        }
+        return new ETHClient(configProvider, blockchain, tokenClient, rpcURL);
+    }
+    async getExternalBalances(api, address, whitelistDenoms, version = "V1") {
+        const tokenQueryResults = await api.token.getAllTokens();
+        const lockProxyAddress = this.getLockProxyAddress().toLowerCase();
+        const tokens = tokenQueryResults.filter((token) => {
+            const isCorrectBlockchain = version === "V2"
+                ?
+                    this.tokenClient.getBlockchainV2(token.denom) == this.blockchain
+                :
+                    (0, blockchain_1.blockchainForChainId)(token.chainId.toNumber(), api.network) == blockchain_1.BLOCKCHAIN_V2_TO_V1_MAPPING[this.blockchain];
+            return isCorrectBlockchain &&
+                token.tokenAddress.length == 40 &&
+                token.bridgeAddress.toLowerCase() == (0, generic_1.stripHexPrefix)(lockProxyAddress) &&
+                (!whitelistDenoms || whitelistDenoms.includes(token.denom)) &&
+                this.verifyChecksum((0, generic_1.appendHexPrefix)(token.tokenAddress));
+        });
+        const assetIds = tokens.map((token) => {
+            return this.verifyChecksum((0, generic_1.appendHexPrefix)(token.tokenAddress));
+        });
+        const provider = this.getProvider();
+        const contractAddress = this.getBalanceReaderAddress();
+        const contract = new ethers_1.ethers.Contract(contractAddress, eth_1.ABIs.balanceReader, provider);
+        const checkSumAddr = ethers_1.ethers.utils.getAddress(address);
+        const balances = await contract.getBalances(checkSumAddr, assetIds);
+        const TokensWithExternalBalance = [];
+        for (let i = 0; i < assetIds.length; i++) {
+            if (!tokens[i])
+                continue;
+            TokensWithExternalBalance.push({
+                ...tokens[i],
+                externalBalance: balances[i].toString(),
+            });
+        }
+        return TokensWithExternalBalance;
+    }
+    async approveERC20(params) {
+        const { token, gasPriceGwei, gasLimit, ethAddress, spenderAddress, signer, amount } = params;
+        const contractAddress = token.tokenAddress;
+        const rpcProvider = this.getProvider();
+        const contract = new ethers_1.ethers.Contract(contractAddress, eth_1.ABIs.erc20, rpcProvider);
+        const approvalAmount = ethers_1.ethers.BigNumber.from(amount?.toString(10) ?? ethers_1.ethers.constants.MaxUint256);
+        const nonce = await this.getTxNonce(ethAddress, params.nonce, rpcProvider);
+        const approveResultTx = await contract.connect(signer).approve(spenderAddress ?? token.bridgeAddress, approvalAmount, {
+            nonce,
+            ...gasPriceGwei && ({ gasPrice: gasPriceGwei.shiftedBy(9).dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10) }),
+            ...gasLimit && ({ gasLimit: gasLimit.dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10) }),
+        });
+        return approveResultTx;
+    }
+    async checkAllowanceERC20(token, owner, spender) {
+        const contractAddress = token.tokenAddress;
+        const rpcProvider = this.getProvider();
+        const contract = new ethers_1.ethers.Contract(contractAddress, eth_1.ABIs.erc20, rpcProvider);
+        const allowance = await contract.allowance(owner, spender);
+        return new bignumber_js_1.default(allowance.toString());
+    }
+    async bridgeTokens(params) {
+        const { fromToken, toToken, amount, toAddress, fromAddress, recoveryAddress, signer, gasPriceGwei, gasLimit, feeAmount, signCompleteCallback, } = params;
+        const networkConfig = this.getNetworkConfig();
+        const rpcProvider = this.getProvider();
+        const recoveryAddrRegex = new RegExp(`^${networkConfig.Bech32Prefix}[a-z0-9]{39}$`);
+        if (!recoveryAddress.match(recoveryAddrRegex)) {
+            throw new Error("Invalid recovery address");
+        }
+        const orbixNetwork = networkConfig.network;
+        const fromTokenId = fromToken.id;
+        const fromTokenAddress = (0, generic_1.appendHexPrefix)(fromToken.tokenAddress);
+        const toTokenDenom = toToken.denom;
+        const recoveryAddressHex = ethers_1.ethers.utils.hexlify(util_1.AddressUtils.SWTHAddress.getAddressBytes(recoveryAddress, orbixNetwork));
+        const fromAssetHash = ethers_1.ethers.utils.hexlify(ethers_1.ethers.utils.toUtf8Bytes(fromTokenId));
+        const toAssetHash = ethers_1.ethers.utils.hexlify(ethers_1.ethers.utils.toUtf8Bytes(toTokenDenom));
+        const nonce = await this.getTxNonce(fromAddress, params.nonce, rpcProvider);
+        const contract = new ethers_1.ethers.Contract(this.getBridgeEntranceAddr(), eth_1.ABIs.bridgeEntrance, rpcProvider);
+        const feeAddress = (0, generic_1.appendHexPrefix)(networkConfig.feeAddress);
+        const tokenCreator = fromToken.creator;
+        const targetAddressBytes = util_1.AddressUtils.SWTHAddress.getAddressBytes(tokenCreator, orbixNetwork);
+        const targetProxyHash = ethers_1.ethers.utils.hexlify(targetAddressBytes);
+        const ethAmount = fromToken.tokenAddress === constant_1.NativeTokenHash ? amount : number_1.BN_ZERO;
+        const bridgeResultTx = await contract.connect(signer).lock(fromTokenAddress, // the asset to deposit (from) (0x00 if eth)
+        [
+            targetProxyHash, // _targetProxyHash
+            recoveryAddressHex, // _recoveryAddress
+            fromAssetHash, // _fromAssetHash
+            feeAddress, // _feeAddress
+            toAddress, // _toAddress the L1 address to bridge to
+            toAssetHash, // _toAssetHash
+        ], [
+            amount.dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10), // amount
+            feeAmount.dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10), // fee amount
+            amount.dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10),
+        ], // callAmount
+        {
+            ...gasPriceGwei && ({ gasPrice: gasPriceGwei.shiftedBy(9).dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10) }),
+            ...gasLimit && ({ gasLimit: gasLimit.dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10) }),
+            nonce,
+            value: ethAmount.dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10),
+        });
+        signCompleteCallback?.();
+        return bridgeResultTx;
+    }
+    async lockDeposit(params) {
+        const { address, token, amount, gasPriceGwei, gasLimit, ethAddress, signer, signCompleteCallback } = params;
+        if (gasLimit?.lt(150000)) {
+            throw new Error("Minimum gas required: 150,000");
+        }
+        const networkConfig = this.getNetworkConfig();
+        const assetId = (0, generic_1.appendHexPrefix)(token.tokenAddress);
+        const targetProxyHash = (0, generic_1.appendHexPrefix)(this.getTargetProxyHash(token));
+        const feeAddress = (0, generic_1.appendHexPrefix)(networkConfig.feeAddress);
+        const toAssetHash = ethers_1.ethers.utils.hexlify(ethers_1.ethers.utils.toUtf8Bytes(token.id));
+        const swthAddress = ethers_1.ethers.utils.hexlify(address);
+        const contractAddress = this.getLockProxyAddress();
+        const rpcProvider = this.getProvider();
+        const nonce = await this.getTxNonce(ethAddress, params.nonce, rpcProvider);
+        const contract = new ethers_1.ethers.Contract(contractAddress, eth_1.ABIs.lockProxy, rpcProvider);
+        const lockResultTx = await contract.connect(signer).lock(assetId, // _assetHash
+        targetProxyHash, // _targetProxyHash
+        swthAddress, // _toAddress
+        toAssetHash, // _toAssetHash
+        feeAddress, // _feeAddress
+        [
+            // _values
+            amount.dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10), // amount
+            "0", // feeAmount
+            amount.dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10), // callAmount
+        ], {
+            nonce,
+            value: "0",
+            ...gasPriceGwei && ({ gasPrice: gasPriceGwei.shiftedBy(9).dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10) }),
+            ...gasLimit && ({ gasLimit: gasLimit.dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10) }),
+            // add tx value for ETH deposits, omit if ERC20 token
+            ...(token.tokenAddress === "0000000000000000000000000000000000000000" && {
+                value: amount.dp(0, bignumber_js_1.default.ROUND_FLOOR).toString(10),
+            }),
+        });
+        signCompleteCallback?.();
+        return lockResultTx;
+    }
+    async getDepositContractAddress(swthBech32Address, ownerEthAddress) {
+        const network = this.getNetworkConfig().network;
+        const addressBytes = address_1.SWTHAddress.getAddressBytes(swthBech32Address, network);
+        const swthAddress = ethers_1.ethers.utils.hexlify(addressBytes);
+        const provider = this.getProvider();
+        const contractAddress = this.getLockProxyAddress();
+        // logger("getDepositContractAddress lock proxy", contractAddress)
+        const contract = new ethers_1.ethers.Contract(contractAddress, eth_1.ABIs.lockProxy, provider);
+        const walletAddress = await contract.getWalletAddress(ownerEthAddress, swthAddress, this.getWalletBytecodeHash());
+        // logger("getDepositContractAddress", swthBech32Address, ownerEthAddress, walletAddress)
+        return walletAddress;
+    }
+    async sendDeposit(tokenWithExternalBalances, swthAddress, ethAddress, getSignatureCallback, overrideFee) {
+        const depositAddress = await this.getDepositContractAddress(swthAddress, ethAddress);
+        // TODO: Remove overrideFee when hydrogen feeQuote is deployed on production
+        let feeAmount = await this.getDepositFeeAmount(tokenWithExternalBalances, depositAddress);
+        if (overrideFee) {
+            feeAmount = overrideFee;
+        }
+        const amount = ethers_1.ethers.BigNumber.from(tokenWithExternalBalances.externalBalance);
+        if (amount.lt(feeAmount)) {
+            return "insufficient balance";
+        }
+        const networkConfig = this.getNetworkConfig();
+        const assetId = (0, generic_1.appendHexPrefix)(tokenWithExternalBalances.tokenAddress);
+        const targetProxyHash = (0, generic_1.appendHexPrefix)(this.getTargetProxyHash(tokenWithExternalBalances));
+        const feeAddress = (0, generic_1.appendHexPrefix)(networkConfig.feeAddress);
+        const toAssetHash = ethers_1.ethers.utils.hexlify(ethers_1.ethers.utils.toUtf8Bytes(tokenWithExternalBalances.id));
+        const nonce = Math.floor(Math.random() * 1000000000); // random nonce to prevent replay attacks
+        const message = ethers_1.ethers.utils.solidityKeccak256(["string", "address", "bytes", "bytes", "bytes", "uint256", "uint256", "uint256"], ["sendTokens", assetId, targetProxyHash, toAssetHash, feeAddress, amount, feeAmount, nonce]);
+        // logger("sendDeposit message", message)
+        const { address, signature } = await getSignatureCallback(message);
+        const signatureBytes = ethers_1.ethers.utils.arrayify((0, generic_1.appendHexPrefix)(signature));
+        const rsv = ethers_1.ethers.utils.splitSignature(signatureBytes);
+        // logger("sign result", address, signature)
+        const signatureResult = {
+            owner: address,
+            v: rsv.v.toString(),
+            r: rsv.r,
+            s: rsv.s,
+        };
+        const network = this.getNetworkConfig().network;
+        const addressBytes = address_1.SWTHAddress.getAddressBytes(swthAddress, network);
+        const swthAddressHex = ethers_1.ethers.utils.hexlify(addressBytes);
+        const body = {
+            owner_address: signatureResult.owner,
+            swth_address: swthAddressHex,
+            token_address: assetId,
+            token_creator: targetProxyHash,
+            token_denom: tokenWithExternalBalances.denom,
+            token_id: tokenWithExternalBalances.id,
+            amount: amount.toString(),
+            fee_amount: feeAmount.toString(),
+            fee_address: feeAddress,
+            nonce: nonce.toString(),
+            v: signatureResult.v,
+            r: signatureResult.r,
+            s: signatureResult.s,
+            blockchain: this.blockchain,
+        };
+        const result = await fetch(this.getPayerUrl() + "/deposit", { method: "POST", body: JSON.stringify(body) });
+        // logger("fetch result", result)
+        return result;
+    }
+    async getDepositFeeAmount(token, depositAddress) {
+        const feeInfo = await this.tokenClient.getFeeInfo(token.denom);
+        if (!feeInfo.deposit_fee) {
+            throw new Error("unsupported token");
+        }
+        if ((0, blockchain_1.blockchainForChainId)(token.chainId.toNumber(), this.configProvider.getConfig().network) !== blockchain_1.BLOCKCHAIN_V2_TO_V1_MAPPING[this.blockchain]) {
+            throw new Error("unsupported token");
+        }
+        let feeAmount = ethers_1.ethers.BigNumber.from(feeInfo.deposit_fee);
+        const walletContractDeployed = await this.isContract(depositAddress);
+        if (!walletContractDeployed) {
+            feeAmount = feeAmount.add(ethers_1.ethers.BigNumber.from(feeInfo.create_wallet_fee));
+        }
+        return feeAmount;
+    }
+    async isContract(address) {
+        const provider = this.getProvider();
+        const code = await provider.getCode(address);
+        // non-contract addresses should return 0x
+        return code !== "0x";
+    }
+    async retrieveERC20Info(address) {
+        const provider = this.getProvider();
+        const contract = new ethers_1.ethers.Contract(address, eth_1.ABIs.erc20, provider);
+        const decimals = await contract.decimals();
+        const name = await contract.name();
+        const symbol = await contract.symbol();
+        return { address, decimals, name, symbol };
+    }
+    static formatWithdrawalAddress(address) {
+        const isValidAddress = ethers_1.ethers.utils.isAddress(address);
+        if (!isValidAddress) {
+            throw new Error("invalid address");
+        }
+        return address.substr(2);
+    }
+    getEthSigner(privateKey) {
+        return new ethers_1.ethers.Wallet(privateKey, this.getProvider());
+    }
+    async sign(message, privateKey) {
+        const ethWallet = this.getEthSigner(privateKey);
+        const messageBytes = ethers_1.ethers.utils.arrayify(message);
+        const signatureBytes = await ethWallet.signMessage(messageBytes);
+        const signature = ethers_1.ethers.utils.hexlify(signatureBytes).replace(/^0x/g, "");
+        return {
+            address: ethWallet.address,
+            signature,
+        };
+    }
+    /**
+     * TargetProxyHash is a hash of token originator address that is used
+     * for lockproxy asset registration and identification
+     *
+     * @param token
+     */
+    getTargetProxyHash(token) {
+        const networkConfig = this.getNetworkConfig();
+        const addressBytes = address_1.SWTHAddress.getAddressBytes(token.creator, networkConfig.network);
+        const addressHex = (0, generic_1.stripHexPrefix)(ethers_1.ethers.utils.hexlify(addressBytes));
+        return addressHex;
+    }
+    getProvider() {
+        return new ethers_1.ethers.providers.JsonRpcProvider(this.getProviderUrl());
+    }
+    getNetworkConfig() {
+        return this.configProvider.getConfig();
+    }
+    getConfig() {
+        const networkConfig = this.getNetworkConfig();
+        const blockchainKey = blockchain_1.BLOCKCHAIN_V2_TO_V1_MAPPING[this.blockchain];
+        return networkConfig[blockchainKey];
+    }
+    getPayerUrl() {
+        return this.getConfig().payerURL;
+    }
+    getProviderUrl() {
+        return this.rpcURL;
+    }
+    getLockProxyAddress() {
+        return this.getConfig().lockProxyAddr;
+    }
+    getBalanceReaderAddress() {
+        return this.getConfig().balanceReader;
+    }
+    getWalletBytecodeHash() {
+        return this.getConfig().byteCodeHash;
+    }
+    getBridgeEntranceAddr() {
+        return this.getConfig().bridgeEntranceAddr;
+    }
+    /**
+     * verify that address is a valid checksum.
+     * Returns checksum address if valid, returns undefined if invalid
+     * @input address to be verified
+     */
+    verifyChecksum(input) {
+        try {
+            return ethers_1.ethers.utils.getAddress(input);
+        }
+        catch {
+            // empty catch
+        }
+    }
+    async getTxNonce(ethAddress, customNonce, provider) {
+        if (customNonce && isFinite(customNonce))
+            return customNonce;
+        const rpcProvider = provider ?? this.getProvider();
+        const nonce = await rpcProvider.getTransactionCount(ethAddress);
+        return nonce;
+    }
+}
+exports.ETHClient = ETHClient;
+exports.default = ETHClient;

package/dist/clients/GasFee.d.ts

@@ -0,0 +1,12 @@
+import { SimpleMap } from "../util/type";
+import BigNumber from "bignumber.js";
+declare class GasFee {
+    readonly txGasCosts: SimpleMap<BigNumber>;
+    readonly txGasPrices: SimpleMap<BigNumber>;
+    readonly defaultFeeDenom: string;
+    constructor(txGasCosts: SimpleMap<BigNumber>, txGasPrices: SimpleMap<BigNumber>, defaultFeeDenom?: string);
+    getFee(msgTypeUrl: string, denom?: string): BigNumber | null;
+    getGasPrice(denom: string): BigNumber | null;
+    getGasCost(msgTypeUrl: string): BigNumber;
+}
+export default GasFee;

package/dist/clients/GasFee.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constant_1 = require("../constant");
+const number_1 = require("../util/number");
+const tx_1 = require("../util/tx");
+class GasFee {
+    constructor(txGasCosts, txGasPrices, defaultFeeDenom = constant_1.DEFAULT_FEE_DENOM) {
+        this.txGasCosts = txGasCosts;
+        this.txGasPrices = txGasPrices;
+        this.defaultFeeDenom = defaultFeeDenom;
+    }
+    getFee(msgTypeUrl, denom = constant_1.DEFAULT_FEE_DENOM) {
+        const minGasPrice = this.getGasPrice(denom);
+        if (!minGasPrice)
+            return null;
+        const msgGasCost = this.getGasCost(msgTypeUrl);
+        return msgGasCost.times(minGasPrice);
+    }
+    getGasPrice(denom) {
+        const gasPrice = this.txGasPrices[denom];
+        if (!gasPrice) {
+            console.warn("denom not supported for paying gas", denom);
+        }
+        return gasPrice ?? null;
+    }
+    getGasCost(msgTypeUrl) {
+        return this.txGasCosts[msgTypeUrl] ?? this.txGasCosts[tx_1.TxGasCostTypeDefaultKey] ?? number_1.BN_ZERO;
+    }
+}
+exports.default = GasFee;

package/dist/clients/GrpcQueryClient.d.ts

@@ -0,0 +1,22 @@
+import { ProtobufRpcClient } from "@cosmjs/stargate";
+import { grpc } from "@improbable-eng/grpc-web";
+export declare class GrpcWebError extends Error {
+    code: grpc.Code;
+    metadata: grpc.Metadata;
+    constructor(message: string, code: grpc.Code, metadata: grpc.Metadata);
+}
+/**
+ * Uses grpc-web module on cosmos-sdk to simulate gRPC queries
+ * throught HTTP/1.1.
+ * see https://github.com/cosmos/cosmos-sdk/issues/7345
+ */
+export declare class GrpcQueryClient implements ProtobufRpcClient {
+    private host;
+    private options;
+    constructor(host: string, options?: {
+        transport?: grpc.TransportFactory;
+        metadata?: grpc.Metadata;
+    });
+    request(serviceName: string, methodName: string, data: Uint8Array): Promise<Uint8Array>;
+}
+export default GrpcQueryClient;

package/dist/clients/GrpcQueryClient.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrpcQueryClient = exports.GrpcWebError = void 0;
+const grpc_web_1 = require("@improbable-eng/grpc-web");
+class GrpcWebError extends Error {
+    constructor(message, code, metadata) {
+        super(message);
+        this.code = code;
+        this.metadata = metadata;
+    }
+}
+exports.GrpcWebError = GrpcWebError;
+/**
+ * Uses grpc-web module on cosmos-sdk to simulate gRPC queries
+ * throught HTTP/1.1.
+ * see https://github.com/cosmos/cosmos-sdk/issues/7345
+ */
+class GrpcQueryClient {
+    constructor(host, options = {}) {
+        this.host = host;
+        this.options = options;
+    }
+    request(serviceName, methodName, data) {
+        return new Promise((resolve, reject) => {
+            grpc_web_1.grpc.unary({
+                methodName,
+                service: { serviceName },
+                requestStream: false,
+                responseStream: false,
+                requestType: {},
+                responseType: {
+                    deserializeBinary: (data) => data,
+                },
+            }, {
+                request: {
+                    ...data,
+                    toObject: () => data,
+                    serializeBinary: () => data,
+                },
+                host: this.host,
+                metadata: this.options.metadata,
+                transport: this.options.transport,
+                debug: false,
+                onEnd: function (response) {
+                    if (response.status === grpc_web_1.grpc.Code.OK) {
+                        resolve(response.message);
+                    }
+                    else {
+                        const err = new Error(response.statusMessage);
+                        err.code = response.status;
+                        err.metadata = response.trailers;
+                        reject(err);
+                    }
+                },
+            });
+        });
+    }
+}
+exports.GrpcQueryClient = GrpcQueryClient;
+exports.default = GrpcQueryClient;

package/dist/clients/HydrogenClient.d.ts

@@ -0,0 +1,28 @@
+import { NetworkConfig } from "../constant";
+import { BlockchainUtils } from "../util";
+import { CrossChainTransfer, CrossChainTransferDetailed, GetDetailedTransfersResponse, GetRelaysRequest, GetRelaysResponse, GetStatsResponse, GetTransfersRequest, GetTransfersResponse } from "../hydrogen";
+import { GetFeeQuoteRequest, GetFeeQuoteResponse } from "../hydrogen/feeQuote";
+import TokenClient from './TokenClient';
+export declare const HydrogenEndpoints: {
+    stats: string;
+    transfer_payloads: string;
+    relays: string;
+    fee_quote: string;
+    bridge_fee: string;
+};
+declare class HydrogenClient {
+    private config;
+    private readonly apiManager;
+    private readonly tokenClient;
+    constructor(config: NetworkConfig, tokenClient: TokenClient);
+    static instance(config: NetworkConfig, tokenClient: TokenClient): HydrogenClient;
+    checkState(): void;
+    formatCrossChainTransferV2: (value: any) => CrossChainTransfer;
+    formatCrossChainTransferDetailedV2: (value: any) => CrossChainTransferDetailed;
+    getStats(): Promise<GetStatsResponse>;
+    getTransfers(req: GetTransfersRequest, version?: string): Promise<GetTransfersResponse>;
+    getDetailedTransfers(req: GetTransfersRequest, version?: string): Promise<GetDetailedTransfersResponse>;
+    getRelaysTransfers(req: GetRelaysRequest): Promise<GetRelaysResponse>;
+    getFeeQuote(req: GetFeeQuoteRequest, blockchain?: BlockchainUtils.Blockchain | BlockchainUtils.BlockchainV2 | undefined, version?: string): Promise<GetFeeQuoteResponse>;
+}
+export default HydrogenClient;