dexbot 1.4.12 → 1.4.13

package/claw/node_modules/btsdex-ecc/lib/KeyUtils.js

@@ -0,0 +1,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _PrivateKey = _interopRequireDefault(require("./PrivateKey"));
+
+var _PublicKey = _interopRequireDefault(require("./PublicKey"));
+
+var _address = _interopRequireDefault(require("./address"));
+
+var _aes = _interopRequireDefault(require("./aes"));
+
+var _hash = require("./hash");
+
+var _secureRandom = _interopRequireDefault(require("secure-random"));
+
+var _addressPrefix = require("./addressPrefix");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// import dictionary from './dictionary_en';
+const Buffer = require("safe-buffer").Buffer; // hash for .25 second
+
+
+var HASH_POWER_MILLS = 250;
+const key = {
+  /** Uses 1 second of hashing power to create a key/password checksum.  An
+    implementation can re-call this method with the same password to re-match
+    the strength of the CPU (either after moving from a desktop to a mobile,
+    mobile to desktop, or N years from now when CPUs are presumably stronger).
+     A salt is used for all the normal reasons...
+     @return object {
+        aes_private: Aes,
+        checksum: "{hash_iteration_count},{salt},{checksum}"
+    }
+    */
+  aes_checksum(password) {
+    if (!(typeof password === "string")) {
+      throw new "password string required"();
+    }
+
+    var salt = _secureRandom.default.randomBuffer(4).toString("hex");
+
+    var iterations = 0;
+    var secret = salt + password; // hash for .1 second
+
+    var start_t = Date.now();
+
+    while (Date.now() - start_t < HASH_POWER_MILLS) {
+      secret = (0, _hash.sha256)(secret);
+      iterations += 1;
+    }
+
+    var checksum = (0, _hash.sha256)(secret);
+    var checksum_string = [iterations, salt.toString("hex"), checksum.slice(0, 4).toString("hex")].join(",");
+    return {
+      aes_private: _aes.default.fromSeed(secret),
+      checksum: checksum_string
+    };
+  },
+
+  /** Provide a matching password and key_checksum.  A "wrong password"
+    error is thrown if the password does not match.  If this method takes
+    much more or less than 1 second to return, one should consider updating
+    all encyrpted fields using a new key.key_checksum.
+    */
+  aes_private(password, key_checksum) {
+    var [iterations, salt, checksum] = key_checksum.split(",");
+    var secret = salt + password;
+
+    for (var i = 0; 0 < iterations ? i < iterations : i > iterations; 0 < iterations ? i++ : i++) {
+      secret = (0, _hash.sha256)(secret);
+    }
+
+    var new_checksum = (0, _hash.sha256)(secret);
+
+    if (!(new_checksum.slice(0, 4).toString("hex") === checksum)) {
+      throw new Error("wrong password");
+    }
+
+    return _aes.default.fromSeed(secret);
+  },
+
+  /**
+        A week random number generator can run out of entropy.  This should ensure even the worst random number implementation will be reasonably safe.
+         @param1 string entropy of at least 32 bytes
+    */
+  random32ByteBuffer(entropy = this.browserEntropy()) {
+    if (!(typeof entropy === "string")) {
+      throw new Error("string required for entropy");
+    }
+
+    if (entropy.length < 32) {
+      throw new Error("expecting at least 32 bytes of entropy");
+    }
+
+    var start_t = Date.now();
+
+    while (Date.now() - start_t < HASH_POWER_MILLS) entropy = (0, _hash.sha256)(entropy);
+
+    var hash_array = [];
+    hash_array.push(entropy); // Hashing for 1 second may helps the computer is not low on entropy (this method may be called back-to-back).
+
+    hash_array.push(_secureRandom.default.randomBuffer(32));
+    return (0, _hash.sha256)(Buffer.concat(hash_array));
+  },
+
+  suggest_brain_key: function (dictionary = ",", entropy = this.browserEntropy()) {
+    var randomBuffer = this.random32ByteBuffer(entropy);
+    var word_count = 16;
+    var dictionary_lines = dictionary.split(",");
+
+    if (!(dictionary_lines.length === 49744)) {
+      throw new Error(`expecting ${49744} but got ${dictionary_lines.length} dictionary words`);
+    }
+
+    var brainkey = [];
+    var end = word_count * 2;
+
+    for (let i = 0; i < end; i += 2) {
+      // randomBuffer has 256 bits / 16 bits per word == 16 words
+      var num = (randomBuffer[i] << 8) + randomBuffer[i + 1]; // convert into a number between 0 and 1 (inclusive)
+
+      var rndMultiplier = num / Math.pow(2, 16);
+      var wordIndex = Math.round(dictionary_lines.length * rndMultiplier);
+      brainkey.push(dictionary_lines[wordIndex]);
+    }
+
+    return this.normalize_brainKey(brainkey.join(" "));
+  },
+
+  get_random_key(entropy) {
+    return _PrivateKey.default.fromBuffer(this.random32ByteBuffer(entropy));
+  },
+
+  get_brainPrivateKey(brainKey, sequence = 0) {
+    if (sequence < 0) {
+      throw new Error("invalid sequence");
+    }
+
+    if (brainKey.trim() === "") {
+      throw new Error("empty brain key");
+    }
+
+    brainKey = key.normalize_brainKey(brainKey);
+    return _PrivateKey.default.fromBuffer((0, _hash.sha256)((0, _hash.sha512)(brainKey + " " + sequence)));
+  },
+
+  // Turn invisible space like characters into a single space
+  normalize_brainKey(brainKey) {
+    if (!(typeof brainKey === "string")) {
+      throw new Error("string required for brainKey");
+    }
+
+    brainKey = brainKey.trim();
+
+    if (brainKey === "") {
+      throw new Error("empty brain key");
+    }
+
+    return brainKey.split(/[\t\n\v\f\r ]+/).join(" ");
+  },
+
+  browserEntropy() {
+    var entropyStr = "";
+
+    try {
+      entropyStr = new Date().toString() + " " + window.screen.height + " " + window.screen.width + " " + window.screen.colorDepth + " " + " " + window.screen.availHeight + " " + window.screen.availWidth + " " + window.screen.pixelDepth + navigator.language + " " + window.location + " " + window.history.length;
+
+      for (var i = 0, mimeType; i < navigator.mimeTypes.length; i++) {
+        mimeType = navigator.mimeTypes[i];
+        entropyStr += mimeType.description + " " + mimeType.type + " " + mimeType.suffixes + " ";
+      }
+
+      console.log("INFO\tbrowserEntropy gathered");
+    } catch (error) {
+      //nodejs:ReferenceError: window is not defined
+      entropyStr = (0, _hash.sha256)(new Date().toString());
+    }
+
+    var b = Buffer.from(entropyStr);
+    entropyStr += b.toString("binary") + " " + new Date().toString();
+    return entropyStr;
+  },
+
+  // @return array of 5 legacy addresses for a pubkey string parameter.
+  addresses(pubkey, address_prefix = (0, _addressPrefix.getAddressPrefix)()) {
+    var public_key = _PublicKey.default.fromPublicKeyString(pubkey, address_prefix); // S L O W
+
+
+    var address_string = [_address.default.fromPublic(public_key, false, 0).toString(address_prefix), // btc_uncompressed
+    _address.default.fromPublic(public_key, true, 0).toString(address_prefix), // btc_compressed
+    _address.default.fromPublic(public_key, false, 56).toString(address_prefix), // pts_uncompressed
+    _address.default.fromPublic(public_key, true, 56).toString(address_prefix), // pts_compressed
+    public_key.toAddressString(address_prefix) // bts_short, most recent format
+    ];
+    return address_string;
+  }
+
+};
+var _default = key;
+exports.default = _default;

package/claw/node_modules/btsdex-ecc/lib/PrivateKey.js

@@ -0,0 +1,198 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ecurve = require("ecurve");
+
+var _bigi = _interopRequireDefault(require("bigi"));
+
+var _bs = require("bs58");
+
+var _hash = require("./hash");
+
+var _PublicKey = _interopRequireDefault(require("./PublicKey"));
+
+var _deepEqual = _interopRequireDefault(require("deep-equal"));
+
+var _assert = _interopRequireDefault(require("assert"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const secp256k1 = (0, _ecurve.getCurveByName)("secp256k1");
+const {
+  n
+} = secp256k1;
+
+const Buffer = require("safe-buffer").Buffer;
+
+class PrivateKey {
+  /**
+        @private see static functions
+        @param {BigInteger}
+    */
+  constructor(d) {
+    this.d = d;
+  }
+
+  static fromBuffer(buf) {
+    if (!Buffer.isBuffer(buf)) {
+      throw new Error("Expecting paramter to be a Buffer type");
+    }
+
+    if (32 !== buf.length) {
+      console.log(`WARN: Expecting 32 bytes, instead got ${buf.length}, stack trace:`, new Error().stack);
+    }
+
+    if (buf.length === 0) {
+      throw new Error("Empty buffer");
+    }
+
+    return new PrivateKey(_bigi.default.fromBuffer(buf));
+  }
+  /** @arg {string} seed - any length string.  This is private, the same seed produces the same private key every time.  */
+
+
+  static fromSeed(seed) {
+    // generate_private_key
+    if (!(typeof seed === "string")) {
+      throw new Error("seed must be of type string");
+    }
+
+    return PrivateKey.fromBuffer((0, _hash.sha256)(seed));
+  }
+  /** @return {string} Wallet Import Format (still a secret, Not encrypted) */
+
+
+  static fromWif(_private_wif) {
+    var private_wif = Buffer.from((0, _bs.decode)(_private_wif));
+    var version = private_wif.readUInt8(0);
+
+    _assert.default.equal(0x80, version, `Expected version ${0x80}, instead got ${version}`); // checksum includes the version
+
+
+    var private_key = private_wif.slice(0, -4);
+    var checksum = private_wif.slice(-4);
+    var new_checksum = (0, _hash.sha256)(private_key);
+    new_checksum = (0, _hash.sha256)(new_checksum);
+    new_checksum = new_checksum.slice(0, 4);
+    var isEqual = (0, _deepEqual.default)(checksum, new_checksum); //, 'Invalid checksum'
+
+    if (!isEqual) {
+      throw new Error("Checksum did not match");
+    }
+
+    private_key = private_key.slice(1);
+    return PrivateKey.fromBuffer(private_key);
+  }
+
+  toWif() {
+    var private_key = this.toBuffer(); // checksum includes the version
+
+    private_key = Buffer.concat([Buffer.from([0x80]), private_key]);
+    var checksum = (0, _hash.sha256)(private_key);
+    checksum = (0, _hash.sha256)(checksum);
+    checksum = checksum.slice(0, 4);
+    var private_wif = Buffer.concat([private_key, checksum]);
+    return (0, _bs.encode)(private_wif);
+  }
+  /**
+        @return {Point}
+    */
+
+
+  toPublicKeyPoint() {
+    return secp256k1.G.multiply(this.d);
+  }
+
+  toPublicKey() {
+    if (this.public_key) {
+      return this.public_key;
+    }
+
+    return this.public_key = _PublicKey.default.fromPoint(this.toPublicKeyPoint());
+  }
+
+  toBuffer() {
+    return this.d.toBuffer(32);
+  }
+  /** ECIES */
+
+
+  get_shared_secret(public_key, legacy = false) {
+    public_key = toPublic(public_key);
+    let KB = public_key.toUncompressed().toBuffer();
+
+    let KBP = _ecurve.Point.fromAffine(secp256k1, _bigi.default.fromBuffer(KB.slice(1, 33)), // x
+    _bigi.default.fromBuffer(KB.slice(33, 65)) // y
+    );
+
+    let r = this.toBuffer();
+    let P = KBP.multiply(_bigi.default.fromBuffer(r));
+    let S = P.affineX.toBuffer({
+      size: 32
+    });
+    /*
+        the input to sha512 must be exactly 32-bytes, to match the c++ implementation
+        of get_shared_secret.  Right now S will be shorter if the most significant
+        byte(s) is zero.  Pad it back to the full 32-bytes
+        */
+
+    if (!legacy && S.length < 32) {
+      let pad = Buffer.alloc(32 - S.length).fill(0);
+      S = Buffer.concat([pad, S]);
+    } // SHA512 used in ECIES
+
+
+    return (0, _hash.sha512)(S);
+  } // /** ECIES (does not always match the Point.fromAffine version above) */
+  // get_shared_secret(public_key){
+  //     public_key = toPublic(public_key)
+  //     var P = public_key.Q.multiply( this.d );
+  //     var S = P.affineX.toBuffer({size: 32});
+  //     // ECIES, adds an extra sha512
+  //     return sha512(S);
+  // }
+
+  /** @throws {Error} - overflow of the key could not be derived */
+
+
+  child(offset) {
+    offset = Buffer.concat([this.toPublicKey().toBuffer(), offset]);
+    offset = (0, _hash.sha256)(offset);
+
+    let c = _bigi.default.fromBuffer(offset);
+
+    if (c.compareTo(n) >= 0) throw new Error("Child offset went out of bounds, try again");
+    let derived = this.d.add(c); //.mod(n)
+
+    if (derived.signum() === 0) throw new Error("Child offset derived to an invalid key, try again");
+    return new PrivateKey(derived);
+  }
+  /* <helper_functions> */
+
+
+  toByteBuffer() {
+    var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    this.appendByteBuffer(b);
+    return b.copy(0, b.offset);
+  }
+
+  static fromHex(hex) {
+    return PrivateKey.fromBuffer(new Buffer(hex, "hex"));
+  }
+
+  toHex() {
+    return this.toBuffer().toString("hex");
+  }
+  /* </helper_functions> */
+
+
+}
+
+var _default = PrivateKey;
+exports.default = _default;
+
+let toPublic = data => data == null ? data : data.Q ? data : _PublicKey.default.fromStringOrThrow(data);

package/claw/node_modules/btsdex-ecc/lib/PublicKey.js

@@ -0,0 +1,197 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _bigi = _interopRequireDefault(require("bigi"));
+
+var _ecurve = require("ecurve");
+
+var _bs = require("bs58");
+
+var _hash = require("./hash");
+
+var _addressPrefix = require("./addressPrefix");
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var _deepEqual = _interopRequireDefault(require("deep-equal"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const secp256k1 = (0, _ecurve.getCurveByName)("secp256k1");
+
+const Buffer = require("safe-buffer").Buffer;
+
+const {
+  G,
+  n
+} = secp256k1;
+
+class PublicKey {
+  /** @param {Point} public key */
+  constructor(Q) {
+    this.Q = Q;
+  }
+
+  static fromBinary(bin) {
+    return PublicKey.fromBuffer(Buffer.from(bin, "binary"));
+  }
+
+  static fromBuffer(buffer) {
+    if (buffer.toString("hex") === "000000000000000000000000000000000000000000000000000000000000000000") return new PublicKey(null);
+    return new PublicKey(_ecurve.Point.decodeFrom(secp256k1, buffer));
+  }
+
+  toBuffer(compressed = this.Q ? this.Q.compressed : null) {
+    if (this.Q === null) return Buffer.from("000000000000000000000000000000000000000000000000000000000000000000", "hex");
+    return this.Q.getEncoded(compressed);
+  }
+
+  static fromPoint(point) {
+    return new PublicKey(point);
+  }
+
+  toUncompressed() {
+    var buf = this.Q.getEncoded(false);
+
+    var point = _ecurve.Point.decodeFrom(secp256k1, buf);
+
+    return PublicKey.fromPoint(point);
+  }
+  /** bts::blockchain::address (unique but not a full public key) */
+
+
+  toBlockchainAddress() {
+    var pub_buf = this.toBuffer();
+    var pub_sha = (0, _hash.sha512)(pub_buf);
+    return (0, _hash.ripemd160)(pub_sha);
+  }
+  /** Alias for {@link toPublicKeyString} */
+
+
+  toString(address_prefix = (0, _addressPrefix.getAddressPrefix)()) {
+    return this.toPublicKeyString(address_prefix);
+  }
+  /**
+        Full public key
+        {return} string
+    */
+
+
+  toPublicKeyString(address_prefix = (0, _addressPrefix.getAddressPrefix)()) {
+    var pub_buf = this.toBuffer();
+    var checksum = (0, _hash.ripemd160)(pub_buf);
+    var addy = Buffer.concat([pub_buf, checksum.slice(0, 4)]);
+    return address_prefix + (0, _bs.encode)(addy);
+  }
+  /**
+        @arg {string} public_key - like GPHXyz...
+        @arg {string} address_prefix - like GPH
+        @return PublicKey or `null` (if the public_key string is invalid)
+    */
+
+
+  static fromPublicKeyString(public_key, address_prefix = (0, _addressPrefix.getAddressPrefix)()) {
+    try {
+      return PublicKey.fromStringOrThrow(public_key, address_prefix);
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+        @arg {string} public_key - like GPHXyz...
+        @arg {string} address_prefix - like GPH
+        @throws {Error} if public key is invalid
+        @return PublicKey
+    */
+
+
+  static fromStringOrThrow(public_key, address_prefix = (0, _addressPrefix.getAddressPrefix)()) {
+    if (public_key.Q === null) public_key = address_prefix + "1111111111111111111111111111111114T1Anm"; // null key
+
+    var prefix = public_key.slice(0, address_prefix.length);
+
+    _assert.default.equal(address_prefix, prefix, `Expecting key to begin with ${address_prefix}, instead got ${prefix}`);
+
+    public_key = public_key.slice(address_prefix.length);
+    public_key = Buffer.from((0, _bs.decode)(public_key), "binary");
+    var checksum = public_key.slice(-4);
+    public_key = public_key.slice(0, -4);
+    var new_checksum = (0, _hash.ripemd160)(public_key);
+    new_checksum = new_checksum.slice(0, 4);
+    var isEqual = (0, _deepEqual.default)(checksum, new_checksum); //, 'Invalid checksum'
+
+    if (!isEqual) {
+      throw new Error("Checksum did not match");
+    }
+
+    return PublicKey.fromBuffer(public_key);
+  }
+
+  toAddressString(address_prefix = (0, _addressPrefix.getAddressPrefix)()) {
+    var pub_buf = this.toBuffer();
+    var pub_sha = (0, _hash.sha512)(pub_buf);
+    var addy = (0, _hash.ripemd160)(pub_sha);
+    var checksum = (0, _hash.ripemd160)(addy);
+    addy = Buffer.concat([addy, checksum.slice(0, 4)]);
+    return address_prefix + (0, _bs.encode)(addy);
+  }
+
+  toPtsAddy() {
+    var pub_buf = this.toBuffer();
+    var pub_sha = (0, _hash.sha256)(pub_buf);
+    var addy = (0, _hash.ripemd160)(pub_sha);
+    addy = Buffer.concat([Buffer.from([0x38]), addy]); //version 56(decimal)
+
+    var checksum = (0, _hash.sha256)(addy);
+    checksum = (0, _hash.sha256)(checksum);
+    addy = Buffer.concat([addy, checksum.slice(0, 4)]);
+    return (0, _bs.encode)(addy);
+  }
+
+  child(offset) {
+    (0, _assert.default)(Buffer.isBuffer(offset), "Buffer required: offset");
+
+    _assert.default.equal(offset.length, 32, "offset length");
+
+    offset = Buffer.concat([this.toBuffer(), offset]);
+    offset = (0, _hash.sha256)(offset);
+
+    let c = _bigi.default.fromBuffer(offset);
+
+    if (c.compareTo(n) >= 0) throw new Error("Child offset went out of bounds, try again");
+    let cG = G.multiply(c);
+    let Qprime = this.Q.add(cG);
+    if (secp256k1.isInfinity(Qprime)) throw new Error("Child offset derived to an invalid key, try again");
+    return PublicKey.fromPoint(Qprime);
+  }
+  /* <HEX> */
+
+
+  toByteBuffer() {
+    var b = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+    this.appendByteBuffer(b);
+    return b.copy(0, b.offset);
+  }
+
+  static fromHex(hex) {
+    return PublicKey.fromBuffer(Buffer.from(hex, "hex"));
+  }
+
+  toHex() {
+    return this.toBuffer().toString("hex");
+  }
+
+  static fromPublicKeyStringHex(hex) {
+    return PublicKey.fromPublicKeyString(Buffer.from(hex, "hex"));
+  }
+  /* </HEX> */
+
+
+}
+
+var _default = PublicKey;
+exports.default = _default;

package/claw/node_modules/btsdex-ecc/lib/address.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _assert = _interopRequireDefault(require("assert"));
+
+var _addressPrefix = require("./addressPrefix");
+
+var _hash2 = require("./hash");
+
+var _bs = require("bs58");
+
+var _deepEqual = _interopRequireDefault(require("deep-equal"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const Buffer = require("safe-buffer").Buffer;
+/** Addresses are shortened non-reversable hashes of a public key.  The full PublicKey is preferred.
+ */
+
+
+class Address {
+  constructor(addy) {
+    this.addy = addy;
+  }
+
+  static fromBuffer(buffer) {
+    var _hash = (0, _hash2.sha512)(buffer);
+
+    var addy = (0, _hash2.ripemd160)(_hash);
+    return new Address(addy);
+  }
+
+  static fromString(string, address_prefix = (0, _addressPrefix.getAddressPrefix)()) {
+    var prefix = string.slice(0, address_prefix.length);
+
+    _assert.default.equal(address_prefix, prefix, `Expecting key to begin with ${address_prefix}, instead got ${prefix}`);
+
+    var addy = string.slice(address_prefix.length);
+    addy = new Buffer((0, _bs.decode)(addy), "binary");
+    var checksum = addy.slice(-4);
+    addy = addy.slice(0, -4);
+    var new_checksum = (0, _hash2.ripemd160)(addy);
+    new_checksum = new_checksum.slice(0, 4);
+    var isEqual = (0, _deepEqual.default)(checksum, new_checksum); //, 'Invalid checksum'
+
+    if (!isEqual) {
+      throw new Error("Checksum did not match");
+    }
+
+    return new Address(addy);
+  }
+  /** @return Address - Compressed PTS format (by default) */
+
+
+  static fromPublic(public_key, compressed = true, version = 56) {
+    var sha2 = (0, _hash2.sha256)(public_key.toBuffer(compressed));
+    var rep = (0, _hash2.ripemd160)(sha2);
+    var versionBuffer = Buffer.alloc(1);
+    versionBuffer.writeUInt8(0xff & version, 0);
+    var addr = Buffer.concat([versionBuffer, rep]);
+    var check = (0, _hash2.sha256)(addr);
+    check = (0, _hash2.sha256)(check);
+    var buffer = Buffer.concat([addr, check.slice(0, 4)]);
+    return new Address((0, _hash2.ripemd160)(buffer));
+  }
+
+  toBuffer() {
+    return this.addy;
+  }
+
+  toString(address_prefix = (0, _addressPrefix.getAddressPrefix)()) {
+    var checksum = (0, _hash2.ripemd160)(this.addy);
+    var addy = Buffer.concat([this.addy, checksum.slice(0, 4)]);
+    return address_prefix + (0, _bs.encode)(addy);
+  }
+
+}
+
+var _default = Address;
+exports.default = _default;

package/claw/node_modules/btsdex-ecc/lib/addressPrefix.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAddressPrefix = exports.setAddressPrefix = void 0;
+var addressPrefix = "BTS";
+
+const setAddressPrefix = prefix => addressPrefix = prefix;
+
+exports.setAddressPrefix = setAddressPrefix;
+
+const getAddressPrefix = () => addressPrefix;
+
+exports.getAddressPrefix = getAddressPrefix;