hbsig 0.0.1

package/esm/signer.js

@@ -0,0 +1,452 @@
+import { httpsig_from, httpsig_to } from "./httpsig.js"
+import { structured_from, structured_to } from "./structured.js"
+import { erl_json_from, erl_json_to, normalize } from "./erl_json.js"
+import { enc } from "./encode.js"
+import { isBytes } from "./encode-utils.js"
+import { createSigner } from "@permaweb/aoconnect"
+import { toHttpSigner } from "./send.js"
+
+// Export verify from signer-utils.js for compatibility
+export { verify } from "./signer-utils.js"
+
+// Helper to check if an array contains binary data
+const arrayHasBinaryData = arr => {
+  if (!Array.isArray(arr)) return false
+
+  return arr.some(item => {
+    if (isBytes(item)) return true
+    if (Array.isArray(item)) return arrayHasBinaryData(item)
+    return false
+  })
+}
+
+// Helper to check if a string contains non-printable characters
+const hasNonPrintableChars = str => {
+  if (typeof str !== "string") return false
+
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i)
+    // Allow only printable ASCII (32-126)
+    // Note: tabs (9), newlines (10), and carriage returns (13) are not allowed in HTTP headers
+    if (code < 32 || code > 126) {
+      return true
+    }
+  }
+  return false
+}
+
+const isValid = encoded => {
+  if (!encoded || typeof encoded !== "object") return false
+
+  // Check if all header values are valid for HTTP headers
+  for (const [key, value] of Object.entries(encoded)) {
+    if (key === "body") {
+      // Body can be string, Buffer, or undefined
+      if (
+        value !== undefined &&
+        typeof value !== "string" &&
+        !Buffer.isBuffer(value)
+      ) {
+        return false
+      }
+    } else {
+      // All other fields (headers) must be strings or numbers
+      if (typeof value !== "string" && typeof value !== "number") {
+        // Check for Buffer in headers - this will fail HTTP signing
+        if (Buffer.isBuffer(value) || isBytes(value)) {
+          return false
+        }
+        return false
+      }
+
+      // Check if string contains non-printable characters
+      if (typeof value === "string" && hasNonPrintableChars(value)) {
+        return false
+      }
+    }
+  }
+
+  return true
+}
+
+// Check if object contains any binary data or arrays with binary data
+const hasBinaryData = obj => {
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "path") continue
+
+    if (isBytes(value)) {
+      return true
+    } else if (Array.isArray(value) && arrayHasBinaryData(value)) {
+      return true
+    } else if (
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value)
+    ) {
+      // Check nested objects
+      for (const [k, v] of Object.entries(value)) {
+        if (isBytes(v)) {
+          return true
+        } else if (Array.isArray(v) && arrayHasBinaryData(v)) {
+          return true
+        }
+      }
+    }
+  }
+  return false
+}
+
+// Helper to check if value is a simple array that should use structured fields
+const isSimpleArray = value => {
+  if (!Array.isArray(value)) return false
+
+  return value.every(item => {
+    // Simple types that can be in structured field lists
+    if (typeof item === "string") return true
+    if (typeof item === "number") return true
+    if (typeof item === "boolean") return true
+    if (isBytes(item)) return true
+
+    // Complex types cannot be in structured field lists
+    if (item && typeof item === "object") return false
+
+    return true
+  })
+}
+
+// Helper to encode array as structured field list
+const encodeAsStructuredFieldList = arr => {
+  return arr
+    .map(item => {
+      if (typeof item === "string") {
+        // String values are quoted
+        return `"${item.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`
+      } else if (typeof item === "number") {
+        // Numbers are bare
+        return String(item)
+      } else if (typeof item === "boolean") {
+        // Booleans use ?0 or ?1
+        return item ? "?1" : "?0"
+      } else if (isBytes(item)) {
+        // Binary data as byte sequences
+        const buffer = Buffer.isBuffer(item) ? item : Buffer.from(item)
+        return `:${buffer.toString("base64")}:`
+      } else {
+        // Fallback
+        return `"${String(item)}"`
+      }
+    })
+    .join(", ")
+}
+
+const smartSign = async (obj, path) => {
+  try {
+    // Filter out undefined values
+    const filtered = filterUndefined(obj)
+
+    // Check if we can encode everything as headers (no multipart needed)
+    let canUseSimpleEncoding = true
+    let hasBodyField = false
+
+    for (const [key, value] of Object.entries(filtered)) {
+      if (key === "path") continue
+
+      // Check if this is the "body" field
+      if (key === "body" || key === "data") {
+        hasBodyField = true
+        // Only use multipart if body/data is actually binary
+        if (isBytes(value)) {
+          canUseSimpleEncoding = false
+          break
+        }
+      }
+
+      // Complex nested objects need multipart
+      if (
+        value &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        !isBytes(value)
+      ) {
+        if (Object.keys(value).length > 0) {
+          canUseSimpleEncoding = false
+          break
+        }
+      }
+
+      // Arrays with complex items need multipart
+      if (Array.isArray(value) && !isSimpleArray(value)) {
+        canUseSimpleEncoding = false
+        break
+      }
+    }
+
+    if (canUseSimpleEncoding) {
+      // Build a simple message that won't trigger multipart
+      const message = { path: path || filtered.path || "/~wao@1.0/httpsig" }
+      const types = []
+
+      for (const [key, value] of Object.entries(filtered)) {
+        if (key === "path") continue
+
+        if (value === "") {
+          types.push(`${key}="empty-binary"`)
+        } else if (Array.isArray(value) && value.length === 0) {
+          types.push(`${key}="empty-list"`)
+        } else if (
+          value &&
+          typeof value === "object" &&
+          Object.keys(value).length === 0
+        ) {
+          types.push(`${key}="empty-message"`)
+        } else if (isSimpleArray(value)) {
+          types.push(`${key}="list"`)
+          message[key] = encodeAsStructuredFieldList(value)
+        } else if (typeof value === "number") {
+          types.push(
+            `${key}="${Number.isInteger(value) ? "integer" : "float"}"`
+          )
+          message[key] = String(value)
+        } else if (typeof value === "boolean") {
+          types.push(`${key}="atom"`)
+          message[key] = String(value)
+        } else if (value === null || value === undefined) {
+          types.push(`${key}="atom"`)
+          message[key] = String(value)
+        } else if (typeof value === "string") {
+          message[key] = value
+        }
+      }
+
+      if (types.length > 0) {
+        message["ao-types"] = types.join(", ")
+      }
+
+      return httpsig_to(message)
+    }
+
+    // For complex structures that need multipart, use enc()
+    const normalized = normalize({
+      ...filtered,
+      path: path || "/~wao@1.0/httpsig",
+    })
+    const result = await enc(normalized)
+
+    // enc() returns { headers: {...}, body: ... }
+    // We need to flatten this for httpsig_to
+    const flattened = {
+      ...result.headers,
+      body: result.body,
+      path: normalized.path || path || "/~wao@1.0/httpsig",
+    }
+
+    // httpsig_to expects the structured format
+    const encoded = httpsig_to(flattened)
+
+    return encoded
+  } catch (error) {
+    console.error("Encoding failed:", error)
+
+    // Fallback: create a simple structure
+    const result = { path: path || "/~wao@1.0/httpsig" }
+
+    for (const [key, value] of Object.entries(obj)) {
+      if (key === "path") continue
+
+      if (!isBytes(value) && value !== undefined) {
+        result[key] = value
+      }
+    }
+
+    return result
+  }
+}
+
+// Internal sign function that matches the original signature
+const _sign = async (obj, path) => {
+  // Filter out undefined values before processing
+  const filtered = filterUndefined(obj)
+
+  // If object contains binary data, use enc() directly
+  if (hasBinaryData(filtered)) {
+    return await smartSign(filtered, path)
+  }
+
+  // Otherwise use the standard pipeline
+  const encoded = httpsig_to(
+    normalize(
+      structured_from(
+        normalize({ ...filtered, path: path || "/~wao@1.0/httpsig" })
+      )
+    )
+  )
+
+  // Check if the encoded result is valid for HTTP headers
+  if (!isValid(encoded)) {
+    return await smartSign(filtered, path)
+  }
+
+  return encoded
+}
+
+// Helper to join URL and path
+const joinUrl = ({ url, path }) => {
+  if (path.startsWith("http://") || path.startsWith("https://")) return path
+  const normalizedPath = path.startsWith("/") ? path : "/" + path
+  return url.endsWith("/")
+    ? url.slice(0, -1) + normalizedPath
+    : url + normalizedPath
+}
+
+// Main sign function that matches signer.js API
+export async function sign({ url, path, msg: encoded, jwk, signPath = true }) {
+  const signer = createSigner(jwk, url)
+  const { body = null, ...headers } = encoded
+  let _enc = { headers }
+  if (body) _enc.body = new Blob([body])
+
+  const headersObj = _enc.headers || {}
+  const bodyData = _enc.body || undefined
+  let url_path = typeof signPath === "string" ? signPath : path
+  const _url = joinUrl({ url, path: url_path })
+
+  headersObj["path"] = path
+  if (bodyData && !headersObj["content-length"]) {
+    const bodySize = bodyData.size || bodyData.byteLength || 0
+    if (bodySize > 0) headersObj["content-length"] = String(bodySize)
+  }
+
+  const lowercaseHeaders = {}
+  for (const [key, value] of Object.entries(headersObj)) {
+    lowercaseHeaders[key.toLowerCase()] = value
+  }
+
+  const bodyKeys = headersObj["body-keys"]
+    ? headersObj["body-keys"]
+        .replace(/"/g, "")
+        .split(",")
+        .map(k => k.trim())
+    : []
+
+  let isPath = false
+  const signingFields = Object.keys(lowercaseHeaders).filter(key => {
+    if (key === "path") isPath = true
+    return key !== "body-keys" && key !== "path" && !bodyKeys.includes(key)
+  })
+
+  if (signPath !== false && isPath) signingFields.push("@path")
+
+  const signedRequest = await toHttpSigner(signer)({
+    request: { url: _url, method: "POST", headers: lowercaseHeaders },
+    fields: signingFields,
+  })
+
+  const finalHeaders = {}
+  for (const [key, value] of Object.entries(headersObj)) {
+    finalHeaders[key] = value
+  }
+
+  finalHeaders["signature"] = signedRequest.headers["signature"]
+  finalHeaders["signature-input"] = signedRequest.headers["signature-input"]
+
+  if (headersObj["body-keys"]) {
+    finalHeaders["body-keys"] = headersObj["body-keys"]
+  }
+
+  const result = { url: _url, method: "POST", headers: finalHeaders }
+  if (bodyData) result.body = bodyData
+
+  return result
+}
+
+// Helper function to recursively filter out undefined values
+const filterUndefined = obj => {
+  if (obj === null || obj === undefined) return obj
+  if (Array.isArray(obj)) {
+    return obj.map(filterUndefined).filter(item => item !== undefined)
+  }
+  if (typeof obj === "object" && obj.constructor === Object) {
+    const filtered = {}
+    for (const [key, value] of Object.entries(obj)) {
+      const filteredValue = filterUndefined(value)
+      if (filteredValue !== undefined) {
+        filtered[key] = filteredValue
+      }
+    }
+    return filtered
+  }
+  return obj
+}
+
+// Signer factory function that matches signer.js API
+export function signer(config) {
+  const { signer, url = "http://localhost:10001" } = config
+  if (!signer) throw new Error("Signer is required for mainnet mode")
+
+  return async (
+    fields,
+    { encoded: _encoded = false, path: _path = true } = {}
+  ) => {
+    const { path = "/relay/process", method = "POST", ...aoFields } = fields
+
+    // Filter out undefined values before encoding
+    const filteredFields = filterUndefined(aoFields)
+    const encoded = _encoded ? filteredFields : await enc(filteredFields)
+
+    const headersObj = encoded ? encoded.headers : {}
+    const body = encoded ? encoded.body : undefined
+    let url_path = typeof _path === "string" ? _path : path
+    const _url = joinUrl({ url, path: url_path })
+
+    headersObj["path"] = path
+    if (body && !headersObj["content-length"]) {
+      const bodySize = body.size || body.byteLength || 0
+      if (bodySize > 0) headersObj["content-length"] = String(bodySize)
+    }
+
+    const lowercaseHeaders = {}
+    for (const [key, value] of Object.entries(headersObj)) {
+      lowercaseHeaders[key.toLowerCase()] = value
+    }
+
+    const bodyKeys = headersObj["body-keys"]
+      ? headersObj["body-keys"]
+          .replace(/"/g, "")
+          .split(",")
+          .map(k => k.trim())
+      : []
+
+    let isPath = false
+    const signingFields = Object.keys(lowercaseHeaders).filter(key => {
+      if (key === "path") isPath = true
+      return key !== "body-keys" && key !== "path" && !bodyKeys.includes(key)
+    })
+
+    if (_path !== false && isPath) signingFields.push("@path")
+
+    const signedRequest = await toHttpSigner(signer)({
+      request: { url: _url, method, headers: lowercaseHeaders },
+      fields: signingFields,
+    })
+
+    const finalHeaders = {}
+    for (const [key, value] of Object.entries(headersObj)) {
+      finalHeaders[key] = value
+    }
+
+    finalHeaders["signature"] = signedRequest.headers["signature"]
+    finalHeaders["signature-input"] = signedRequest.headers["signature-input"]
+
+    if (headersObj["body-keys"]) {
+      finalHeaders["body-keys"] = headersObj["body-keys"]
+    }
+
+    const result = { url: _url, method, headers: finalHeaders }
+    if (body) result.body = body
+
+    return result
+  }
+}
+
+// Export the internal sign function for backward compatibility
+export { _sign as signInternal }

package/esm/structured.js

@@ -0,0 +1,269 @@
+/**
+ * Structured field codec for JavaScript-Erlang interoperability
+ * Implements the same behavior as dev_codec_structured.erl
+ */
+
+import { erl_str_from } from "./erl_str.js"
+
+/**
+ * Convert from structured format
+ * @param {string|object} input - Erlang term string or JavaScript object
+ * @returns {object} - Processed object
+ */
+export function structured_from(input) {
+  // If input is a string (Erlang response), parse it
+  if (typeof input === "string") {
+    return 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
+ */
+export 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) {
+  let allArrays = true
+  let hasObjects = false
+  let hasEmptyArrays = false
+
+  for (const item of arr) {
+    // 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
+  return (
+    hasObjects ||
+    hasEmptyArrays ||
+    (allArrays && arr.length > 0 && arr.every(item => 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
+  const normalizedMap = {}
+  for (const [key, value] of Object.entries(msg)) {
+    const normKey = key.toLowerCase()
+    normalizedMap[normKey] = value
+  }
+
+  // Get sorted keys (normalized)
+  const sortedKeys = Object.keys(normalizedMap).sort()
+
+  const types = []
+  const values = []
+
+  // Process each key in sorted order
+  for (const normKey of sortedKeys) {
+    const value = normalizedMap[normKey]
+
+    // Handle empty values
+    if (value === "" || (value instanceof Buffer && value.length === 0)) {
+      types.push([normKey, "empty-binary"])
+      continue
+    }
+
+    if (Array.isArray(value) && value.length === 0) {
+      types.push([normKey, "empty-list"])
+      continue
+    }
+
+    if (
+      typeof value === "object" &&
+      value !== null &&
+      !Array.isArray(value) &&
+      !(value instanceof Buffer) &&
+      Object.keys(value).length === 0
+    ) {
+      types.push([normKey, "empty-message"])
+      continue
+    }
+
+    // Handle binary/string values
+    if (value instanceof Buffer || value instanceof Uint8Array) {
+      // Keep buffers as buffers
+      values.push([normKey, value])
+      continue
+    }
+
+    if (typeof value === "string") {
+      // Keep strings as strings
+      values.push([normKey, value])
+      continue
+    }
+
+    // Handle nested maps
+    if (typeof value === "object" && !Array.isArray(value) && value !== null) {
+      values.push([normKey, from(value)])
+      continue
+    }
+
+    // Handle arrays
+    if (Array.isArray(value) && value.length > 0) {
+      if (shouldConvertToNumberedMap(value)) {
+        // Convert to numbered map (1-based indexing)
+        const numberedMap = {}
+        value.forEach((item, idx) => {
+          numberedMap[(idx + 1).toString()] = item
+        })
+        types.push([normKey, "list"])
+        values.push([normKey, from(numberedMap)])
+      } else {
+        // Encode as list string
+        const [type, encoded] = encodeValue(value)
+        types.push([normKey, type])
+        values.push([normKey, encoded])
+      }
+      continue
+    }
+
+    // Handle typed values (need encoding)
+    if (
+      typeof value === "symbol" ||
+      typeof value === "number" ||
+      Array.isArray(value) ||
+      typeof value === "boolean" ||
+      value === null
+    ) {
+      const [type, encoded] = encodeValue(value)
+      types.push([normKey, type])
+      values.push([normKey, encoded])
+      continue
+    }
+  }
+
+  // Build result
+  const result = {}
+
+  // Add ao-types if present
+  if (types.length > 0) {
+    result["ao-types"] = types.map(([k, t]) => `${k}="${t}"`).join(", ")
+  }
+
+  // Add values (but NOT empty values)
+  for (const [k, v] of values) {
+    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
+    let 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", `"${value}"`]
+  }
+
+  // Symbol (as atom)
+  if (typeof value === "symbol") {
+    const name = Symbol.keyFor(value) || value.description || ""
+    return ["atom", `"${name}"`]
+  }
+
+  // List
+  if (Array.isArray(value)) {
+    const parts = []
+
+    for (const item of value) {
+      if (item instanceof Buffer) {
+        // Empty buffer => empty string
+        parts.push(item.length === 0 ? '""' : `"${item.toString()}"`)
+      } else if (typeof item === "string") {
+        parts.push(`"${item}"`)
+      } else {
+        const [itemType, itemEncoded] = encodeValue(item)
+
+        if (itemType === "list") {
+          // Escape nested list quotes
+          const escaped = itemEncoded
+            .replace(/\\/g, "\\\\")
+            .replace(/"/g, '\\"')
+          parts.push(`"(ao-type-list) ${escaped}"`)
+        } else if (itemType === "atom") {
+          // Escape atom quotes
+          const escaped = itemEncoded.replace(/"/g, '\\"')
+          parts.push(`"(ao-type-atom) ${escaped}"`)
+        } else {
+          parts.push(`"(ao-type-${itemType}) ${itemEncoded}"`)
+        }
+      }
+    }
+
+    return ["list", parts.join(", ")]
+  }
+
+  if (value instanceof Buffer) {
+    return ["binary", value]
+  }
+
+  return ["unknown", String(value)]
+}