@tonappchain/sdk 0.7.0-rc16 → 0.7.0-rc19

package/dist/artifacts/testnet/ton/internal/wrappers/utils/GasUtils.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMsgPrices = exports.setMsgPrices = exports.configParseMsgPrices = exports.storageValue = exports.StorageStats = void 0;
+exports.computedGeneric = computedGeneric;
+exports.storageGeneric = storageGeneric;
+exports.shr16ceil = shr16ceil;
+exports.collectCellStats = collectCellStats;
+exports.getGasPrices = getGasPrices;
+exports.setGasPrice = setGasPrice;
+exports.getStoragePrices = getStoragePrices;
+exports.calcStorageFee = calcStorageFee;
+exports.calcMasterchainStorageFee = calcMasterchainStorageFee;
+exports.setStoragePrices = setStoragePrices;
+exports.computeGasFee = computeGasFee;
+exports.computeDefaultForwardFee = computeDefaultForwardFee;
+exports.computeCellForwardFees = computeCellForwardFees;
+exports.computeMessageForwardFees = computeMessageForwardFees;
+exports.computeFwdFees = computeFwdFees;
+exports.computeFwdFeesVerbose = computeFwdFeesVerbose;
+const core_1 = require("@ton/core");
+class StorageStats {
+    constructor(bits, cells) {
+        this.bits = bits !== undefined ? BigInt(bits) : 0n;
+        this.cells = cells !== undefined ? BigInt(cells) : 0n;
+    }
+    add(...stats) {
+        let cells = this.cells, bits = this.bits;
+        for (let stat of stats) {
+            bits += stat.bits;
+            cells += stat.cells;
+        }
+        return new StorageStats(bits, cells);
+    }
+    sub(...stats) {
+        let cells = this.cells, bits = this.bits;
+        for (let stat of stats) {
+            bits -= stat.bits;
+            cells -= stat.cells;
+        }
+        return new StorageStats(bits, cells);
+    }
+    addBits(bits) {
+        return new StorageStats(this.bits + BigInt(bits), this.cells);
+    }
+    subBits(bits) {
+        return new StorageStats(this.bits - BigInt(bits), this.cells);
+    }
+    addCells(cells) {
+        return new StorageStats(this.bits, this.cells + BigInt(cells));
+    }
+    subCells(cells) {
+        return new StorageStats(this.bits, this.cells - BigInt(cells));
+    }
+    toString() {
+        return JSON.stringify({
+            bits: this.bits.toString(),
+            cells: this.cells.toString(),
+        });
+    }
+}
+exports.StorageStats = StorageStats;
+function computedGeneric(transaction) {
+    if (transaction.description.type !== 'generic')
+        throw 'Expected generic transactionaction';
+    if (transaction.description.computePhase.type !== 'vm')
+        throw 'Compute phase expected';
+    return transaction.description.computePhase;
+}
+function storageGeneric(transaction) {
+    if (transaction.description.type !== 'generic')
+        throw 'Expected generic transactionaction';
+    const storagePhase = transaction.description.storagePhase;
+    if (storagePhase === null || storagePhase === undefined)
+        throw 'Storage phase expected';
+    return storagePhase;
+}
+function shr16ceil(src) {
+    let rem = src % BigInt(65536);
+    let res = src / 65536n; // >> BigInt(16);
+    if (rem != BigInt(0)) {
+        res += BigInt(1);
+    }
+    return res;
+}
+function collectCellStats(cell, visited, skipRoot = false) {
+    let bits = skipRoot ? 0n : BigInt(cell.bits.length);
+    let cells = skipRoot ? 0n : 1n;
+    let hash = cell.hash().toString();
+    if (visited.includes(hash)) {
+        // We should not account for current cell data if visited
+        return new StorageStats();
+    }
+    else {
+        visited.push(hash);
+    }
+    for (let ref of cell.refs) {
+        let r = collectCellStats(ref, visited);
+        cells += r.cells;
+        bits += r.bits;
+    }
+    return new StorageStats(bits, cells);
+}
+function getGasPrices(configRaw, workchain) {
+    const config = configRaw.beginParse().loadDictDirect(core_1.Dictionary.Keys.Int(32), core_1.Dictionary.Values.Cell());
+    const ds = config.get(21 + workchain).beginParse();
+    if (ds.loadUint(8) !== 0xd1) {
+        throw new Error('Invalid flat gas prices tag!');
+    }
+    const flat_gas_limit = ds.loadUintBig(64);
+    const flat_gas_price = ds.loadUintBig(64);
+    if (ds.loadUint(8) !== 0xde) {
+        throw new Error('Invalid gas prices tag!');
+    }
+    return {
+        flat_gas_limit,
+        flat_gas_price,
+        gas_price: ds.preloadUintBig(64),
+    };
+}
+function setGasPrice(configRaw, prices, workchain) {
+    const config = configRaw.beginParse().loadDictDirect(core_1.Dictionary.Keys.Int(32), core_1.Dictionary.Values.Cell());
+    const idx = 21 + workchain;
+    const ds = config.get(idx);
+    const tail = ds.beginParse().skip(8 + 64 + 64 + 8 + 64);
+    const newPrices = (0, core_1.beginCell)()
+        .storeUint(0xd1, 8)
+        .storeUint(prices.flat_gas_limit, 64)
+        .storeUint(prices.flat_gas_price, 64)
+        .storeUint(0xde, 8)
+        .storeUint(prices.gas_price, 64)
+        .storeSlice(tail)
+        .endCell();
+    config.set(idx, newPrices);
+    return (0, core_1.beginCell)().storeDictDirect(config).endCell();
+}
+exports.storageValue = {
+    serialize: (src, builder) => {
+        builder
+            .storeUint(0xcc, 8)
+            .storeUint(src.utime_sice, 32)
+            .storeUint(src.bit_price_ps, 64)
+            .storeUint(src.cell_price_ps, 64)
+            .storeUint(src.mc_bit_price_ps, 64)
+            .storeUint(src.mc_cell_price_ps, 64);
+    },
+    parse: (src) => {
+        return {
+            utime_sice: src.skip(8).loadUint(32),
+            bit_price_ps: src.loadUintBig(64),
+            cell_price_ps: src.loadUintBig(64),
+            mc_bit_price_ps: src.loadUintBig(64),
+            mc_cell_price_ps: src.loadUintBig(64),
+        };
+    },
+};
+function getStoragePrices(configRaw) {
+    const config = configRaw.beginParse().loadDictDirect(core_1.Dictionary.Keys.Int(32), core_1.Dictionary.Values.Cell());
+    const storageData = core_1.Dictionary.loadDirect(core_1.Dictionary.Keys.Uint(32), exports.storageValue, config.get(18));
+    const values = storageData.values();
+    return values[values.length - 1];
+}
+function calcStorageFee(prices, stats, duration) {
+    return shr16ceil((stats.bits * prices.bit_price_ps + stats.cells * prices.cell_price_ps) * duration);
+}
+function calcMasterchainStorageFee(prices, stats, duration) {
+    return shr16ceil((stats.bits * prices.mc_bit_price_ps + stats.cells * prices.mc_cell_price_ps) * duration);
+}
+function setStoragePrices(configRaw, prices) {
+    const config = configRaw.beginParse().loadDictDirect(core_1.Dictionary.Keys.Int(32), core_1.Dictionary.Values.Cell());
+    const storageData = core_1.Dictionary.loadDirect(core_1.Dictionary.Keys.Uint(32), exports.storageValue, config.get(18));
+    storageData.set(storageData.values().length - 1, prices);
+    config.set(18, (0, core_1.beginCell)().storeDictDirect(storageData).endCell());
+    return (0, core_1.beginCell)().storeDictDirect(config).endCell();
+}
+function computeGasFee(prices, gas) {
+    if (gas <= prices.flat_gas_limit) {
+        return prices.flat_gas_price;
+    }
+    return prices.flat_gas_price + (prices.gas_price * (gas - prices.flat_gas_limit)) / 65536n;
+}
+function computeDefaultForwardFee(msgPrices) {
+    return msgPrices.lumpPrice - ((msgPrices.lumpPrice * msgPrices.firstFrac) >> BigInt(16));
+}
+function computeCellForwardFees(msgPrices, msg) {
+    let storageStats = collectCellStats(msg, [], true);
+    return computeFwdFees(msgPrices, storageStats.cells, storageStats.bits);
+}
+function computeMessageForwardFees(msgPrices, msg) {
+    // let msg = loadMessageRelaxed(cell.beginParse());
+    let storageStats = new StorageStats();
+    if (msg.info.type !== 'internal') {
+        throw Error('Helper intended for internal messages');
+    }
+    const defaultFwd = computeDefaultForwardFee(msgPrices);
+    // If message forward fee matches default than msg cell is flat
+    if (msg.info.forwardFee == defaultFwd) {
+        return { fees: msgPrices.lumpPrice, res: defaultFwd, remaining: defaultFwd, stats: storageStats };
+    }
+    let visited = [];
+    // Init
+    if (msg.init) {
+        let addBits = 5n; // Minimal additional bits
+        let refCount = 0;
+        if (msg.init.splitDepth) {
+            addBits += 5n;
+        }
+        if (msg.init.libraries) {
+            refCount++;
+            storageStats = storageStats.add(collectCellStats((0, core_1.beginCell)().storeDictDirect(msg.init.libraries).endCell(), visited, true));
+        }
+        if (msg.init.code) {
+            refCount++;
+            storageStats = storageStats.add(collectCellStats(msg.init.code, visited));
+        }
+        if (msg.init.data) {
+            refCount++;
+            storageStats = storageStats.add(collectCellStats(msg.init.data, visited));
+        }
+        if (refCount >= 2) {
+            //https://github.com/ton-blockchain/ton/blob/51baec48a02e5ba0106b0565410d2c2fd4665157/crypto/block/transaction.cpp#L2079
+            storageStats.cells++;
+            storageStats.bits += addBits;
+        }
+    }
+    const lumpBits = BigInt(msg.body.bits.length);
+    const bodyStats = collectCellStats(msg.body, visited, true);
+    storageStats = storageStats.add(bodyStats);
+    // NOTE: Extra currencies are ignored for now
+    let fees = computeFwdFeesVerbose(msgPrices, BigInt(storageStats.cells), BigInt(storageStats.bits));
+    // Meeh
+    if (fees.remaining < msg.info.forwardFee) {
+        // console.log(`Remaining ${fees.remaining} < ${msg.info.forwardFee} lump bits:${lumpBits}`);
+        storageStats = storageStats.addCells(1).addBits(lumpBits);
+        fees = computeFwdFeesVerbose(msgPrices, storageStats.cells, storageStats.bits);
+    }
+    // if(fees.remaining != msg.info.forwardFee) {
+    //     throw(new Error("Something went wrong in fee calcuation!"));
+    // }
+    return { fees, stats: storageStats };
+}
+const configParseMsgPrices = (sc) => {
+    let magic = sc.loadUint(8);
+    if (magic != 0xea) {
+        throw Error('Invalid message prices magic number!');
+    }
+    return {
+        lumpPrice: sc.loadUintBig(64),
+        bitPrice: sc.loadUintBig(64),
+        cellPrice: sc.loadUintBig(64),
+        ihrPriceFactor: sc.loadUintBig(32),
+        firstFrac: sc.loadUintBig(16),
+        nextFrac: sc.loadUintBig(16),
+    };
+};
+exports.configParseMsgPrices = configParseMsgPrices;
+const setMsgPrices = (configRaw, prices, workchain) => {
+    const config = configRaw.beginParse().loadDictDirect(core_1.Dictionary.Keys.Int(32), core_1.Dictionary.Values.Cell());
+    const priceCell = (0, core_1.beginCell)()
+        .storeUint(0xea, 8)
+        .storeUint(prices.lumpPrice, 64)
+        .storeUint(prices.bitPrice, 64)
+        .storeUint(prices.cellPrice, 64)
+        .storeUint(prices.ihrPriceFactor, 32)
+        .storeUint(prices.firstFrac, 16)
+        .storeUint(prices.nextFrac, 16)
+        .endCell();
+    config.set(25 + workchain, priceCell);
+    return (0, core_1.beginCell)().storeDictDirect(config).endCell();
+};
+exports.setMsgPrices = setMsgPrices;
+const getMsgPrices = (configRaw, workchain) => {
+    const config = configRaw.beginParse().loadDictDirect(core_1.Dictionary.Keys.Int(32), core_1.Dictionary.Values.Cell());
+    const prices = config.get(25 + workchain);
+    if (prices === undefined) {
+        throw Error('No prices defined in config');
+    }
+    return (0, exports.configParseMsgPrices)(prices.beginParse());
+};
+exports.getMsgPrices = getMsgPrices;
+function computeFwdFees(msgPrices, cells, bits) {
+    return msgPrices.lumpPrice + shr16ceil(msgPrices.bitPrice * bits + msgPrices.cellPrice * cells);
+}
+function computeFwdFeesVerbose(msgPrices, cells, bits) {
+    const fees = computeFwdFees(msgPrices, BigInt(cells), BigInt(bits));
+    const res = (fees * msgPrices.firstFrac) >> 16n;
+    return {
+        total: fees,
+        res,
+        remaining: fees - res,
+    };
+}

package/dist/artifacts/testnet/ton/internal/wrappers/utils/MerkleRoots.d.ts

@@ -0,0 +1,7 @@
+import { Cell, Dictionary } from '@ton/core';
+export type MerkleRoot = {
+    root: bigint;
+    validTimestamp: number;
+};
+export declare function cellToArray(addrDict: Cell | null): Array<MerkleRoot>;
+export declare function arrayToCell(arr: Array<MerkleRoot>): Dictionary<bigint, number>;

package/dist/artifacts/testnet/ton/internal/wrappers/utils/MerkleRoots.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cellToArray = cellToArray;
+exports.arrayToCell = arrayToCell;
+const core_1 = require("@ton/core");
+const Constants_1 = require("../Constants");
+function cellToArray(addrDict) {
+    let resArr = [];
+    if (addrDict !== null) {
+        const dict = core_1.Dictionary.loadDirect(core_1.Dictionary.Keys.BigUint(Constants_1.Params.bitsize.hash), core_1.Dictionary.Values.Uint(Constants_1.Params.bitsize.time), addrDict);
+        resArr = dict.keys().map((root) => {
+            const time = dict.get(root);
+            return {
+                root: root,
+                validTimestamp: time,
+            };
+        });
+    }
+    return resArr;
+}
+function arrayToCell(arr) {
+    let dict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(Constants_1.Params.bitsize.hash), core_1.Dictionary.Values.Uint(Constants_1.Params.bitsize.time));
+    for (let i = 0; i < arr.length; i++) {
+        dict.set(arr[i].root, arr[i].validTimestamp);
+    }
+    return dict;
+}

package/dist/artifacts/testnet/ton/wrappers.d.ts

@@ -0,0 +1,8 @@
+export { CrossChainLayer, CrossChainLayerConfig, CrossChainLayerOpCodes, MsgType } from "./internal/wrappers/CrossChainLayer";
+export { JettonMinter, JettonMinterConfig, JettonMinterData, JettonMinterOpCodes } from "./internal/wrappers/JettonMinter";
+export { JettonProxy, JettonProxyConfig, JettonProxyOpCodes } from "./internal/wrappers/JettonProxy";
+export { JettonWallet, JettonWalletConfig, JettonWalletData, JettonWalletOpCodes } from "./internal/wrappers/JettonWallet";
+export { NFTCollection, NFTCollectionConfig, NFTCollectionData, NFTCollectionOpCodes } from "./internal/wrappers/NFTCollection";
+export { NFTItem, NFTItemConfig, NFTItemData, NFTItemOpCodes } from "./internal/wrappers/NFTItem";
+export { NFTProxy, NFTProxyConfig, NFTProxyOpCodes } from "./internal/wrappers/NFTProxy";
+export { Settings, SettingsConfig } from "./internal/wrappers/Settings";

package/dist/artifacts/testnet/ton/wrappers.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Settings = exports.NFTProxyOpCodes = exports.NFTProxy = exports.NFTItemOpCodes = exports.NFTItem = exports.NFTCollectionOpCodes = exports.NFTCollection = exports.JettonWalletOpCodes = exports.JettonWallet = exports.JettonProxyOpCodes = exports.JettonProxy = exports.JettonMinterOpCodes = exports.JettonMinter = exports.MsgType = exports.CrossChainLayerOpCodes = exports.CrossChainLayer = void 0;
+var CrossChainLayer_1 = require("./internal/wrappers/CrossChainLayer");
+Object.defineProperty(exports, "CrossChainLayer", { enumerable: true, get: function () { return CrossChainLayer_1.CrossChainLayer; } });
+Object.defineProperty(exports, "CrossChainLayerOpCodes", { enumerable: true, get: function () { return CrossChainLayer_1.CrossChainLayerOpCodes; } });
+Object.defineProperty(exports, "MsgType", { enumerable: true, get: function () { return CrossChainLayer_1.MsgType; } });
+var JettonMinter_1 = require("./internal/wrappers/JettonMinter");
+Object.defineProperty(exports, "JettonMinter", { enumerable: true, get: function () { return JettonMinter_1.JettonMinter; } });
+Object.defineProperty(exports, "JettonMinterOpCodes", { enumerable: true, get: function () { return JettonMinter_1.JettonMinterOpCodes; } });
+var JettonProxy_1 = require("./internal/wrappers/JettonProxy");
+Object.defineProperty(exports, "JettonProxy", { enumerable: true, get: function () { return JettonProxy_1.JettonProxy; } });
+Object.defineProperty(exports, "JettonProxyOpCodes", { enumerable: true, get: function () { return JettonProxy_1.JettonProxyOpCodes; } });
+var JettonWallet_1 = require("./internal/wrappers/JettonWallet");
+Object.defineProperty(exports, "JettonWallet", { enumerable: true, get: function () { return JettonWallet_1.JettonWallet; } });
+Object.defineProperty(exports, "JettonWalletOpCodes", { enumerable: true, get: function () { return JettonWallet_1.JettonWalletOpCodes; } });
+var NFTCollection_1 = require("./internal/wrappers/NFTCollection");
+Object.defineProperty(exports, "NFTCollection", { enumerable: true, get: function () { return NFTCollection_1.NFTCollection; } });
+Object.defineProperty(exports, "NFTCollectionOpCodes", { enumerable: true, get: function () { return NFTCollection_1.NFTCollectionOpCodes; } });
+var NFTItem_1 = require("./internal/wrappers/NFTItem");
+Object.defineProperty(exports, "NFTItem", { enumerable: true, get: function () { return NFTItem_1.NFTItem; } });
+Object.defineProperty(exports, "NFTItemOpCodes", { enumerable: true, get: function () { return NFTItem_1.NFTItemOpCodes; } });
+var NFTProxy_1 = require("./internal/wrappers/NFTProxy");
+Object.defineProperty(exports, "NFTProxy", { enumerable: true, get: function () { return NFTProxy_1.NFTProxy; } });
+Object.defineProperty(exports, "NFTProxyOpCodes", { enumerable: true, get: function () { return NFTProxy_1.NFTProxyOpCodes; } });
+var Settings_1 = require("./internal/wrappers/Settings");
+Object.defineProperty(exports, "Settings", { enumerable: true, get: function () { return Settings_1.Settings; } });

package/dist/{adapters → src/adapters}/contractOpener.js

@@ -6,15 +6,16 @@ exports.orbsOpener = orbsOpener;
 exports.orbsOpener4 = orbsOpener4;
 const ton_access_1 = require("@orbs-network/ton-access");
 const ton_1 = require("@ton/ton");
-const artifacts_1 = require("@tonappchain/artifacts");
 const ton_lite_client_1 = require("@tonappchain/ton-lite-client");
+const artifacts_1 = require("../../artifacts");
 const Utils_1 = require("../sdk/Utils");
 const Struct_1 = require("../structs/Struct");
 async function getHttpEndpointWithRetry(network, maxRetries = 5, delay = 1000) {
     let lastError;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
-            return await (0, ton_access_1.getHttpEndpoint)({ network });
+            const tonNetwork = network === Struct_1.Network.MAINNET ? 'mainnet' : 'testnet';
+            return await (0, ton_access_1.getHttpEndpoint)({ network: tonNetwork });
         }
         catch (error) {
             lastError = error;
@@ -29,7 +30,8 @@ async function getHttpV4EndpointWithRetry(network, maxRetries = 5, delay = 1000)
     let lastError;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
         try {
-            return await (0, ton_access_1.getHttpV4Endpoint)({ network });
+            const tonNetwork = network === Struct_1.Network.MAINNET ? 'mainnet' : 'testnet';
+            return await (0, ton_access_1.getHttpV4Endpoint)({ network: tonNetwork });
         }
         catch (error) {
             lastError = error;
@@ -48,7 +50,7 @@ function intToIP(int) {
     return part4 + '.' + part3 + '.' + part2 + '.' + part1;
 }
 async function getDefaultLiteServers(network) {
-    const url = network === Struct_1.Network.TESTNET ? artifacts_1.testnet.DEFAULT_LITESERVERS : artifacts_1.mainnet.DEFAULT_LITESERVERS;
+    const url = network === Struct_1.Network.TESTNET || network === Struct_1.Network.DEV ? artifacts_1.testnet.DEFAULT_LITESERVERS : artifacts_1.mainnet.DEFAULT_LITESERVERS;
     const resp = await fetch(url);
     const liteClients = await resp.json();
     return liteClients.liteservers;

package/dist/{adapters → src/adapters}/retryableContractOpener.d.ts

@@ -1,8 +1,7 @@
 import { SandboxContract } from '@ton/sandbox';
 import { Address, Contract, OpenedContract } from '@ton/ton';
-import { mainnet, testnet } from '@tonappchain/artifacts';
 import { ContractOpener } from '../interfaces';
-import { ContractState } from '../structs/Struct';
+import { ContractState, Network } from '../structs/Struct';
 export interface OpenerConfig {
     /** Underlying opener implementation to use for this slot. */
     opener: ContractOpener;
@@ -22,4 +21,4 @@ export declare class RetryableContractOpener implements ContractOpener {
     private createRetryableContract;
     private callMethodAcrossOpeners;
 }
-export declare function createDefaultRetryableOpener(artifacts: typeof testnet | typeof mainnet, maxRetries?: number, retryDelay?: number): Promise<ContractOpener>;
+export declare function createDefaultRetryableOpener(tonRpcEndpoint: string, networkType: Network, maxRetries?: number, retryDelay?: number): Promise<ContractOpener>;

package/dist/{adapters → src/adapters}/retryableContractOpener.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RetryableContractOpener = void 0;
 exports.createDefaultRetryableOpener = createDefaultRetryableOpener;
 const ton_1 = require("@ton/ton");
-const artifacts_1 = require("@tonappchain/artifacts");
 const instances_1 = require("../errors/instances");
 const Struct_1 = require("../structs/Struct");
 const contractOpener_1 = require("./contractOpener");
@@ -86,16 +85,16 @@ class RetryableContractOpener {
     }
 }
 exports.RetryableContractOpener = RetryableContractOpener;
-async function createDefaultRetryableOpener(artifacts, maxRetries = 5, retryDelay = 1000) {
+async function createDefaultRetryableOpener(tonRpcEndpoint, networkType, maxRetries = 5, retryDelay = 1000) {
+    const openers = [];
     const tonClient = new ton_1.TonClient({
-        endpoint: new URL('api/v2/jsonRPC', artifacts.TON_RPC_ENDPOINT_BY_TAC).toString(),
+        endpoint: new URL('api/v2/jsonRPC', tonRpcEndpoint).toString(),
     });
-    const network = artifacts === artifacts_1.testnet ? Struct_1.Network.TESTNET : Struct_1.Network.MAINNET;
-    const opener4 = await (0, contractOpener_1.orbsOpener4)(network);
-    const opener = await (0, contractOpener_1.orbsOpener)(network);
-    return new RetryableContractOpener([
-        { opener: tonClient, retries: maxRetries, retryDelay },
-        { opener: opener4, retries: maxRetries, retryDelay },
-        { opener: opener, retries: maxRetries, retryDelay },
-    ]);
+    openers.push({ opener: tonClient, retries: maxRetries, retryDelay });
+    if (networkType !== Struct_1.Network.DEV) {
+        const opener4 = await (0, contractOpener_1.orbsOpener4)(networkType);
+        const opener = await (0, contractOpener_1.orbsOpener)(networkType);
+        openers.push({ opener: opener4, retries: maxRetries, retryDelay }, { opener: opener, retries: maxRetries, retryDelay });
+    }
+    return new RetryableContractOpener(openers);
 }