example-js-sdk 0.0.1

package/lib/clients/CarbonQueryClient.d.ts

@@ -0,0 +1,108 @@
+import { QueryClientImpl as ADLQueryClient } from "../codec/mememax/orbix/adl/query";
+import { QueryClientImpl as BookQueryClient } from "../codec/mememax/orbix/book/query";
+import { QueryClientImpl as BrokerQueryClient } from "../codec/mememax/orbix/broker/query";
+import { QueryClientImpl as CoinQueryClient } from "../codec/mememax/orbix/coin/query";
+import { QueryClientImpl as AuthQueryClient } from "../codec/cosmos/auth/v1beta1/query";
+import { QueryClientImpl as BankQueryClient } from "../codec/cosmos/bank/v1beta1/query";
+import { QueryClientImpl as NativeBankQueryClient } from "../codec/mememax/orbix/bank/query";
+import { QueryClientImpl as BridgeQueryClient } from "../codec/mememax/orbix/bridge/query";
+import { ServiceClientImpl as CosmosTmClient } from "../codec/cosmos/base/tendermint/v1beta1/query";
+import { QueryClientImpl as DistributionQueryClient } from "../codec/cosmos/distribution/v1beta1/query";
+import { QueryClientImpl as EvidenceQueryClient } from "../codec/cosmos/evidence/v1beta1/query";
+import { QueryClientImpl as GovQueryClient } from "../codec/cosmos/gov/v1/query";
+import { QueryClientImpl as GroupQueryClient } from "../codec/cosmos/group/v1/query";
+import { QueryClientImpl as MintQueryClient } from "../codec/cosmos/mint/v1beta1/query";
+import { QueryClientImpl as ParamsQueryClient } from "../codec/cosmos/params/v1beta1/query";
+import { QueryClientImpl as SlashingQueryClient } from "../codec/cosmos/slashing/v1beta1/query";
+import { QueryClientImpl as StakingQueryClient } from "../codec/cosmos/staking/v1beta1/query";
+import { QueryClientImpl as UpgradeQueryClient } from "../codec/cosmos/upgrade/v1beta1/query";
+import { QueryClientImpl as EthermintEVMQueryClient } from "../codec/ethermint/evm/v1/query";
+import { QueryClientImpl as GrantQueryClient } from "../codec/cosmos/authz/v1beta1/query";
+import { QueryClientImpl as FeeGrantQueryClient } from "../codec/cosmos/feegrant/v1beta1/query";
+import { QueryClientImpl as EvmMergeQueryClient } from "../codec/mememax/orbix/evmmerge/query";
+import { QueryClientImpl as EvmBankQueryClient } from "../codec/mememax/orbix/evmbank/query";
+import { QueryClientImpl as EthermintFeeMarketQueryClient } from "../codec/ethermint/feemarket/v1/query";
+import { QueryClientImpl as FeeQueryClient } from "../codec/mememax/orbix/fee/query";
+import { QueryClientImpl as IBCInterchainControlQueryClient } from "../codec/ibc/applications/interchain_accounts/controller/v1/query";
+import { QueryClientImpl as IBCInterchainHostQueryClient } from "../codec/ibc/applications/interchain_accounts/host/v1/query";
+import { QueryClientImpl as IBCTransferQueryClient } from "../codec/ibc/applications/transfer/v1/query";
+import { QueryClientImpl as IBCClientQueryClient } from "../codec/ibc/core/client/v1/query";
+import { QueryClientImpl as IBCConnectionQueryClient } from "../codec/ibc/core/connection/v1/query";
+import { QueryClientImpl as IBCChannelQueryClient } from "../codec/ibc/core/channel/v1/query";
+import { QueryClientImpl as InsuranceQueryClient } from "../codec/mememax/orbix/insurance/query";
+import { QueryClientImpl as LeverageQueryClient } from "../codec/mememax/orbix/leverage/query";
+import { QueryClientImpl as LiquidationQueryClient } from "../codec/mememax/orbix/liquidation/query";
+import { QueryClientImpl as MarketQueryClient } from "../codec/mememax/orbix/market/query";
+import { QueryClientImpl as MarketStatsQueryClient } from "../codec/mememax/orbix/marketstats/query";
+import { QueryClientImpl as MiscQueryClient } from "../codec/mememax/orbix/misc/query";
+import { QueryClientImpl as OracleQueryClient } from "../codec/mememax/orbix/oracle/query";
+import { QueryClientImpl as OrderQueryClient } from "../codec/mememax/orbix/order/query";
+import { QueryClientImpl as PositionQueryClient } from "../codec/mememax/orbix/position/query";
+import { QueryClientImpl as PricingQueryClient } from "../codec/mememax/orbix/pricing/query";
+import { QueryClientImpl as SubaccountQueryClient } from "../codec/mememax/orbix/subaccount/query";
+import { QueryClientImpl as AllianceClient } from "../codec/alliance/alliance/query";
+import { QueryClientImpl as PerpspoolQueryClient } from "../codec/mememax/orbix/perpspool/query";
+import { QueryClientImpl as AdminQueryClient } from "../codec/mememax/orbix/admin/query";
+import { Tendermint37Client } from "@cosmjs/tendermint-rpc";
+import BlockchainClient from "./BlockchainClient";
+import GrpcQueryClient from "./GrpcQueryClient";
+export interface IBCClientGroup {
+    controller: IBCInterchainControlQueryClient;
+    host: IBCInterchainHostQueryClient;
+    transfer: IBCTransferQueryClient;
+    client: IBCClientQueryClient;
+    connection: IBCConnectionQueryClient;
+    channel: IBCChannelQueryClient;
+}
+export interface EthermintClientGroup {
+    evm: EthermintEVMQueryClient;
+    feeMarket: EthermintFeeMarketQueryClient;
+}
+export interface CarbonQueryClientOpts {
+    tmClient: Tendermint37Client;
+    grpcClient?: GrpcQueryClient;
+}
+declare class CarbonQueryClient {
+    adl: ADLQueryClient;
+    book: BookQueryClient;
+    bridge: BridgeQueryClient;
+    broker: BrokerQueryClient;
+    coin: CoinQueryClient;
+    fee: FeeQueryClient;
+    insurance: InsuranceQueryClient;
+    leverage: LeverageQueryClient;
+    liquidation: LiquidationQueryClient;
+    market: MarketQueryClient;
+    marketstats: MarketStatsQueryClient;
+    misc: MiscQueryClient;
+    oracle: OracleQueryClient;
+    order: OrderQueryClient;
+    position: PositionQueryClient;
+    pricing: PricingQueryClient;
+    subaccount: SubaccountQueryClient;
+    perpspool: PerpspoolQueryClient;
+    auth: AuthQueryClient;
+    bank: BankQueryClient;
+    nativeBank: NativeBankQueryClient;
+    distribution: DistributionQueryClient;
+    evidence: EvidenceQueryClient;
+    gov: GovQueryClient;
+    group: GroupQueryClient;
+    mint: MintQueryClient;
+    params: ParamsQueryClient;
+    slashing: SlashingQueryClient;
+    staking: StakingQueryClient;
+    upgrade: UpgradeQueryClient;
+    cosmosTm: CosmosTmClient;
+    grant: GrantQueryClient;
+    feegrant: FeeGrantQueryClient;
+    alliance: AllianceClient;
+    chain: BlockchainClient;
+    ibc: IBCClientGroup;
+    ethermint: EthermintClientGroup;
+    evmmerge: EvmMergeQueryClient;
+    evmbank: EvmBankQueryClient;
+    admin: AdminQueryClient;
+    constructor(opts: CarbonQueryClientOpts);
+}
+export default CarbonQueryClient;

package/lib/clients/CarbonQueryClient.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const query_1 = require("../codec/mememax/orbix/adl/query");
+const query_2 = require("../codec/mememax/orbix/book/query");
+const query_3 = require("../codec/mememax/orbix/broker/query");
+const query_4 = require("../codec/mememax/orbix/coin/query");
+const query_5 = require("../codec/cosmos/auth/v1beta1/query");
+const query_6 = require("../codec/cosmos/bank/v1beta1/query");
+const query_7 = require("../codec/mememax/orbix/bank/query");
+const query_8 = require("../codec/mememax/orbix/bridge/query");
+const query_9 = require("../codec/cosmos/base/tendermint/v1beta1/query");
+const query_10 = require("../codec/cosmos/distribution/v1beta1/query");
+const query_11 = require("../codec/cosmos/evidence/v1beta1/query");
+const query_12 = require("../codec/cosmos/gov/v1/query");
+const query_13 = require("../codec/cosmos/group/v1/query");
+const query_14 = require("../codec/cosmos/mint/v1beta1/query");
+const query_15 = require("../codec/cosmos/params/v1beta1/query");
+const query_16 = require("../codec/cosmos/slashing/v1beta1/query");
+const query_17 = require("../codec/cosmos/staking/v1beta1/query");
+const query_18 = require("../codec/cosmos/upgrade/v1beta1/query");
+const query_19 = require("../codec/ethermint/evm/v1/query");
+const query_20 = require("../codec/cosmos/authz/v1beta1/query");
+const query_21 = require("../codec/cosmos/feegrant/v1beta1/query");
+const query_22 = require("../codec/mememax/orbix/evmmerge/query");
+const query_23 = require("../codec/mememax/orbix/evmbank/query");
+const query_24 = require("../codec/ethermint/feemarket/v1/query");
+const query_25 = require("../codec/mememax/orbix/fee/query");
+const query_26 = require("../codec/ibc/applications/interchain_accounts/controller/v1/query");
+const query_27 = require("../codec/ibc/applications/interchain_accounts/host/v1/query");
+const query_28 = require("../codec/ibc/applications/transfer/v1/query");
+const query_29 = require("../codec/ibc/core/client/v1/query");
+const query_30 = require("../codec/ibc/core/connection/v1/query");
+const query_31 = require("../codec/ibc/core/channel/v1/query");
+const query_32 = require("../codec/mememax/orbix/insurance/query");
+const query_33 = require("../codec/mememax/orbix/leverage/query");
+const query_34 = require("../codec/mememax/orbix/liquidation/query");
+const query_35 = require("../codec/mememax/orbix/market/query");
+const query_36 = require("../codec/mememax/orbix/marketstats/query");
+const query_37 = require("../codec/mememax/orbix/misc/query");
+const query_38 = require("../codec/mememax/orbix/oracle/query");
+const query_39 = require("../codec/mememax/orbix/order/query");
+const query_40 = require("../codec/mememax/orbix/position/query");
+const query_41 = require("../codec/mememax/orbix/pricing/query");
+const query_42 = require("../codec/mememax/orbix/subaccount/query");
+const query_43 = require("../codec/alliance/alliance/query");
+const query_44 = require("../codec/mememax/orbix/perpspool/query");
+const query_45 = require("../codec/mememax/orbix/admin/query");
+const stargate_1 = require("@cosmjs/stargate");
+const BlockchainClient_1 = __importDefault(require("./BlockchainClient"));
+class CarbonQueryClient {
+    constructor(opts) {
+        const rpcClient = opts.grpcClient ?? (0, stargate_1.createProtobufRpcClient)(new stargate_1.QueryClient(opts.tmClient));
+        this.chain = BlockchainClient_1.default.connectWithTm(opts.tmClient);
+        this.adl = new query_1.QueryClientImpl(rpcClient);
+        this.alliance = new query_43.QueryClientImpl(rpcClient);
+        this.book = new query_2.QueryClientImpl(rpcClient);
+        this.bridge = new query_8.QueryClientImpl(rpcClient);
+        this.broker = new query_3.QueryClientImpl(rpcClient);
+        this.coin = new query_4.QueryClientImpl(rpcClient);
+        this.fee = new query_25.QueryClientImpl(rpcClient);
+        this.insurance = new query_32.QueryClientImpl(rpcClient);
+        this.leverage = new query_33.QueryClientImpl(rpcClient);
+        this.liquidation = new query_34.QueryClientImpl(rpcClient);
+        this.market = new query_35.QueryClientImpl(rpcClient);
+        this.marketstats = new query_36.QueryClientImpl(rpcClient);
+        this.misc = new query_37.QueryClientImpl(rpcClient);
+        this.oracle = new query_38.QueryClientImpl(rpcClient);
+        this.order = new query_39.QueryClientImpl(rpcClient);
+        this.position = new query_40.QueryClientImpl(rpcClient);
+        this.pricing = new query_41.QueryClientImpl(rpcClient);
+        this.subaccount = new query_42.QueryClientImpl(rpcClient);
+        this.evmmerge = new query_22.QueryClientImpl(rpcClient);
+        this.evmbank = new query_23.QueryClientImpl(rpcClient);
+        this.perpspool = new query_44.QueryClientImpl(rpcClient);
+        this.auth = new query_5.QueryClientImpl(rpcClient);
+        this.bank = new query_6.QueryClientImpl(rpcClient);
+        this.nativeBank = new query_7.QueryClientImpl(rpcClient);
+        this.distribution = new query_10.QueryClientImpl(rpcClient);
+        this.evidence = new query_11.QueryClientImpl(rpcClient);
+        this.grant = new query_20.QueryClientImpl(rpcClient);
+        this.feegrant = new query_21.QueryClientImpl(rpcClient);
+        this.group = new query_13.QueryClientImpl(rpcClient);
+        this.gov = new query_12.QueryClientImpl(rpcClient);
+        this.mint = new query_14.QueryClientImpl(rpcClient);
+        this.params = new query_15.QueryClientImpl(rpcClient);
+        this.slashing = new query_16.QueryClientImpl(rpcClient);
+        this.staking = new query_17.QueryClientImpl(rpcClient);
+        this.upgrade = new query_18.QueryClientImpl(rpcClient);
+        this.cosmosTm = new query_9.ServiceClientImpl(rpcClient);
+        this.alliance = new query_43.QueryClientImpl(rpcClient);
+        this.admin = new query_45.QueryClientImpl(rpcClient);
+        this.ibc = {
+            controller: new query_26.QueryClientImpl(rpcClient),
+            host: new query_27.QueryClientImpl(rpcClient),
+            transfer: new query_28.QueryClientImpl(rpcClient),
+            client: new query_29.QueryClientImpl(rpcClient),
+            connection: new query_30.QueryClientImpl(rpcClient),
+            channel: new query_31.QueryClientImpl(rpcClient),
+        };
+        this.ethermint = {
+            evm: new query_19.QueryClientImpl(rpcClient),
+            feeMarket: new query_24.QueryClientImpl(rpcClient),
+        };
+    }
+}
+exports.default = CarbonQueryClient;

package/lib/clients/ETHClient.d.ts

@@ -0,0 +1,101 @@
+import CarbonSDK, { Carbon } from "../CarbonSDK";
+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: Carbon.Coin.Token;
+    toToken: Carbon.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: Carbon.Coin.Token;
+    signCompleteCallback?: () => void;
+}
+export interface ApproveERC20Params extends ETHTxParams {
+    token: Carbon.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): CarbonSDK.ETHClient;
+    getExternalBalances(api: CarbonSDK, address: string, whitelistDenoms?: string[], version?: string): Promise<TokensWithExternalBalance[]>;
+    approveERC20(params: ApproveERC20Params): Promise<EthersTransactionResponse>;
+    checkAllowanceERC20(token: Carbon.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: Carbon.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: Carbon.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/lib/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 === 'Carbon') {
+            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 carbonNetwork = 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, carbonNetwork));
+        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, carbonNetwork);
+        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;