trac-msb 0.2.7 → 0.2.9

package/.github/workflows/publish.yml

@@ -5,37 +5,29 @@ on:
     types: [published]
 
 permissions:
+  id-token: write  # Required for OIDC
   contents: read
 
 jobs:
-  publish-npm:
+  publish:
     runs-on: ubuntu-latest
-
     steps:
-      - name: Checkout repo
+      - name: Checkout release tag
         uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.release.tag_name }}
 
       - name: Use Node.js
         uses: actions/setup-node@v4
         with:
           node-version: '24'
           registry-url: 'https://registry.npmjs.org'
+      - name: Install dependencies
+        run: npm ci
 
-      - name: Set package.json version from tag
-        run: |
-          TAG="${GITHUB_REF#refs/tags/}"
-          VERSION="${TAG#v}"
-          echo "Version from tag: $VERSION"
-          npm version "$VERSION" --no-git-tag-version
-          
       # unit tests are temporarily disabled because they lost stability on GH runners.
-      #- name: Install dependencies
-      #  run: npm ci
-
       #- name: Run unit tests
       #  run: npm run test:unit:all
 
       - name: Publish to npm
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_MSB_PUBLISH_TOKEN }}
-        run: npm publish
+        run: npm publish --access public

package/msb.mjs

@@ -1,33 +1,22 @@
 import { MainSettlementBus } from './src/index.js';
+import { startRpcServer } from './rpc/rpc_server.js';
+import { createConfig, ENV } from './src/config/env.js';
 
 const pearApp = typeof Pear !== 'undefined' ? (Pear.app ?? Pear.config) : undefined;
 const runtimeArgs = typeof process !== 'undefined' ? process.argv.slice(2) : [];
 const args = pearApp?.args ?? runtimeArgs;
 const runRpc = args.includes('--rpc');
+const storeName = pearApp?.args?.[0] ?? runtimeArgs[0]
 
-const opts = {
-    stores_directory: 'stores/',
-    store_name: pearApp?.args?.[0] ?? runtimeArgs[0],
-    bootstrap: 'acbc3a4344d3a804101d40e53db1dda82b767646425af73599d4cd6577d69685',
-    channel: '0000trac0network0msb0mainnet0000',
-    enable_role_requester: false,
-    enable_wallet: true,
-    enable_validator_observer: true,
-    enable_interactive_mode: true,
-    disable_rate_limit: false,
-    enable_tx_apply_logs: false,
-    enable_error_apply_logs: false,
-};
+const rpc = {
+    storeName: pearApp?.args?.[0] ?? runtimeArgs[0],
+    enableWallet: false,
+    enableInteractiveMode: false
+}
 
-const rpc_opts = {
-    ...opts,
-    enable_tx_apply_logs: false,
-    enable_error_apply_logs: false,
-    enable_wallet: false,
-    enable_interactive_mode: false,
-};
-
-const msb = new MainSettlementBus(runRpc ? rpc_opts : opts);
+const options = args.includes('--rpc') ? rpc : { storeName }
+const config = createConfig(ENV.MAINNET, options)
+const msb = new MainSettlementBus(config);
 
 msb.ready().then(async () => {
     if (runRpc) {
@@ -36,10 +25,9 @@ msb.ready().then(async () => {
         const port = (portIndex !== -1 && args[portIndex + 1]) ? parseInt(args[portIndex + 1], 10) : 5000;
         const hostIndex = args.indexOf('--host');
         const host = (hostIndex !== -1 && args[hostIndex + 1]) ? args[hostIndex + 1] : 'localhost';
-
-        const {startRpcServer} = await import('./rpc/rpc_server.mjs');
-        startRpcServer(msb, host, port);
+        startRpcServer(msb, config , host, port);
     } else {
+        console.log('RPC server will not be started.');
         msb.interactiveMode();
     }
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"
@@ -25,7 +25,6 @@
     "test:unit:bare:cov": "brittle-bare -c -t 60000  tests/unit/unit.test.js"
   },
   "dependencies": {
-    "@tracsystems/blake3": "0.0.13",
     "autobase": "7.20.1",
     "b4a": "1.6.7",
     "bare-crypto": "1.12.0",
@@ -50,8 +49,9 @@
     "protomux-wakeup": "2.4.0",
     "readline": "npm:bare-node-readline",
     "ready-resource": "1.1.2",
-    "trac-wallet": "0.0.43-msb-r2.8",
-    "tty": "npm:bare-node-tty"
+    "trac-wallet": "1.0.1",
+    "tty": "npm:bare-node-tty",
+    "uuid": "^13.0.0"
   },
   "devDependencies": {
     "bare-os": "^3.6.1",
@@ -67,5 +67,9 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Trac-Systems/main_settlement_bus"
   }
 }

package/proto/network.proto

@@ -0,0 +1,74 @@
+syntax = "proto3";
+
+package network.v1;
+
+enum MessageType {
+    MESSAGE_TYPE_UNSPECIFIED = 0;
+    MESSAGE_TYPE_VALIDATOR_CONNECTION_REQUEST = 1;
+    MESSAGE_TYPE_VALIDATOR_CONNECTION_RESPONSE = 2;
+    MESSAGE_TYPE_LIVENESS_REQUEST = 3;
+    MESSAGE_TYPE_LIVENESS_RESPONSE = 4;
+    MESSAGE_TYPE_BROADCAST_TRANSACTION_REQUEST = 5;
+    MESSAGE_TYPE_BROADCAST_TRANSACTION_RESPONSE = 6;
+}
+
+enum ResultCode {
+    RESULT_CODE_UNSPECIFIED = 0;
+    RESULT_CODE_OK = 1;
+    RESULT_CODE_INVALID_PAYLOAD = 2;
+    RESULT_CODE_UNSUPPORTED_VERSION = 3;
+    RESULT_CODE_RATE_LIMITED = 4;
+    RESULT_CODE_TIMEOUT = 5;
+    RESULT_CODE_SIGNATURE_INVALID = 6;
+}
+
+message ValidatorConnectionRequest {
+    string issuer_address = 1;
+    bytes nonce = 2;
+    bytes signature = 3;
+}
+
+message ValidatorConnectionResponse {
+    string issuer_address = 1;
+    bytes nonce = 2;
+    bytes signature = 3;
+    ResultCode result = 4;
+}
+
+message LivenessRequest {
+    bytes nonce = 1;
+    bytes signature = 2;
+}
+
+message LivenessResponse {
+    bytes nonce = 1;
+    bytes signature = 2;
+    ResultCode result = 3;
+}
+
+message BroadcastTransactionRequest {
+    bytes data = 1; // binary encoded payload
+    bytes nonce = 2;
+    bytes signature = 3;
+}
+
+message BroadcastTransactionResponse {
+    bytes nonce = 1;
+    bytes signature = 2;
+    ResultCode result = 3;
+}
+
+message MessageHeader {
+    MessageType type = 1;
+    string id = 2;
+    uint64 timestamp = 3;
+    oneof field {
+        ValidatorConnectionRequest            validator_connection_request  = 4;
+        ValidatorConnectionResponse           validator_connection_response  = 5;
+        LivenessRequest                       liveness_request = 6;
+        LivenessResponse                      liveness_response = 7;
+        BroadcastTransactionRequest           broadcast_transaction_request = 8;
+        BroadcastTransactionResponse          broadcast_transaction_response = 9;
+    }
+    repeated string capabilities = 10;
+}

package/rpc/{create_server.mjs → create_server.js}

@@ -1,9 +1,9 @@
 // rpc_server.mjs
 import http from 'http'
-import { applyCors } from './cors.mjs';
-import { routes } from './routes/index.mjs';
+import { applyCors } from './cors.js';
+import { routes } from './routes/index.js';
 
-export const createServer = (msbInstance) => {
+export const createServer = (msbInstance, config) => {
   const server = http.createServer({}, async (req, res) => {
     
     // --- 1. Define safe 'respond' utility (Payload MUST be an object) ---
@@ -53,7 +53,7 @@ export const createServer = (msbInstance) => {
             try {
                 // This try/catch covers synchronous errors and errors from awaited promises
                 // within the route.handler function.
-                await route.handler({ req, res, respond, msbInstance });
+                await route.handler({ req, res, respond,  msbInstance, config});
             } catch (error) {
                 // Catch errors thrown directly from the handler (or its awaited parts)
                 console.error(`Error on ${route.path}:`, error);

package/rpc/{handlers.mjs → handlers.js}

@@ -1,6 +1,6 @@
-import { decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitizeTransferPayload, validatePayloadStructure } from "./utils/helpers.mjs"
-import { MAX_SIGNED_LENGTH, ZERO_WK } from "./constants.mjs";
-import { buildRequestUrl } from "./utils/url.mjs";
+import { decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitizeTransferPayload, validatePayloadStructure } from "./utils/helpers.js"
+import { MAX_SIGNED_LENGTH, ZERO_WK } from "./constants.js";
+import { buildRequestUrl } from "./utils/url.js";
 import { isHexString } from "../src/utils/helpers.js";
 import {
     getBalance,
@@ -16,7 +16,7 @@ import {
 } from "./rpc_services.js";
 import { bufferToBigInt, licenseBufferToBigInt } from "../src/utils/amountSerialization.js";
 import { isAddressValid } from "../src/core/state/utils/address.js";
-import { getConfirmedParameter } from "./utils/confirmedParameter.mjs";
+import { getConfirmedParameter } from "./utils/confirmedParameter.js";
 
 export async function handleBalance({ req, respond, msbInstance }) {
     const url = buildRequestUrl(req);
@@ -52,7 +52,7 @@ export async function handleConfirmedLength({ msbInstance, respond }) {
     respond(200, { confirmed_length });
 }
 
-export async function handleBroadcastTransaction({ msbInstance, respond, req }) {
+export async function handleBroadcastTransaction({ msbInstance, config, respond, req }) {
     let body = '';
     req.on('data', chunk => {
         body += chunk.toString();
@@ -72,7 +72,7 @@ export async function handleBroadcastTransaction({ msbInstance, respond, req })
             const decodedPayload = decodeBase64Payload(payload);
             validatePayloadStructure(decodedPayload);
             const sanitizedPayload = sanitizeTransferPayload(decodedPayload);
-            const result = await broadcastTransaction(msbInstance, sanitizedPayload);
+            const result = await broadcastTransaction(msbInstance, config, sanitizedPayload);
             respond(200, { result });
         } catch (error) {
             let code = error instanceof SyntaxError ? 400 : 500;
@@ -258,7 +258,7 @@ export async function handleAccountDetails({ msbInstance, respond, req }) {
         return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
     }
 
-    if (!isAddressValid(address)) {
+    if (!isAddressValid(address, msbInstance.config.addressPrefix)) {
         return respond(400, { error: "Invalid account address format" });
     }
 

package/rpc/routes/{index.mjs → index.js}

@@ -1,4 +1,4 @@
-import { v1Routes } from './v1.mjs';
+import { v1Routes } from './v1.js';
 
 // future version
 // import { v2Routes } from './v2.mjs';

package/rpc/routes/{v1.mjs → v1.js}

@@ -10,7 +10,7 @@ import {
     handleFetchBulkTxPayloads,
     handleTransactionExtendedDetails,
     handleAccountDetails
-} from '../handlers.mjs';
+} from '../handlers.js';
 
 export const v1Routes = [
     { method: 'GET', path: '/balance', handler: handleBalance },

package/rpc/rpc_server.js

@@ -0,0 +1,10 @@
+import { createServer } from "./create_server.js";
+
+// Called by msb.mjs file
+export function startRpcServer(msbInstance, config ,host, port) {
+    const server = createServer(msbInstance, config)
+
+    return server.listen(port, host, () => {
+        console.log(`Running RPC with http at http://${host}:${port}`);
+    });
+}

package/rpc/rpc_services.js

@@ -1,6 +1,14 @@
 import { bufferToBigInt } from "../src/utils/amountSerialization.js";
-import { normalizeDecodedPayloadForJson } from "../src/utils/normalizers.js";
+import {
+    normalizeDecodedPayloadForJson,
+    normalizeTransactionOperation,
+    normalizeTransferOperation
+} from "../src/utils/normalizers.js";
 import { get_confirmed_tx_info, get_unconfirmed_tx_info } from "../src/utils/cli.js";
+import {OperationType} from "../src/utils/constants.js";
+import b4a from "b4a";
+import PartialTransaction from "../src/core/network/protocols/shared/validators/PartialTransaction.js";
+import PartialTransfer from "../src/core/network/protocols/shared/validators/PartialTransfer.js";
 
 export async function getBalance(msbInstance, address, confirmed) {
     const state = msbInstance.state;
@@ -36,8 +44,41 @@ export async function getUnconfirmedLength(msbInstance) {
     return msbInstance.state.getUnsignedLength();
 }
 
-export async function broadcastTransaction(msbInstance, payload) {
-    return msbInstance.broadcastTransactionCommand(payload);
+export async function broadcastTransaction(msbInstance, config, payload) {
+    if (!payload) {
+        throw new Error("Transaction payload is required for broadcasting.");
+    }
+    let normalizedPayload;
+    let isValid = false;
+    let hash;
+
+    const partialTransferValidator = new PartialTransfer(msbInstance.state, null , config);
+    const partialTransactionValidator = new PartialTransaction(msbInstance.state, null , config);
+
+    if (payload.type === OperationType.TRANSFER) {
+        normalizedPayload = normalizeTransferOperation(payload, config);
+        isValid = await partialTransferValidator.validate(normalizedPayload);
+        hash = b4a.toString(normalizedPayload.tro.tx, "hex");
+    } else if (payload.type === OperationType.TX) {
+        normalizedPayload = normalizeTransactionOperation(payload, config);
+        isValid = await partialTransactionValidator.validate(normalizedPayload);
+        hash = b4a.toString(normalizedPayload.txo.tx, "hex");
+    }
+
+    if (!isValid) {
+        throw new Error("Invalid transaction payload.");
+    }
+
+    const success = await msbInstance.broadcastPartialTransaction(payload);
+
+    if (!success) {
+        throw new Error("Failed to broadcast transaction after multiple attempts.");
+    }
+
+    const signedLength = msbInstance.state.getSignedLength();
+    const unsignedLength = msbInstance.state.getUnsignedLength();
+
+    return { message: "Transaction broadcasted successfully.", signedLength, unsignedLength, tx: hash };
 }
 
 export async function getTxHashes(msbInstance, start, end) {
@@ -51,7 +92,7 @@ export async function getTxDetails(msbInstance, hash) {
         return null;
     }
 
-    return normalizeDecodedPayloadForJson(rawPayload.decoded);
+    return normalizeDecodedPayloadForJson(rawPayload.decoded, msbInstance.config);
 }
 
 export async function fetchBulkTxPayloads(msbInstance, hashes) {
@@ -73,7 +114,7 @@ export async function fetchBulkTxPayloads(msbInstance, hashes) {
         if (result === null || result === undefined) {
             res.missing.push(hash);
         } else {
-            const decodedResult = normalizeDecodedPayloadForJson(result.decoded);
+            const decodedResult = normalizeDecodedPayloadForJson(result.decoded, msbInstance.config);
             res.results.push({ hash, payload: decodedResult });
         }
     });
@@ -93,7 +134,7 @@ export async function getExtendedTxDetails(msbInstance, hash, confirmed) {
         if (confirmedLength === null) {
             throw new Error(`No confirmed length found for tx hash: ${hash} in confirmed mode`);
         }
-        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, msbInstance.config);
         const feeBuffer = state.getFee();
         return {
             txDetails: normalizedPayload,
@@ -107,7 +148,7 @@ export async function getExtendedTxDetails(msbInstance, hash, confirmed) {
         throw new Error(`No payload found for tx hash: ${hash}`);
     }
 
-    const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+    const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, msbInstance.config);
     const length = await state.getTransactionConfirmedLength(hash);
     if (length === null) {
         return {

package/rpc/utils/{helpers.mjs → helpers.js}

@@ -1,5 +1,5 @@
 import b4a from "b4a"
-import { operationToPayload } from "../../src/utils/operations.js"
+import { operationToPayload } from "../../src/utils/applyOperations.js"
 export function decodeBase64Payload(base64) {
 	let decodedPayloadString
 	try {

package/src/config/config.js

@@ -0,0 +1,137 @@
+import b4a from 'b4a'
+
+export class Config {
+    #options
+    #config
+    #bootstrap
+    #channel
+
+    constructor(options = {}, config = {}) {
+        this.#validate(options, config)
+        this.#options = options
+        this.#config = config
+        this.#bootstrap = b4a.from(this.#options.bootstrap || this.#config.bootstrap, 'hex')
+        // Ensure a 32-byte channel buffer (repeat-fill from string/Buffer if provided)
+        this.#channel = b4a.alloc(32).fill(this.#options.channel || this.#config.channel)
+    }
+
+    get addressLength() {
+        return this.#config.addressLength
+    }
+
+    get addressPrefix() {
+        return this.#config.addressPrefix
+    }
+
+    get addressPrefixLength() {
+        return this.addressPrefix.length
+    }
+
+    get bech32mHrpLength() {
+        return this.#config.bech32mHrpLength
+    }
+
+    get bootstrap() {
+        return this.#bootstrap
+    }
+
+    get channel() {
+        return this.#channel
+    }
+
+    get dhtBootstrap() {
+        if (this.#isOverriden('dhtBootstrap')) return this.#options.dhtBootstrap
+        return this.#config.dhtBootstrap
+    }
+
+    get disableRateLimit() {
+        if (this.#isOverriden('disableRateLimit')) return !!this.#options.disableRateLimit
+        return !!this.#config.disableRateLimit
+    }
+
+    get enableErrorApplyLogs() {
+        if (this.#isOverriden('enableErrorApplyLogs')) return !!this.#options.enableErrorApplyLogs
+        return !!this.#config.enableErrorApplyLogs
+    }
+
+    get enableInteractiveMode() {
+        if (this.#isOverriden('enableInteractiveMode')) return this.#options.enableInteractiveMode !== false
+        return !!this.#config.enableInteractiveMode
+    }
+
+    get enableRoleRequester() {
+        if (this.#isOverriden('enableRoleRequester')) return !!this.#options.enableRoleRequester
+        return !!this.#config.enableRoleRequester
+    }
+
+    get enableValidatorObserver() {
+        if (this.#isOverriden('enableValidatorObserver')) return !!this.#options.enableValidatorObserver
+        return !!this.#config.enableValidatorObserver
+    }
+
+    get enableTxApplyLogs() {
+        if (this.#isOverriden('enableTxApplyLogs')) return !!this.#options.enableTxApplyLogs
+        return !!this.#config.enableTxApplyLogs
+    }
+
+    get enableWallet() {
+        if (this.#isOverriden('enableWallet')) return this.#options.enableWallet !== false
+        return !!this.#config.enableWallet
+    }
+
+    get isAdminMode() {
+        return this.#options.storeName === 'admin'
+    }
+
+    get keyPairPath()  {
+        return `${this.storesFullPath}/db/keypair.json`
+    }
+
+    get maxRetries() {
+        if (this.#isOverriden('maxRetries')) return this.#options.maxRetries
+        return this.#config.maxRetries
+    }
+
+    get maxValidators() {
+        if (this.#isOverriden('maxValidators')) return this.#options.maxValidators
+        return this.#config.maxValidators
+    }
+
+    get networkId() {
+        return this.#config.networkId
+    }
+
+    get storesDirectory() {
+        if (this.#isOverriden('storesDirectory')) return this.#options.storesDirectory
+        return this.#config.storesDirectory
+    }
+
+    get storesFullPath() {
+        return `${this.storesDirectory}${this.#options.storeName}`
+    }
+
+    get messageThreshold() {
+        return this.#config.messageThreshold
+    }
+
+    get messageValidatorRetryDelay() {
+        return this.#config.messageValidatorRetryDelay
+    }
+
+    get messageValidatorResponseTimeout() {
+        return this.#config.messageValidatorResponseTimeout
+    }
+
+    // Most of these properties are boolean
+    #isOverriden(prop) {
+        return this.#options.hasOwnProperty(prop)
+    }
+
+    #validate(options, config) {
+        if (!options.channel && !config.channel) {
+            throw new Error(
+                "MainSettlementBus: Channel is required. Application cannot start without channel."
+            );
+        }
+    }
+}

package/src/config/env.js

@@ -0,0 +1,63 @@
+import { TRAC_NETWORK_MSB_MAINNET_PREFIX } from 'trac-wallet/constants.js';
+import { Config } from './config.js';
+
+export const ENV = {
+    MAINNET: 'mainnet',
+    DEVELOPMENT: 'development',
+    TESTNET1: 'testnet1'
+}
+// TODO: CREATE TEST ENV CONFIG SIMILAR TO MAINNET AND USE IT IN TESTS.
+// TODO: CREATE TESTNET1 ENV CONFIG and update npm scripts to run node witn mainnet or testnet1.
+
+const configData = {
+    [ENV.MAINNET]: {
+        addressLength: 63,
+        addressPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX,
+        addressPrefixLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length,
+        bech32mHrpLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length + 1, // len(addressPrefix + separator)
+        bootstrap: 'acbc3a4344d3a804101d40e53db1dda82b767646425af73599d4cd6577d69685',
+        channel: '0000trac0network0msb0mainnet0000',
+        dhtBootstrap: ['116.202.214.149:10001', '157.180.12.214:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'],
+        disableRateLimit: false,
+        enableErrorApplyLogs: false,
+        enableInteractiveMode: true,
+        enableRoleRequester: false,
+        enableTxApplyLogs: false,
+        enableValidatorObserver: true,
+        enableWallet: true,
+        maxValidators: 50,
+        maxRetries: 3,
+        messageThreshold: 3,
+        messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
+        messageValidatorResponseTimeout: 3 * 3 * 1000, //Overall timeout for sending a message (ms). This is 3 * maxRetries * messageValidatorRetryDelay;
+        networkId: 918,
+        storesDirectory: 'stores/',
+    },
+    [ENV.DEVELOPMENT]: {
+        addressLength: 63,
+        addressPrefix: TRAC_NETWORK_MSB_MAINNET_PREFIX,
+        addressPrefixLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length,
+        bech32mHrpLength: TRAC_NETWORK_MSB_MAINNET_PREFIX.length + 1, // len(addressPrefix + separator)
+        bootstrap: 'e90cca53847a12a82f3bf0f67401e45e2ccc1698ee163e61414c2894eb3c6b12',
+        channel: '12312313123123',
+        dhtBootstrap: ['116.202.214.149:10001', '157.180.12.214:10001', 'node1.hyperdht.org:49737', 'node2.hyperdht.org:49737', 'node3.hyperdht.org:49737'],
+        disableRateLimit: false,
+        enableErrorApplyLogs: true,
+        enableInteractiveMode: true,
+        enableRoleRequester: false,
+        enableTxApplyLogs: true,
+        enableValidatorObserver: true,
+        enableWallet: true,
+        maxValidators: 6,
+        maxRetries: 0,
+        messageThreshold: 1000,
+        messageValidatorRetryDelay: 1000, //How long to wait before retrying (ms) MESSAGE_VALIDATOR_RETRY_DELAY_MS
+        messageValidatorResponseTimeout: 3 * 3 * 1000, //Overall timeout for sending a message (ms). This is 3 * maxRetries * messageValidatorRetryDelay;
+        networkId: 918,
+        storesDirectory : 'stores/',
+    }
+}
+
+export const createConfig = (environment, options) => {
+    return new Config(options, configData[environment])
+}