carbon-js-sdk 0.3.4 → 0.3.6

package/lib/clients/CarbonQueryClient.js

@@ -44,7 +44,7 @@ class CarbonQueryClient {
     constructor(tmClient) {
         this.tmClient = tmClient;
         this.baseClient = new stargate_1.QueryClient(this.tmClient);
-        const rpcClient = stargate_1.createProtobufRpcClient(this.baseClient);
+        const rpcClient = (0, stargate_1.createProtobufRpcClient)(this.baseClient);
         this.chain = BlockchainClient_1.default.connectWithTm(this.tmClient);
         this.adl = new query_1.QueryClientImpl(rpcClient);
         this.book = new query_2.QueryClientImpl(rpcClient);
@@ -85,7 +85,7 @@ class CarbonQueryClient {
         };
     }
     getProtobufRpcClient() {
-        return stargate_1.createProtobufRpcClient(this.baseClient);
+        return (0, stargate_1.createProtobufRpcClient)(this.baseClient);
     }
 }
 exports.default = CarbonQueryClient;

package/lib/clients/CarbonTendermintClient.d.ts

@@ -0,0 +1,117 @@
+import { Stream } from "xstream";
+import { JsonRpcSuccessResponse } from "@cosmjs/json-rpc/build/types";
+import * as requests from "@cosmjs/tendermint-rpc/build/tendermint34/requests";
+import * as responses from "@cosmjs/tendermint-rpc/build/tendermint34/responses";
+export interface SubscriptionEvent {
+    readonly query: string;
+    readonly data: {
+        readonly type: string;
+        readonly value: any;
+    };
+}
+export declare type JsonRpcId = number | string;
+export interface JsonRpcRequest {
+    readonly jsonrpc: "2.0";
+    readonly id: JsonRpcId;
+    readonly method: string;
+    readonly params: JsonCompatibleArray | JsonCompatibleDictionary;
+}
+export interface JsonCompatibleArray extends ReadonlyArray<JsonCompatibleValue> {
+}
+export interface JsonCompatibleDictionary {
+    readonly [key: string]: JsonCompatibleValue | readonly JsonCompatibleValue[];
+}
+export declare type JsonCompatibleValue = JsonCompatibleDictionary | JsonCompatibleArray | string | number | boolean | null;
+export interface RpcClient {
+    readonly execute: (request: JsonRpcRequest) => Promise<JsonRpcSuccessResponse>;
+    readonly disconnect: () => void;
+}
+export declare function instanceOfRpcStreamingClient(client: RpcClient): client is RpcStreamingClient;
+export interface RpcStreamingClient extends RpcClient {
+    readonly listen: (request: JsonRpcRequest) => Stream<SubscriptionEvent>;
+}
+export default class CarbonTendermintClient {
+    /**
+     * Creates a new Tendermint client for the given endpoint.
+     *
+     * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+     */
+    static connect(endpoint: string): Promise<CarbonTendermintClient>;
+    /**
+     * Creates a new Tendermint client given an RPC client.
+     */
+    static create(rpcClient: RpcClient): Promise<CarbonTendermintClient>;
+    private static detectVersion;
+    private readonly client;
+    private readonly p;
+    private readonly r;
+    /**
+     * Use `CarbonTendermintClient.connect` or `CarbonTendermintClient.create` to create an instance.
+     */
+    private constructor();
+    disconnect(): void;
+    abciInfo(): Promise<responses.AbciInfoResponse>;
+    abciQuery(params: requests.AbciQueryParams): Promise<responses.AbciQueryResponse>;
+    block(height?: number): Promise<responses.BlockResponse>;
+    blockResults(height?: number): Promise<responses.BlockResultsResponse>;
+    /**
+     * Search for events that are in a block.
+     *
+     * NOTE
+     * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+     */
+    blockSearch(params: requests.BlockSearchParams): Promise<responses.BlockSearchResponse>;
+    blockSearchAll(params: requests.BlockSearchParams): Promise<responses.BlockSearchResponse>;
+    /**
+     * Queries block headers filtered by minHeight <= height <= maxHeight.
+     *
+     * @param minHeight The minimum height to be included in the result. Defaults to 0.
+     * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+     */
+    blockchain(minHeight?: number, maxHeight?: number): Promise<responses.BlockchainResponse>;
+    /**
+     * Broadcast transaction to mempool and wait for response
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+     */
+    broadcastTxSync(params: requests.BroadcastTxParams): Promise<responses.BroadcastTxSyncResponse>;
+    /**
+     * Broadcast transaction to mempool and do not wait for result
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+     */
+    broadcastTxAsync(params: requests.BroadcastTxParams): Promise<responses.BroadcastTxAsyncResponse>;
+    /**
+     * Broadcast transaction to mempool and wait for block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+     */
+    broadcastTxCommit(params: requests.BroadcastTxParams): Promise<responses.BroadcastTxCommitResponse>;
+    commit(height?: number): Promise<responses.CommitResponse>;
+    genesis(): Promise<responses.GenesisResponse>;
+    health(): Promise<responses.HealthResponse>;
+    numUnconfirmedTxs(): Promise<responses.NumUnconfirmedTxsResponse>;
+    status(): Promise<responses.StatusResponse>;
+    subscribeNewBlock(): Stream<responses.NewBlockEvent>;
+    subscribeNewBlockHeader(): Stream<responses.NewBlockHeaderEvent>;
+    subscribeTx(query?: string): Stream<responses.TxEvent>;
+    /**
+     * Get a single transaction by hash
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+     */
+    tx(params: requests.TxParams): Promise<responses.TxResponse>;
+    /**
+     * Search for transactions that are in a block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+     */
+    txSearch(params: requests.TxSearchParams): Promise<responses.TxSearchResponse>;
+    txSearchAll(params: requests.TxSearchParams): Promise<responses.TxSearchResponse>;
+    validators(params: requests.ValidatorsParams): Promise<responses.ValidatorsResponse>;
+    validatorsAll(height?: number): Promise<responses.ValidatorsResponse>;
+    private doCall;
+    private subscribe;
+}

package/lib/clients/CarbonTendermintClient.js

@@ -0,0 +1,376 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfRpcStreamingClient = void 0;
+const jsonrpc_1 = require("@cosmjs/tendermint-rpc/build/jsonrpc");
+const httpclient_1 = require("@cosmjs/tendermint-rpc/build/rpcclients/httpclient");
+const adaptor_1 = require("@cosmjs/tendermint-rpc/build/tendermint34/adaptor");
+const requests = __importStar(require("@cosmjs/tendermint-rpc/build/tendermint34/requests"));
+function instanceOfRpcStreamingClient(client) {
+    return typeof client.listen === "function";
+}
+exports.instanceOfRpcStreamingClient = instanceOfRpcStreamingClient;
+class CarbonTendermintClient {
+    /**
+     * Use `CarbonTendermintClient.connect` or `CarbonTendermintClient.create` to create an instance.
+     */
+    constructor(client) {
+        this.client = client;
+        this.p = adaptor_1.adaptor34.params;
+        this.r = adaptor_1.adaptor34.responses;
+    }
+    /**
+     * Creates a new Tendermint client for the given endpoint.
+     *
+     * Uses HTTP when the URL schema is http or https. Uses WebSockets otherwise.
+     */
+    static connect(endpoint) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const useHttp = endpoint.startsWith("http://") || endpoint.startsWith("https://");
+            if (!useHttp) {
+                throw new Error('this client only uses httpClient.');
+            }
+            const rpcClient = new httpclient_1.HttpClient(endpoint);
+            return CarbonTendermintClient.create(rpcClient);
+        });
+    }
+    /**
+     * Creates a new Tendermint client given an RPC client.
+     */
+    static create(rpcClient) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // For some very strange reason I don't understand, tests start to fail on some systems
+            // (our CI) when skipping the status call before doing other queries. Sleeping a little
+            // while did not help. Thus we query the version as a way to say "hi" to the backend,
+            // even in cases where we don't use the result.
+            const _version = yield this.detectVersion(rpcClient);
+            return new CarbonTendermintClient(rpcClient);
+        });
+    }
+    static detectVersion(client) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = (0, jsonrpc_1.createJsonRpcRequest)(requests.Method.Status);
+            const response = yield client.execute(req);
+            const result = response.result;
+            if (!result || !result.node_info) {
+                throw new Error("Unrecognized format for status response");
+            }
+            const version = result.node_info.version;
+            if (typeof version !== "string") {
+                throw new Error("Unrecognized version format: must be string");
+            }
+            return version;
+        });
+    }
+    disconnect() {
+        this.client.disconnect();
+    }
+    abciInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.AbciInfo };
+            return this.doCall(query, this.p.encodeAbciInfo, this.r.decodeAbciInfo);
+        });
+    }
+    abciQuery(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.AbciQuery };
+            return this.doCall(query, this.p.encodeAbciQuery, this.r.decodeAbciQuery);
+        });
+    }
+    block(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Block, params: { height: height } };
+            return this.doCall(query, this.p.encodeBlock, this.r.decodeBlock);
+        });
+    }
+    blockResults(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.BlockResults,
+                params: { height: height },
+            };
+            return this.doCall(query, this.p.encodeBlockResults, this.r.decodeBlockResults);
+        });
+    }
+    /**
+     * Search for events that are in a block.
+     *
+     * NOTE
+     * This method will error on any node that is running a Tendermint version lower than 0.34.9.
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/block_search
+     */
+    blockSearch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BlockSearch };
+            const resp = yield this.doCall(query, this.p.encodeBlockSearch, this.r.decodeBlockSearch);
+            return Object.assign(Object.assign({}, resp), { 
+                // make sure we sort by height, as tendermint may be sorting by string value of the height
+                blocks: [...resp.blocks].sort((a, b) => a.block.header.height - b.block.header.height) });
+        });
+    }
+    // this should paginate through all blockSearch options to ensure it returns all results.
+    // starts with page 1 or whatever was provided (eg. to start on page 7)
+    //
+    // NOTE
+    // This method will error on any node that is running a Tendermint version lower than 0.34.9.
+    blockSearchAll(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let page = params.page || 1;
+            const blocks = [];
+            let done = false;
+            while (!done) {
+                const resp = yield this.blockSearch(Object.assign(Object.assign({}, params), { page: page }));
+                blocks.push(...resp.blocks);
+                if (blocks.length < resp.totalCount) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            // make sure we sort by height, as tendermint may be sorting by string value of the height
+            // and the earlier items may be in a higher page than the later items
+            blocks.sort((a, b) => a.block.header.height - b.block.header.height);
+            return {
+                totalCount: blocks.length,
+                blocks: blocks,
+            };
+        });
+    }
+    /**
+     * Queries block headers filtered by minHeight <= height <= maxHeight.
+     *
+     * @param minHeight The minimum height to be included in the result. Defaults to 0.
+     * @param maxHeight The maximum height to be included in the result. Defaults to infinity.
+     */
+    blockchain(minHeight, maxHeight) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.Blockchain,
+                params: {
+                    minHeight: minHeight,
+                    maxHeight: maxHeight,
+                },
+            };
+            return this.doCall(query, this.p.encodeBlockchain, this.r.decodeBlockchain);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and wait for response
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_sync
+     */
+    broadcastTxSync(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxSync };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxSync);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and do not wait for result
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_async
+     */
+    broadcastTxAsync(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxAsync };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxAsync);
+        });
+    }
+    /**
+     * Broadcast transaction to mempool and wait for block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Tx/broadcast_tx_commit
+     */
+    broadcastTxCommit(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.BroadcastTxCommit };
+            return this.doCall(query, this.p.encodeBroadcastTx, this.r.decodeBroadcastTxCommit);
+        });
+    }
+    commit(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Commit, params: { height: height } };
+            return this.doCall(query, this.p.encodeCommit, this.r.decodeCommit);
+        });
+    }
+    genesis() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Genesis };
+            return this.doCall(query, this.p.encodeGenesis, this.r.decodeGenesis);
+        });
+    }
+    health() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Health };
+            return this.doCall(query, this.p.encodeHealth, this.r.decodeHealth);
+        });
+    }
+    numUnconfirmedTxs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.NumUnconfirmedTxs };
+            return this.doCall(query, this.p.encodeNumUnconfirmedTxs, this.r.decodeNumUnconfirmedTxs);
+        });
+    }
+    status() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { method: requests.Method.Status };
+            return this.doCall(query, this.p.encodeStatus, this.r.decodeStatus);
+        });
+    }
+    subscribeNewBlock() {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: { type: requests.SubscriptionEventType.NewBlock },
+        };
+        return this.subscribe(request, this.r.decodeNewBlockEvent);
+    }
+    subscribeNewBlockHeader() {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: { type: requests.SubscriptionEventType.NewBlockHeader },
+        };
+        return this.subscribe(request, this.r.decodeNewBlockHeaderEvent);
+    }
+    subscribeTx(query) {
+        const request = {
+            method: requests.Method.Subscribe,
+            query: {
+                type: requests.SubscriptionEventType.Tx,
+                raw: query,
+            },
+        };
+        return this.subscribe(request, this.r.decodeTxEvent);
+    }
+    /**
+     * Get a single transaction by hash
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx
+     */
+    tx(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.Tx };
+            return this.doCall(query, this.p.encodeTx, this.r.decodeTx);
+        });
+    }
+    /**
+     * Search for transactions that are in a block
+     *
+     * @see https://docs.tendermint.com/master/rpc/#/Info/tx_search
+     */
+    txSearch(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = { params: params, method: requests.Method.TxSearch };
+            return this.doCall(query, this.p.encodeTxSearch, this.r.decodeTxSearch);
+        });
+    }
+    // this should paginate through all txSearch options to ensure it returns all results.
+    // starts with page 1 or whatever was provided (eg. to start on page 7)
+    txSearchAll(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let page = params.page || 1;
+            const txs = [];
+            let done = false;
+            while (!done) {
+                const resp = yield this.txSearch(Object.assign(Object.assign({}, params), { page: page }));
+                txs.push(...resp.txs);
+                if (txs.length < resp.totalCount) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            return {
+                totalCount: txs.length,
+                txs: txs,
+            };
+        });
+    }
+    validators(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = {
+                method: requests.Method.Validators,
+                params: params,
+            };
+            return this.doCall(query, this.p.encodeValidators, this.r.decodeValidators);
+        });
+    }
+    validatorsAll(height) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validators = [];
+            let page = 1;
+            let done = false;
+            let blockHeight = height;
+            while (!done) {
+                const response = yield this.validators({
+                    per_page: 50,
+                    height: blockHeight,
+                    page: page,
+                });
+                validators.push(...response.validators);
+                blockHeight = blockHeight || response.blockHeight;
+                if (validators.length < response.total) {
+                    page++;
+                }
+                else {
+                    done = true;
+                }
+            }
+            return {
+                // NOTE: Default value is for type safety but this should always be set
+                blockHeight: blockHeight !== null && blockHeight !== void 0 ? blockHeight : 0,
+                count: validators.length,
+                total: validators.length,
+                validators: validators,
+            };
+        });
+    }
+    // doCall is a helper to handle the encode/call/decode logic
+    doCall(request, encode, decode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const req = encode(request);
+            const result = yield this.client.execute(req);
+            return decode(result);
+        });
+    }
+    subscribe(request, decode) {
+        if (!instanceOfRpcStreamingClient(this.client)) {
+            throw new Error("This RPC client type cannot subscribe to events");
+        }
+        const req = this.p.encodeSubscribe(request);
+        const eventStream = this.client.listen(req);
+        return eventStream.map((event) => {
+            return decode(event);
+        });
+    }
+}
+exports.default = CarbonTendermintClient;

package/lib/clients/ETHClient.js

@@ -40,13 +40,13 @@ class ETHClient {
         return __awaiter(this, void 0, void 0, function* () {
             const tokenQueryResults = yield api.token.getAllTokens();
             const lockProxyAddress = this.getLockProxyAddress().toLowerCase();
-            const tokens = tokenQueryResults.filter((token) => blockchain_1.blockchainForChainId(token.chainId.toNumber()) == this.blockchain &&
+            const tokens = tokenQueryResults.filter((token) => (0, blockchain_1.blockchainForChainId)(token.chainId.toNumber()) == this.blockchain &&
                 token.tokenAddress.length == 40 &&
-                token.bridgeAddress.toLowerCase() == generic_1.stripHexPrefix(lockProxyAddress) &&
+                token.bridgeAddress.toLowerCase() == (0, generic_1.stripHexPrefix)(lockProxyAddress) &&
                 (!whitelistDenoms || whitelistDenoms.includes(token.denom)) &&
-                this.verifyChecksum(generic_1.appendHexPrefix(token.tokenAddress)));
+                this.verifyChecksum((0, generic_1.appendHexPrefix)(token.tokenAddress)));
             const assetIds = tokens.map((token) => {
-                return this.verifyChecksum(generic_1.appendHexPrefix(token.tokenAddress));
+                return this.verifyChecksum((0, generic_1.appendHexPrefix)(token.tokenAddress));
             });
             const provider = this.getProvider();
             const contractAddress = this.getBalanceReaderAddress();
@@ -95,14 +95,14 @@ class ETHClient {
                 throw new Error("Invalid recovery address");
             }
             const fromTokenId = fromToken.id;
-            const fromTokenAddress = generic_1.appendHexPrefix(fromToken.tokenAddress);
+            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, CarbonSDK_1.default.Network.MainNet));
             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 = yield rpcProvider.getTransactionCount(fromAddress);
             const contract = new ethers_1.ethers.Contract(this.getBridgeEntranceAddr(), eth_1.ABIs.bridgeEntrance, rpcProvider);
-            const feeAddress = generic_1.appendHexPrefix(networkConfig.feeAddress);
+            const feeAddress = (0, generic_1.appendHexPrefix)(networkConfig.feeAddress);
             const tokenCreator = fromToken.creator;
             const targetAddressBytes = util_1.AddressUtils.SWTHAddress.getAddressBytes(tokenCreator, CarbonSDK_1.default.Network.MainNet);
             const targetProxyHash = ethers_1.ethers.utils.hexlify(targetAddressBytes);
@@ -137,9 +137,9 @@ class ETHClient {
                 throw new Error("Minimum gas required: 150,000");
             }
             const networkConfig = this.getNetworkConfig();
-            const assetId = generic_1.appendHexPrefix(token.tokenAddress);
-            const targetProxyHash = generic_1.appendHexPrefix(this.getTargetProxyHash(token));
-            const feeAddress = generic_1.appendHexPrefix(networkConfig.feeAddress);
+            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();
@@ -190,16 +190,16 @@ class ETHClient {
                 return "insufficient balance";
             }
             const networkConfig = this.getNetworkConfig();
-            const assetId = generic_1.appendHexPrefix(tokenWithExternalBalances.tokenAddress);
-            const targetProxyHash = generic_1.appendHexPrefix(this.getTargetProxyHash(tokenWithExternalBalances));
-            const feeAddress = generic_1.appendHexPrefix(networkConfig.feeAddress);
+            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)
             let signatureResult;
             const { address, signature } = yield getSignatureCallback(message);
-            const signatureBytes = ethers_1.ethers.utils.arrayify(generic_1.appendHexPrefix(signature));
+            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)
             signatureResult = {
@@ -238,7 +238,7 @@ class ETHClient {
             if (!feeInfo.deposit_fee) {
                 throw new Error("unsupported token");
             }
-            if (blockchain_1.blockchainForChainId(token.chainId.toNumber()) !== this.blockchain) {
+            if ((0, blockchain_1.blockchainForChainId)(token.chainId.toNumber()) !== this.blockchain) {
                 throw new Error("unsupported token");
             }
             let feeAmount = ethers_1.ethers.BigNumber.from(feeInfo.deposit_fee);
@@ -304,7 +304,7 @@ class ETHClient {
     getTargetProxyHash(token) {
         const networkConfig = this.getNetworkConfig();
         const addressBytes = address_1.SWTHAddress.getAddressBytes(token.creator, networkConfig.network);
-        const addressHex = generic_1.stripHexPrefix(ethers_1.ethers.utils.hexlify(addressBytes));
+        const addressHex = (0, generic_1.stripHexPrefix)(ethers_1.ethers.utils.hexlify(addressBytes));
         return addressHex;
     }
     getProvider() {

package/lib/clients/HydrogenClient.js

@@ -29,7 +29,7 @@ exports.HydrogenEndpoints = {
 const formatDateField = (value) => {
     if (typeof value !== "string")
         return null;
-    return dayjs_1.default(value);
+    return (0, dayjs_1.default)(value);
 };
 const formatCrossChainTransfer = (value) => {
     var _a, _b;

package/lib/clients/N3Client.js

@@ -97,7 +97,7 @@ class N3Client {
                 neon_core_next_1.sc.ContractParam.byteArray(neon_core_next_1.u.HexString.fromHex(toAddressHex, true)),
                 neon_core_next_1.sc.ContractParam.integer(amount.toString(10)),
                 neon_core_next_1.sc.ContractParam.integer(feeAmount.toString(10)),
-                neon_core_next_1.sc.ContractParam.byteArray(neon_core_next_1.u.HexString.fromHex(networkConfig.feeAddress, true)),
+                neon_core_next_1.sc.ContractParam.byteArray(neon_core_next_1.u.HexString.fromHex(feeAmount.isZero() ? "" : networkConfig.feeAddress, true)),
                 neon_core_next_1.sc.ContractParam.integer(nonce),
             ];
             const script = neon_core_next_1.sc.createScript({
@@ -160,13 +160,14 @@ class N3Client {
             const fromAddressHex = o3Wallet.address;
             const publicKeyOutput = yield o3Wallet.getPublicKeyOutput();
             const accountScriptHash = address_1.N3Address.publicKeyToScriptHash(publicKeyOutput.publicKey);
+            const feeAddress = feeAmount.isZero() ? "" : neon_core_next_1.u.HexString.fromHex(networkConfig.feeAddress).toBase64();
             const args = [
                 { type: o3_1.O3Types.ArgTypes.Hash160, value: tokenScriptHash },
                 { type: o3_1.O3Types.ArgTypes.Hash160, value: fromAddressHex },
                 { type: o3_1.O3Types.ArgTypes.ByteArray, value: neon_core_next_1.u.HexString.fromHex(toAddressHex).toBase64() },
                 { type: o3_1.O3Types.ArgTypes.Integer, value: amount.toString(10) },
                 { type: o3_1.O3Types.ArgTypes.Integer, value: feeAmount.toString(10) },
-                { type: o3_1.O3Types.ArgTypes.ByteArray, value: neon_core_next_1.u.HexString.fromHex(networkConfig.feeAddress).toBase64() },
+                { type: o3_1.O3Types.ArgTypes.ByteArray, value: feeAddress },
                 { type: o3_1.O3Types.ArgTypes.Integer, value: nonce.toString() },
             ];
             const result = yield o3Wallet.getDAPI().invoke({