hbsig 0.0.1

package/cjs/structured.js

@@ -0,0 +1,296 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.structured_from = structured_from;
+exports.structured_to = structured_to;
+var _erl_str = require("./erl_str.js");
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } /**
+ * Structured field codec for JavaScript-Erlang interoperability
+ * Implements the same behavior as dev_codec_structured.erl
+ */
+/**
+ * Convert from structured format
+ * @param {string|object} input - Erlang term string or JavaScript object
+ * @returns {object} - Processed object
+ */
+function structured_from(input) {
+  // If input is a string (Erlang response), parse it
+  if (typeof input === "string") {
+    return (0, _erl_str.erl_str_from)(input, false);
+  }
+
+  // Otherwise process the object like Erlang's from/1
+  return from(input);
+}
+
+/**
+ * Convert to structured format
+ * @param {*} obj - JavaScript object
+ * @returns {*} - Structured format object
+ */
+function structured_to(obj) {
+  // TODO: Implement the inverse of structured_from
+  return obj;
+}
+
+/**
+ * Check if an array should be converted to numbered map
+ * Rules based on Erlang behavior:
+ * 1. Contains any objects/maps → convert
+ * 2. Contains empty arrays (but NOT empty buffers) → convert
+ * 3. All items are arrays (array of arrays) → convert
+ * 4. Otherwise → encode as string
+ */
+function shouldConvertToNumberedMap(arr) {
+  var allArrays = true;
+  var hasObjects = false;
+  var hasEmptyArrays = false;
+  var _iterator = _createForOfIteratorHelper(arr),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      // Check for objects (not arrays or buffers)
+      if (_typeof(item) === "object" && item !== null && !Array.isArray(item) && !Buffer.isBuffer(item)) {
+        hasObjects = true;
+      }
+      // Check for empty arrays only (NOT empty buffers)
+      else if (Array.isArray(item) && item.length === 0) {
+        hasEmptyArrays = true;
+      }
+      // Track if all items are arrays
+      else if (!Array.isArray(item)) {
+        allArrays = false;
+      }
+    }
+
+    // Convert if: has objects, has empty arrays, or all items are non-empty arrays
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return hasObjects || hasEmptyArrays || allArrays && arr.length > 0 && arr.every(function (item) {
+    return Array.isArray(item);
+  });
+}
+
+/**
+ * Implementation of Erlang's dev_codec_structured:from/1
+ */
+function from(msg) {
+  // Handle non-map values
+  if (msg instanceof Buffer || _typeof(msg) !== "object" || msg === null || Array.isArray(msg)) {
+    return msg;
+  }
+
+  // Normalize keys first
+  var normalizedMap = {};
+  for (var _i = 0, _Object$entries = Object.entries(msg); _i < _Object$entries.length; _i++) {
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+      key = _Object$entries$_i[0],
+      value = _Object$entries$_i[1];
+    var normKey = key.toLowerCase();
+    normalizedMap[normKey] = value;
+  }
+
+  // Get sorted keys (normalized)
+  var sortedKeys = Object.keys(normalizedMap).sort();
+  var types = [];
+  var values = [];
+
+  // Process each key in sorted order
+  var _iterator2 = _createForOfIteratorHelper(sortedKeys),
+    _step2;
+  try {
+    var _loop = function _loop() {
+        var normKey = _step2.value;
+        var value = normalizedMap[normKey];
+
+        // Handle empty values
+        if (value === "" || value instanceof Buffer && value.length === 0) {
+          types.push([normKey, "empty-binary"]);
+          return 0; // continue
+        }
+        if (Array.isArray(value) && value.length === 0) {
+          types.push([normKey, "empty-list"]);
+          return 0; // continue
+        }
+        if (_typeof(value) === "object" && value !== null && !Array.isArray(value) && !(value instanceof Buffer) && Object.keys(value).length === 0) {
+          types.push([normKey, "empty-message"]);
+          return 0; // continue
+        }
+
+        // Handle binary/string values
+        if (value instanceof Buffer || value instanceof Uint8Array) {
+          // Keep buffers as buffers
+          values.push([normKey, value]);
+          return 0; // continue
+        }
+        if (typeof value === "string") {
+          // Keep strings as strings
+          values.push([normKey, value]);
+          return 0; // continue
+        }
+
+        // Handle nested maps
+        if (_typeof(value) === "object" && !Array.isArray(value) && value !== null) {
+          values.push([normKey, from(value)]);
+          return 0; // continue
+        }
+
+        // Handle arrays
+        if (Array.isArray(value) && value.length > 0) {
+          if (shouldConvertToNumberedMap(value)) {
+            // Convert to numbered map (1-based indexing)
+            var numberedMap = {};
+            value.forEach(function (item, idx) {
+              numberedMap[(idx + 1).toString()] = item;
+            });
+            types.push([normKey, "list"]);
+            values.push([normKey, from(numberedMap)]);
+          } else {
+            // Encode as list string
+            var _encodeValue = encodeValue(value),
+              _encodeValue2 = _slicedToArray(_encodeValue, 2),
+              type = _encodeValue2[0],
+              encoded = _encodeValue2[1];
+            types.push([normKey, type]);
+            values.push([normKey, encoded]);
+          }
+          return 0; // continue
+        }
+
+        // Handle typed values (need encoding)
+        if (_typeof(value) === "symbol" || typeof value === "number" || Array.isArray(value) || typeof value === "boolean" || value === null) {
+          var _encodeValue3 = encodeValue(value),
+            _encodeValue4 = _slicedToArray(_encodeValue3, 2),
+            _type = _encodeValue4[0],
+            _encoded = _encodeValue4[1];
+          types.push([normKey, _type]);
+          values.push([normKey, _encoded]);
+          return 0; // continue
+        }
+      },
+      _ret;
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      _ret = _loop();
+      if (_ret === 0) continue;
+    }
+
+    // Build result
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  var result = {};
+
+  // Add ao-types if present
+  if (types.length > 0) {
+    result["ao-types"] = types.map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        k = _ref2[0],
+        t = _ref2[1];
+      return "".concat(k, "=\"").concat(t, "\"");
+    }).join(", ");
+  }
+
+  // Add values (but NOT empty values)
+  for (var _i2 = 0, _values = values; _i2 < _values.length; _i2++) {
+    var _values$_i = _slicedToArray(_values[_i2], 2),
+      k = _values$_i[0],
+      v = _values$_i[1];
+    result[k] = v;
+  }
+  return result;
+}
+
+/**
+ * Encode a value with its type
+ */
+function encodeValue(value) {
+  // Null (as atom)
+  if (value === null) {
+    return ["atom", '"null"'];
+  }
+
+  // Integer
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return ["integer", value.toString()];
+  }
+
+  // Float
+  if (typeof value === "number") {
+    // Format like Erlang with scientific notation
+    var str = value.toExponential(20);
+    // Remove trailing zeros but keep at least one
+    str = str.replace(/(\.\d*?)0+e/, "$1e").replace(/\.e/, ".0e");
+    // Ensure 2-digit exponent
+    str = str.replace(/e([+-])(\d)$/, "e$10$2");
+    return ["float", str];
+  }
+
+  // Boolean (as atom)
+  if (typeof value === "boolean") {
+    return ["atom", "\"".concat(value, "\"")];
+  }
+
+  // Symbol (as atom)
+  if (_typeof(value) === "symbol") {
+    var name = Symbol.keyFor(value) || value.description || "";
+    return ["atom", "\"".concat(name, "\"")];
+  }
+
+  // List
+  if (Array.isArray(value)) {
+    var parts = [];
+    var _iterator3 = _createForOfIteratorHelper(value),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var item = _step3.value;
+        if (item instanceof Buffer) {
+          // Empty buffer => empty string
+          parts.push(item.length === 0 ? '""' : "\"".concat(item.toString(), "\""));
+        } else if (typeof item === "string") {
+          parts.push("\"".concat(item, "\""));
+        } else {
+          var _encodeValue5 = encodeValue(item),
+            _encodeValue6 = _slicedToArray(_encodeValue5, 2),
+            itemType = _encodeValue6[0],
+            itemEncoded = _encodeValue6[1];
+          if (itemType === "list") {
+            // Escape nested list quotes
+            var escaped = itemEncoded.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            parts.push("\"(ao-type-list) ".concat(escaped, "\""));
+          } else if (itemType === "atom") {
+            // Escape atom quotes
+            var _escaped = itemEncoded.replace(/"/g, '\\"');
+            parts.push("\"(ao-type-atom) ".concat(_escaped, "\""));
+          } else {
+            parts.push("\"(ao-type-".concat(itemType, ") ").concat(itemEncoded, "\""));
+          }
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+    return ["list", parts.join(", ")];
+  }
+  if (value instanceof Buffer) {
+    return ["binary", value];
+  }
+  return ["unknown", String(value)];
+}

package/cjs/test.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "acc", {
+  enumerable: true,
+  get: function get() {
+    return _accounts.acc;
+  }
+});
+Object.defineProperty(exports, "toAddr", {
+  enumerable: true,
+  get: function get() {
+    return _utils.toAddr;
+  }
+});
+Object.defineProperty(exports, "wait", {
+  enumerable: true,
+  get: function get() {
+    return _utils.wait;
+  }
+});
+var _fs = require("fs");
+var _path = require("path");
+var _accounts = require("./accounts.js");
+var _utils = require("./utils.js");

package/cjs/utils.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toAddr = toAddr;
+var _fastSha = _interopRequireDefault(require("fast-sha256"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function base64urlDecode(str) {
+  str = str.replace(/-/g, "+").replace(/_/g, "/");
+  var pad = str.length % 4;
+  if (pad === 2) str += "==";else if (pad === 3) str += "=";else if (pad !== 0) throw new Error("Invalid base64url string");
+  var bin = atob(str);
+  var bytes = new Uint8Array(bin.length);
+  for (var i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  return bytes;
+}
+function base64urlEncode(bytes) {
+  var bin = "";
+  var _iterator = _createForOfIteratorHelper(bytes),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var b = _step.value;
+      bin += String.fromCharCode(b);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var b64 = btoa(bin);
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function toAddr(n) {
+  var pubBytes = base64urlDecode(n);
+  var hash = (0, _fastSha["default"])(pubBytes);
+  return base64urlEncode(hash);
+}

package/esm/bin_to_str.js

@@ -0,0 +1,46 @@
+/**
+ * Convert a Buffer to string if it contains valid UTF-8 text
+ * @param {Buffer} buffer - Buffer to check and potentially convert
+ * @returns {string|Buffer} - String if valid UTF-8, otherwise original Buffer
+ */
+export default function bin_to_str(buffer) {
+  if (!Buffer.isBuffer(buffer)) {
+    return buffer
+  }
+
+  // Empty buffer stays as buffer
+  if (buffer.length === 0) {
+    return buffer
+  }
+
+  try {
+    const str = buffer.toString("utf8")
+    // Check if it's valid UTF-8 by seeing if it round-trips correctly
+    if (Buffer.from(str, "utf8").equals(buffer)) {
+      // Additional check: ensure all characters are printable or common whitespace
+      // This prevents converting binary data that happens to be valid UTF-8
+      let isPrintable = true
+      for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i)
+        // Allow printable ASCII (32-126) and common whitespace (tab, newline, carriage return)
+        if (
+          !(code >= 32 && code <= 126) &&
+          code !== 9 &&
+          code !== 10 &&
+          code !== 13
+        ) {
+          isPrintable = false
+          break
+        }
+      }
+
+      if (isPrintable) {
+        return str
+      }
+    }
+  } catch (e) {
+    // Not valid UTF-8, return original buffer
+  }
+
+  return buffer
+}