dequanto 0.0.1 → 0.0.7

package/dist/src/txs/TxWriter.js

@@ -4,30 +4,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxWriter = void 0;
+require("../env/BigIntSerializer");
 const a_di_1 = __importDefault(require("a-di"));
 const atma_utils_1 = require("atma-utils");
+const _bigint_1 = require("@dequanto/utils/$bigint");
+const _txData_1 = require("@dequanto/utils/$txData");
+const _sign_1 = require("@dequanto/utils/$sign");
+const _logger_1 = require("@dequanto/utils/$logger");
+const _promise_1 = require("@dequanto/utils/$promise");
+const _account_1 = require("@dequanto/utils/$account");
+const _gas_1 = require("@dequanto/utils/$gas");
 const TxDataBuilder_1 = require("./TxDataBuilder");
 const TxLogger_1 = require("./TxLogger");
-require("../env/BigIntSerializer");
-const _bigint_1 = require("@dequanto/utils/$bigint");
 const ChainAccountsService_1 = require("@dequanto/ChainAccountsService");
 const Web3ClientFactory_1 = require("@dequanto/clients/Web3ClientFactory");
-const _promise_1 = require("@dequanto/utils/$promise");
 const ClientErrorUtil_1 = require("@dequanto/clients/utils/ClientErrorUtil");
-const _logger_1 = require("@dequanto/utils/$logger");
 const TxLogParser_1 = require("./receipt/TxLogParser");
+const GnosisSafeHandler_1 = require("@dequanto/safe/GnosisSafeHandler");
+const SigFileTransport_1 = require("./sig-transports/SigFileTransport");
+const _require_1 = require("@dequanto/utils/$require");
 class TxWriter extends atma_utils_1.class_EventEmitter {
     constructor(client, builder, account) {
         super();
         this.client = client;
         this.builder = builder;
         this.account = account;
+        this.isSafe = _account_1.$account.isSafe(this.account);
         this.onSent = new atma_utils_1.class_Dfr();
         this.onCompleted = new atma_utils_1.class_Dfr();
+        this.onSaved = new atma_utils_1.class_Dfr();
         this.id = Math.round(Math.random() * 10 ** 10) + '';
         this.tx = null;
         this.txs = [];
-        this.logger = new TxLogger_1.TxLogger(this.id, this.account.name ?? this.account.key, this.builder);
+        this.logger = new TxLogger_1.TxLogger(this.id, this.getSenderName(), this.builder);
         this.confirmationAwaiters = [];
     }
     onConfirmed(waitForCount) {
@@ -43,6 +52,9 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
         }
         return promise;
     }
+    wait() {
+        return this.onCompleted;
+    }
     send(options) {
         if (this.tx == null) {
             this.logger.logStart();
@@ -59,9 +71,51 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
             this.send(options);
         }
     }
-    sendTxInner() {
+    async sendTxInner() {
+        if (this.options?.txOutput != null) {
+            // handle none blockchain
+            await this.saveTxAndExit();
+            return;
+        }
+        if (this.isSafe) {
+            let safeAccount = this.account;
+            let sender = await this.getSender();
+            let safe = new GnosisSafeHandler_1.GnosisSafeHandler({
+                safeAddress: safeAccount.address ?? safeAccount.safeAddress,
+                owner: sender,
+                client: this.client,
+                transport: this.options?.safeTransport
+            });
+            let innerWriter = await safe.execute(this);
+            this.pipeInnerWriter(innerWriter);
+            return;
+        }
         let time = Date.now();
-        let signedTxBuffer = this.builder.signToString(this.account.key);
+        let sender = await this.getSender();
+        if (this.builder.data.nonce == null) {
+            await this.builder.setNonce();
+        }
+        let key = sender?.key;
+        let signedTxBuffer = key == null
+            ? null
+            : await this.builder.signToString(sender.key);
+        if (signedTxBuffer == null) {
+            if (this.options?.sigTransport != null) {
+                let transport = a_di_1.default.resolve(SigFileTransport_1.SigFileTransport);
+                let shouldWait = this.options?.sigTransportWait !== false;
+                let { signed, path } = await transport.create(this.options.sigTransport, this.builder, { wait: shouldWait });
+                if (path) {
+                    this.onSaved.resolve(path);
+                }
+                if (shouldWait === false) {
+                    return;
+                }
+            }
+            if (this.options?.signature) {
+                let tx = _txData_1.$txData.getJson(this.builder.data, this.client);
+                signedTxBuffer = await _sign_1.$sign.serializeTx(tx, this.options.signature);
+            }
+        }
         let tx = {
             timestamp: Date.now(),
             confirmations: 0,
@@ -72,10 +126,22 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
         tx.timeout = this.startTimer(tx);
         this.tx = tx;
         this.txs.push(tx);
-        let promiEvent = this
-            .client
-            .sendSignedTransaction(signedTxBuffer)
+        let promiEvent;
+        if (signedTxBuffer != null) {
+            promiEvent = this
+                .client
+                .sendSignedTransaction(signedTxBuffer);
+        }
+        else {
+            promiEvent = this
+                .client
+                .sendTransaction(this.builder.getTxData(this.client));
+        }
+        promiEvent
             .once('transactionHash', hash => {
+            if (tx.hash === hash) {
+                return;
+            }
             if (tx.hash && tx.timeout) {
                 // network has reaccepted the tx, restart previous timeout
                 this.clearTimer(tx);
@@ -84,17 +150,7 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
             tx.hash = hash;
             this.onSent.resolve(hash);
             this.emit('transactionHash', hash);
-            this.emit('log', `Tx hash received: ${hash}`);
-        })
-            .once('receipt', receipt => {
-            tx.receipt = receipt;
-            tx.hash = receipt.transactionHash ?? tx.hash;
-            this.receipt = receipt;
-            this.clearTimer(tx);
-            this.logger.logReceipt(receipt, Date.now() - time);
-            this.onSent.resolve();
-            this.emit('receipt', receipt);
-            this.emit('log', `Tx receipt received for ${receipt.transactionHash}. Status: ${receipt.status}`);
+            this.emit('log', `Tx hash: ${hash}`);
         })
             // .on('confirmation', (confNumber, receipt) => {
             //     tx.hash = receipt.transactionHash ?? tx.hash;
@@ -111,6 +167,8 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
             //     }
             // })
             .on('error', error => {
+            this.onSent.reject(error);
+            this.onCompleted.reject(error);
             this.clearTimer(tx);
             this.logger.logError(error);
             this.emit('error', error);
@@ -121,9 +179,28 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
             try {
                 await this.extractLogs(receipt, tx);
             }
-            catch (error) { }
-            this.onCompleted.resolve(receipt);
+            catch (error) {
+                console.error('Logs error', error);
+            }
+            try {
+                tx.receipt = receipt;
+                tx.hash = receipt.transactionHash ?? tx.hash;
+                this.receipt = receipt;
+                this.logger.logReceipt(receipt, Date.now() - time);
+                this.onSent.resolve();
+                this.emit('receipt', receipt);
+                let hash = tx.hash;
+                let status = receipt.status;
+                let gasFormatted = _gas_1.$gas.formatUsed(this.builder.data, receipt);
+                this.emit('log', `Tx receipt: ${hash}.\n\tStatus: ${status}.\n\tGas used: ${gasFormatted}`);
+                this.onCompleted.resolve(receipt);
+            }
+            catch (error) {
+                console.error('FATAL ERROR', error);
+                throw error;
+            }
         }, async (err) => {
+            this.logger.log(`Tx errored ${err.message}`);
             this.clearTimer(tx);
             tx.error = err;
             const options = this.options ?? {};
@@ -131,12 +208,12 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
                 // read reason
                 // let client = await this.client.getWeb3();
                 // let tx = await this.client.getTransaction(err.receipt.transactionHash);
-                // console.log('RECEIPT', err.receipt, tx);
+                // $logger.log('RECEIPT', err.receipt, tx);
                 // try {
                 //     let result = await client.eth.call(tx, tx.blockNumber);
-                //     console.log('RESULT', result);
+                //     $logger.log('RESULT', result);
                 // } catch (err) {
-                //     console.log('CALL ERROR', err);
+                //     $logger.log('CALL ERROR', err);
                 // }
                 // throw new Error('asd');
             }
@@ -182,21 +259,41 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
             this.onCompleted.reject(err);
         });
     }
+    async getSender() {
+        let account = this.account;
+        let sender = _account_1.$account.getSender(account);
+        if (sender.key == null) {
+            /** check the encrypted storage. In case no key is found, assume the target node contains unlocked or locked account */
+            let addressOrName = sender.address ?? sender.name;
+            let service = a_di_1.default.resolve(ChainAccountsService_1.ChainAccountsService);
+            let fromStorage = await service.get(addressOrName, this.client.platform);
+            if (fromStorage) {
+                sender = fromStorage;
+            }
+        }
+        return sender;
+    }
+    getSenderName() {
+        let sender = _account_1.$account.getSender(this.account);
+        return sender.name ?? sender.address;
+    }
     async extractLogs(receipt, tx) {
         let parser = a_di_1.default.resolve(TxLogParser_1.TxLogParser);
         let logs = await parser.parse(receipt);
         tx.knownLogs = logs.filter(x => x != null);
     }
     async fundAccountAndResend() {
-        let account = this.builder.config.gasFunding;
+        let gasFunding = this.builder.config.gasFunding;
+        let sender = _account_1.$account.getSender(this.account);
         await this.builder.setGas({
             gasEstimation: true,
-            from: this.account.address
+            from: sender.address
         });
-        let { gasPrice, gasLimit } = this.builder.data;
+        let { gasLimit } = this.builder.data;
+        let gasPrice = TxDataBuilder_1.TxDataBuilder.getGasPrice(this.builder);
         let LITTLE_BIT_MORE = 1.3;
-        let wei = _bigint_1.$bigint.multWithFloat(BigInt(gasPrice) * BigInt(gasLimit), LITTLE_BIT_MORE);
-        let fundTx = await this.transferNative(account, this.account.address, wei);
+        let wei = _bigint_1.$bigint.multWithFloat(gasPrice * BigInt(gasLimit), LITTLE_BIT_MORE);
+        let fundTx = await this.transferNative(gasFunding, sender.address, wei);
         await fundTx.onCompleted;
         // account was funded resubmit the tx
         this.resubmit();
@@ -236,7 +333,13 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
         }
         this.sendTxInner();
     }
-    /** Use this transfer in case of additional account funding */
+    pipeInnerWriter(innerWriter) {
+        innerWriter.onCompleted.then((receipt) => this.onCompleted.resolve(receipt), (error) => this.onCompleted.reject(error));
+        innerWriter.onSent.then((hash) => this.onSent.resolve(hash), (error) => this.onSent.reject(error));
+        innerWriter.on('error', error => this.emit('error', error));
+        innerWriter.on('log', message => this.emit('log', message));
+    }
+    /** Use this transfer also in case of additional account funding */
     async transferNative(from, to, amount) {
         let txBuilder = new TxDataBuilder_1.TxDataBuilder(this.client, from, {
             to: to,
@@ -250,22 +353,41 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
         return TxWriter.write(this.client, txBuilder, from);
     }
     toJSON() {
+        let account = this.account;
+        if (typeof account !== 'string') {
+            account = JSON.parse(JSON.stringify(account));
+            // Clean any KEY to prevent leaking. When resubmitted if one is required should be taken from the storage
+            if (_account_1.$account.isSafe(account)) {
+                delete account.operator?.key;
+            }
+            else {
+                delete account.key;
+            }
+        }
         return {
             id: this.id,
             platform: this.client.platform,
             options: this.options,
-            account: this.account.address,
+            account: account,
             txs: this.txs,
             builder: this.builder.toJSON(),
         };
     }
-    static async fromJSON(json, client) {
+    //** We can save the Tx Data for later reuse/blockchain send */
+    async saveTxAndExit(additionalProperties) {
+        let path = this.options?.txOutput;
+        _require_1.$require.notNull(path, 'Save tx data to the file, but the path is undefined');
+        await this.builder.save(path, additionalProperties);
+        this.onSent.resolve(path);
+        this.onSaved.resolve(path);
+        this.onCompleted.reject(new Error(`Transaction is not submited to the blockchain. It has been saved to "${path}". Subscribe to the "onSaved" promise instead`));
+    }
+    static async fromJSON(json, client, account) {
         client = client ?? Web3ClientFactory_1.Web3ClientFactory.get(json.platform);
-        let service = a_di_1.default.resolve(ChainAccountsService_1.ChainAccountsService);
-        let account = await service.get(json.account, json.platform);
+        account = account ?? json.account;
         let builder = TxDataBuilder_1.TxDataBuilder.fromJSON(client, account, {
             config: json.builder.config,
-            data: json.builder.data,
+            tx: json.builder.tx,
         });
         let writer = TxWriter.create(client, builder, account, json.options);
         let txs = json.txs;
@@ -283,5 +405,15 @@ class TxWriter extends atma_utils_1.class_EventEmitter {
     static create(client, builder, account, options) {
         return new TxWriter(client, builder, account);
     }
+    static async writeTxData(client, data, account, options) {
+        let txBuilder = new TxDataBuilder_1.TxDataBuilder(client, account, data);
+        await Promise.all([
+            txBuilder.setGas(),
+            txBuilder.setNonce(),
+        ]);
+        let w = new TxWriter(client, txBuilder, account);
+        w.send(options);
+        return w;
+    }
 }
 exports.TxWriter = TxWriter;

package/dist/src/txs/receipt/TxLogParser.js

@@ -11,7 +11,11 @@ class TxLogParser {
     constructor(topics = new TxTopicProvider_1.TxTopicProvider()) {
         this.topics = topics;
     }
-    async parse(receipt) {
+    /**
+     *  Sparse arrays will contain NULLs for unparsed log items.
+     *  Per default dense arrays - only with known logs - are returned
+     */
+    async parse(receipt, opts) {
         let logs = await (0, alot_1.default)(receipt.logs).mapAsync(async (log) => {
             let topic = await this.topics.get(log.topics[0]);
             if (topic == null) {
@@ -19,8 +23,14 @@ class TxLogParser {
             }
             let { abi, formatter } = topic;
             let parsed = _contract_1.$contract.parseLogWithAbi(log, abi);
+            if (formatter) {
+                return await formatter.extract(parsed, opts?.platform ?? 'eth');
+            }
             return parsed;
         }).toArrayAsync();
+        if (opts?.sparse !== true) {
+            logs = logs.filter(x => x != null);
+        }
         return logs;
     }
 }

package/dist/src/txs/receipt/TxLogsTransfer.js

@@ -5,8 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxLogsTransfer = void 0;
 const alot_1 = __importDefault(require("alot"));
-const TokensServiceFactory_1 = require("@dequanto/tokens/TokensServiceFactory");
-const TxLogParser_1 = require("./TxLogParser");
+const TokenDataProvider_1 = require("@dequanto/tokens/TokenDataProvider");
 class TxLogsTransfer {
     async extractFromWriter(writer) {
         let receipt = await writer.onCompleted;
@@ -14,13 +13,14 @@ class TxLogsTransfer {
         return this.extractFromParsed(knownLogs, writer.client.platform);
     }
     async extractFromParsed(knownLogs, platform) {
-        let transfers = knownLogs.filter(x => x.name === 'Transfer');
-        let tokenService = TokensServiceFactory_1.TokensServiceFactory.get(platform);
+        let transfers = knownLogs.filter(x => x.event === 'Transfer');
+        let tokenService = new TokenDataProvider_1.TokenDataProvider(platform);
         return (0, alot_1.default)(transfers).mapAsync(async (transfer) => {
-            let erc20Address = transfer.contract;
+            let erc20Address = transfer.address;
             let token = await tokenService.getTokenOrDefault(erc20Address);
             let [from, to, amount] = transfer.arguments;
             return {
+                event: transfer.event,
                 token,
                 from: from.value,
                 to: to.value,
@@ -28,18 +28,19 @@ class TxLogsTransfer {
             };
         }).toArrayAsync();
     }
-    async extractFromReceipt(receipt, platform) {
-        let parser = new TxLogParser_1.TxLogParser();
-        let logs = await parser.parse(receipt);
-        logs = logs.filter(x => x != null);
-        return this.extractFromParsed(logs, platform);
-    }
+    // async extractFromReceipt (receipt: TransactionReceipt, platform: TPlatform): Promise<ITxLogsTransferData[]> {
+    //     let parser = new TxLogParser();
+    //     let logs = await parser.parse(receipt);
+    //     logs = logs.filter(x => x != null);
+    //     return this.extractFromParsed(logs, platform);
+    // }
     async extract(transfer, platform) {
-        let tokenService = TokensServiceFactory_1.TokensServiceFactory.get(platform);
-        let erc20Address = transfer.contract;
+        let tokenService = new TokenDataProvider_1.TokenDataProvider(platform);
+        let erc20Address = transfer.address;
         let token = await tokenService.getTokenOrDefault(erc20Address);
         let [from, to, amount] = transfer.arguments;
         return {
+            event: transfer.event,
             token,
             from: from.value,
             to: to.value,

package/dist/src/txs/receipt/TxTopicProvider.js

@@ -1,17 +1,21 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxTopicProvider = void 0;
-//import { TxLogsTransfer } from './TxLogsTransfer';
+const a_di_1 = __importDefault(require("a-di"));
+const TxLogsTransfer_1 = require("./TxLogsTransfer");
 const TxTopicInMemoryProvider_1 = require("./TxTopicInMemoryProvider");
 class TxTopicProvider {
     constructor() {
         this.default = new TxTopicInMemoryProvider_1.TxTopicInMemoryProvider();
         this.register([
-            'event Transfer(address from, address to, uint256 amount)'
-            // {
-            //     abi: 'event Transfer(address from, address to, uint256 amount)',
-            //     formatter: di.resolve(TxLogsTransfer)
-            // }
+            //'event Transfer(address from, address to, uint256 amount)'
+            {
+                abi: 'event Transfer(address from, address to, uint256 amount)',
+                formatter: a_di_1.default.resolve(TxLogsTransfer_1.TxLogsTransfer)
+            }
         ]);
     }
     async get(topicHash) {

package/dist/src/txs/sig-transports/SigFileTransport.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SigFileTransport = void 0;
+const _logger_1 = require("@dequanto/utils/$logger");
+const _sign_1 = require("@dequanto/utils/$sign");
+const _txData_1 = require("@dequanto/utils/$txData");
+const atma_io_1 = require("atma-io");
+const ethers_1 = require("ethers");
+class SigFileTransport {
+    async create(path, txBuilder, params) {
+        let tx = _txData_1.$txData.getJson(txBuilder.data, txBuilder.client);
+        let json = {
+            account: {
+                address: txBuilder.account?.address
+            },
+            tx,
+            config: txBuilder.config,
+            raw: ethers_1.utils.serializeTransaction(tx),
+            signature: null,
+        };
+        await atma_io_1.File.writeAsync(path, json);
+        _logger_1.$logger.log('');
+        _logger_1.$logger.log(`Tx data saved to the file "${path}".`);
+        _logger_1.$logger.log(`Sign the data, insert the signature to the "signature" field and save the file.`);
+        if (params.wait) {
+            _logger_1.$logger.log(`Waiting for the signature...`);
+            _logger_1.$logger.log(`... or you can close this process, and continue later with "0xweb tx send ${path}"`);
+        }
+        else {
+            _logger_1.$logger.log(`Continue later with "0xweb tx send ${path}"`);
+            return { path };
+        }
+        _logger_1.$logger.log('');
+        return new Promise((resolve) => {
+            atma_io_1.File.watch(path, async () => {
+                _logger_1.$logger.log(`File changed. Checking signature...`);
+                let json = await atma_io_1.File.readAsync(path, { cached: false });
+                if (json?.signature == null) {
+                    _logger_1.$logger.log(`Signature not found. Still waiting...`);
+                    return;
+                }
+                let signed = await _sign_1.$sign.serializeTx(tx, json.signature);
+                resolve({ path, signed });
+            });
+        });
+    }
+}
+exports.SigFileTransport = SigFileTransport;

package/dist/src/utils/$abiParser.js

@@ -45,7 +45,7 @@ var $abiParser;
             throw new Error(`Invalid method abi ${methodAbi}. Expect like 'foo(uint256):address'`);
         }
         let fnName = match.groups.methodName;
-        let $return = match.groups.return?.trim() ?? 'uint256';
+        let $return = match.groups.return?.trim() ?? '';
         outputs = parseArguments($return);
         let inputs = Parse.parametersLine(match.groups.params ?? '');
         return {
@@ -64,6 +64,7 @@ var $abiParser;
     // (uint256, uint256)
     // (uint256 foo, uint256 bar)
     // (uint256 foo, uint256 bar)[]
+    // ((uint256 foo, uint256 bar) foo, uint256 bar)
     function parseArguments(line) {
         line = line?.trim();
         if (!line || line === '()') {
@@ -78,8 +79,7 @@ var $abiParser;
             let parametersLine = line.substring(1, end);
             let isArray = line.endsWith('[]');
             let params = Parse.parametersLine(parametersLine);
-            let isTuple = params.every(x => Boolean(x.name));
-            if (isTuple && isArray) {
+            if (isArray) {
                 return [
                     {
                         name: '',
@@ -88,15 +88,29 @@ var $abiParser;
                     }
                 ];
             }
-            if (params.length === 1) {
-                line = params[0].type;
-                params = [
+            let delimiter = line.indexOf(',', end);
+            if (delimiter === -1) {
+                delimiter = line.length;
+            }
+            let tupleName = line.substring(end + 1, delimiter).trim();
+            if (tupleName) {
+                return [
                     {
-                        name: "",
-                        type: line,
-                    },
+                        name: tupleName,
+                        type: `tuple`,
+                        components: params
+                    }
                 ];
             }
+            // if (params.length === 1) {
+            //     line = params[0].type;
+            //     params = [
+            //         {
+            //             name: "",
+            //             type: line,
+            //         },
+            //     ];
+            // }
             return params;
         }
         // if (c === '{') {
@@ -109,10 +123,17 @@ var $abiParser;
         //         };
         //     });
         // }
+        let name = '';
+        let type = line;
+        let match = /^(?<type>.+)\s+(?<name>[\w_$]+)$/.exec(line);
+        if (match) {
+            name = match.groups.name;
+            type = match.groups.type;
+        }
         return [
             {
-                name: '',
-                type: line,
+                name,
+                type,
             },
         ];
     }
@@ -122,19 +143,33 @@ var Parse;
 (function (Parse) {
     // uint256 foo, uint bar, address qux
     function parametersLine(paramsStr) {
-        return paramsStr
-            .split(',')
-            .map(x => x.trim())
-            .filter(Boolean)
+        return splitByDelimiter(paramsStr, ',')
             .map(param => {
-            let [_type, _name] = param.split(/\s+/).map(x => x.trim()).filter(Boolean);
-            return {
-                name: _name ?? '',
-                type: _type.trim()
-            };
+            let params = $abiParser.parseArguments(param);
+            return params[0];
         });
     }
     Parse.parametersLine = parametersLine;
+    function splitByDelimiter(line, delimiter) {
+        let parts = [];
+        let start = 0;
+        for (let i = 0; i < line.length; i++) {
+            let c = line[i];
+            if (c === delimiter) {
+                parts.push(line.substring(start, i).trim());
+                start = i + 1;
+                continue;
+            }
+            if (c === '(') {
+                i = goToClosing(line, i, c);
+                continue;
+            }
+        }
+        // final part
+        parts.push(line.substring(start).trim());
+        return parts.filter(Boolean);
+    }
+    Parse.splitByDelimiter = splitByDelimiter;
     function goToClosing(str, startI, openChar, closeChar) {
         closeChar = closeChar ?? CLOSE_CHARS[openChar];
         let count = 0;