@certik/skynet 0.20.2 → 0.22.0

package/dist/opsgenie.js

@@ -0,0 +1,320 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// node_modules/crypt/crypt.js
+var require_crypt = __commonJS((exports, module) => {
+  (function() {
+    var base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", crypt = {
+      rotl: function(n, b) {
+        return n << b | n >>> 32 - b;
+      },
+      rotr: function(n, b) {
+        return n << 32 - b | n >>> b;
+      },
+      endian: function(n) {
+        if (n.constructor == Number) {
+          return crypt.rotl(n, 8) & 16711935 | crypt.rotl(n, 24) & 4278255360;
+        }
+        for (var i = 0;i < n.length; i++)
+          n[i] = crypt.endian(n[i]);
+        return n;
+      },
+      randomBytes: function(n) {
+        for (var bytes = [];n > 0; n--)
+          bytes.push(Math.floor(Math.random() * 256));
+        return bytes;
+      },
+      bytesToWords: function(bytes) {
+        for (var words = [], i = 0, b = 0;i < bytes.length; i++, b += 8)
+          words[b >>> 5] |= bytes[i] << 24 - b % 32;
+        return words;
+      },
+      wordsToBytes: function(words) {
+        for (var bytes = [], b = 0;b < words.length * 32; b += 8)
+          bytes.push(words[b >>> 5] >>> 24 - b % 32 & 255);
+        return bytes;
+      },
+      bytesToHex: function(bytes) {
+        for (var hex = [], i = 0;i < bytes.length; i++) {
+          hex.push((bytes[i] >>> 4).toString(16));
+          hex.push((bytes[i] & 15).toString(16));
+        }
+        return hex.join("");
+      },
+      hexToBytes: function(hex) {
+        for (var bytes = [], c = 0;c < hex.length; c += 2)
+          bytes.push(parseInt(hex.substr(c, 2), 16));
+        return bytes;
+      },
+      bytesToBase64: function(bytes) {
+        for (var base64 = [], i = 0;i < bytes.length; i += 3) {
+          var triplet = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+          for (var j = 0;j < 4; j++)
+            if (i * 8 + j * 6 <= bytes.length * 8)
+              base64.push(base64map.charAt(triplet >>> 6 * (3 - j) & 63));
+            else
+              base64.push("=");
+        }
+        return base64.join("");
+      },
+      base64ToBytes: function(base64) {
+        base64 = base64.replace(/[^A-Z0-9+\/]/ig, "");
+        for (var bytes = [], i = 0, imod4 = 0;i < base64.length; imod4 = ++i % 4) {
+          if (imod4 == 0)
+            continue;
+          bytes.push((base64map.indexOf(base64.charAt(i - 1)) & Math.pow(2, -2 * imod4 + 8) - 1) << imod4 * 2 | base64map.indexOf(base64.charAt(i)) >>> 6 - imod4 * 2);
+        }
+        return bytes;
+      }
+    };
+    module.exports = crypt;
+  })();
+});
+
+// node_modules/charenc/charenc.js
+var require_charenc = __commonJS((exports, module) => {
+  var charenc = {
+    utf8: {
+      stringToBytes: function(str) {
+        return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
+      },
+      bytesToString: function(bytes) {
+        return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
+      }
+    },
+    bin: {
+      stringToBytes: function(str) {
+        for (var bytes = [], i = 0;i < str.length; i++)
+          bytes.push(str.charCodeAt(i) & 255);
+        return bytes;
+      },
+      bytesToString: function(bytes) {
+        for (var str = [], i = 0;i < bytes.length; i++)
+          str.push(String.fromCharCode(bytes[i]));
+        return str.join("");
+      }
+    }
+  };
+  module.exports = charenc;
+});
+
+// node_modules/is-buffer/index.js
+var require_is_buffer = __commonJS((exports, module) => {
+  /*!
+   * Determine if an object is a Buffer
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   */
+  module.exports = function(obj) {
+    return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+  };
+  function isBuffer(obj) {
+    return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+  }
+  function isSlowBuffer(obj) {
+    return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer(obj.slice(0, 0));
+  }
+});
+
+// node_modules/md5/md5.js
+var require_md5 = __commonJS((exports, module) => {
+  (function() {
+    var crypt = require_crypt(), utf8 = require_charenc().utf8, isBuffer = require_is_buffer(), bin = require_charenc().bin, md5 = function(message, options) {
+      if (message.constructor == String)
+        if (options && options.encoding === "binary")
+          message = bin.stringToBytes(message);
+        else
+          message = utf8.stringToBytes(message);
+      else if (isBuffer(message))
+        message = Array.prototype.slice.call(message, 0);
+      else if (!Array.isArray(message) && message.constructor !== Uint8Array)
+        message = message.toString();
+      var m = crypt.bytesToWords(message), l = message.length * 8, a = 1732584193, b = -271733879, c = -1732584194, d = 271733878;
+      for (var i = 0;i < m.length; i++) {
+        m[i] = (m[i] << 8 | m[i] >>> 24) & 16711935 | (m[i] << 24 | m[i] >>> 8) & 4278255360;
+      }
+      m[l >>> 5] |= 128 << l % 32;
+      m[(l + 64 >>> 9 << 4) + 14] = l;
+      var { _ff: FF, _gg: GG, _hh: HH, _ii: II } = md5;
+      for (var i = 0;i < m.length; i += 16) {
+        var aa = a, bb = b, cc = c, dd = d;
+        a = FF(a, b, c, d, m[i + 0], 7, -680876936);
+        d = FF(d, a, b, c, m[i + 1], 12, -389564586);
+        c = FF(c, d, a, b, m[i + 2], 17, 606105819);
+        b = FF(b, c, d, a, m[i + 3], 22, -1044525330);
+        a = FF(a, b, c, d, m[i + 4], 7, -176418897);
+        d = FF(d, a, b, c, m[i + 5], 12, 1200080426);
+        c = FF(c, d, a, b, m[i + 6], 17, -1473231341);
+        b = FF(b, c, d, a, m[i + 7], 22, -45705983);
+        a = FF(a, b, c, d, m[i + 8], 7, 1770035416);
+        d = FF(d, a, b, c, m[i + 9], 12, -1958414417);
+        c = FF(c, d, a, b, m[i + 10], 17, -42063);
+        b = FF(b, c, d, a, m[i + 11], 22, -1990404162);
+        a = FF(a, b, c, d, m[i + 12], 7, 1804603682);
+        d = FF(d, a, b, c, m[i + 13], 12, -40341101);
+        c = FF(c, d, a, b, m[i + 14], 17, -1502002290);
+        b = FF(b, c, d, a, m[i + 15], 22, 1236535329);
+        a = GG(a, b, c, d, m[i + 1], 5, -165796510);
+        d = GG(d, a, b, c, m[i + 6], 9, -1069501632);
+        c = GG(c, d, a, b, m[i + 11], 14, 643717713);
+        b = GG(b, c, d, a, m[i + 0], 20, -373897302);
+        a = GG(a, b, c, d, m[i + 5], 5, -701558691);
+        d = GG(d, a, b, c, m[i + 10], 9, 38016083);
+        c = GG(c, d, a, b, m[i + 15], 14, -660478335);
+        b = GG(b, c, d, a, m[i + 4], 20, -405537848);
+        a = GG(a, b, c, d, m[i + 9], 5, 568446438);
+        d = GG(d, a, b, c, m[i + 14], 9, -1019803690);
+        c = GG(c, d, a, b, m[i + 3], 14, -187363961);
+        b = GG(b, c, d, a, m[i + 8], 20, 1163531501);
+        a = GG(a, b, c, d, m[i + 13], 5, -1444681467);
+        d = GG(d, a, b, c, m[i + 2], 9, -51403784);
+        c = GG(c, d, a, b, m[i + 7], 14, 1735328473);
+        b = GG(b, c, d, a, m[i + 12], 20, -1926607734);
+        a = HH(a, b, c, d, m[i + 5], 4, -378558);
+        d = HH(d, a, b, c, m[i + 8], 11, -2022574463);
+        c = HH(c, d, a, b, m[i + 11], 16, 1839030562);
+        b = HH(b, c, d, a, m[i + 14], 23, -35309556);
+        a = HH(a, b, c, d, m[i + 1], 4, -1530992060);
+        d = HH(d, a, b, c, m[i + 4], 11, 1272893353);
+        c = HH(c, d, a, b, m[i + 7], 16, -155497632);
+        b = HH(b, c, d, a, m[i + 10], 23, -1094730640);
+        a = HH(a, b, c, d, m[i + 13], 4, 681279174);
+        d = HH(d, a, b, c, m[i + 0], 11, -358537222);
+        c = HH(c, d, a, b, m[i + 3], 16, -722521979);
+        b = HH(b, c, d, a, m[i + 6], 23, 76029189);
+        a = HH(a, b, c, d, m[i + 9], 4, -640364487);
+        d = HH(d, a, b, c, m[i + 12], 11, -421815835);
+        c = HH(c, d, a, b, m[i + 15], 16, 530742520);
+        b = HH(b, c, d, a, m[i + 2], 23, -995338651);
+        a = II(a, b, c, d, m[i + 0], 6, -198630844);
+        d = II(d, a, b, c, m[i + 7], 10, 1126891415);
+        c = II(c, d, a, b, m[i + 14], 15, -1416354905);
+        b = II(b, c, d, a, m[i + 5], 21, -57434055);
+        a = II(a, b, c, d, m[i + 12], 6, 1700485571);
+        d = II(d, a, b, c, m[i + 3], 10, -1894986606);
+        c = II(c, d, a, b, m[i + 10], 15, -1051523);
+        b = II(b, c, d, a, m[i + 1], 21, -2054922799);
+        a = II(a, b, c, d, m[i + 8], 6, 1873313359);
+        d = II(d, a, b, c, m[i + 15], 10, -30611744);
+        c = II(c, d, a, b, m[i + 6], 15, -1560198380);
+        b = II(b, c, d, a, m[i + 13], 21, 1309151649);
+        a = II(a, b, c, d, m[i + 4], 6, -145523070);
+        d = II(d, a, b, c, m[i + 11], 10, -1120210379);
+        c = II(c, d, a, b, m[i + 2], 15, 718787259);
+        b = II(b, c, d, a, m[i + 9], 21, -343485551);
+        a = a + aa >>> 0;
+        b = b + bb >>> 0;
+        c = c + cc >>> 0;
+        d = d + dd >>> 0;
+      }
+      return crypt.endian([a, b, c, d]);
+    };
+    md5._ff = function(a, b, c, d, x, s, t) {
+      var n = a + (b & c | ~b & d) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._gg = function(a, b, c, d, x, s, t) {
+      var n = a + (b & d | c & ~d) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._hh = function(a, b, c, d, x, s, t) {
+      var n = a + (b ^ c ^ d) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._ii = function(a, b, c, d, x, s, t) {
+      var n = a + (c ^ (b | ~d)) + (x >>> 0) + t;
+      return (n << s | n >>> 32 - s) + b;
+    };
+    md5._blocksize = 16;
+    md5._digestsize = 16;
+    module.exports = function(message, options) {
+      if (message === undefined || message === null)
+        throw new Error("Illegal argument " + message);
+      var digestbytes = crypt.wordsToBytes(md5(message, options));
+      return options && options.asBytes ? digestbytes : options && options.asString ? bin.bytesToString(digestbytes) : crypt.bytesToHex(digestbytes);
+    };
+  })();
+});
+
+// opsgenie.ts
+var import_md5 = __toESM(require_md5(), 1);
+function getGenieKey(key) {
+  return key || process.env["SKYNET_OPSGENIE_API_KEY"];
+}
+function getGenieEndPoint() {
+  return process.env["SKYNET_OPSGENIE_END_POINT"] || "https://api.opsgenie.com/v2/alerts";
+}
+async function postGenieMessage(body, apiKey, verbose) {
+  try {
+    const genieKey = apiKey || getGenieKey();
+    const genieEndPoint = getGenieEndPoint();
+    if (!body.alias) {
+      body.alias = import_md5.default(body.message);
+    }
+    if (verbose) {
+      console.log(`Making API call to Opsgenie`, JSON.stringify(body, null, 2));
+    }
+    const response = await fetch(genieEndPoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `GenieKey ${genieKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    const result = await response.json();
+    if (verbose) {
+      console.log(`Result of API call to Opsgenie... ${result}`);
+    }
+    return result;
+  } catch (error) {
+    console.error("Failed to make opsgenie API call", error);
+    throw error;
+  }
+}
+export {
+  postGenieMessage
+};

package/dist/por.d.ts

@@ -0,0 +1,38 @@
+export interface UserLiability {
+    userHash: string;
+    balance: number;
+    token?: string;
+}
+export interface MerkleProof {
+    userHash: string;
+    balance: number;
+    token?: string;
+    proof: string[];
+    positions: ('left' | 'right')[];
+    rootHash: string;
+    leafIndex: number;
+    hashFunction?: (data: string) => string;
+}
+export interface MerkleNode {
+    hash: string;
+    left?: MerkleNode;
+    right?: MerkleNode;
+    data?: UserLiability;
+}
+export declare class MerkleTreePoR {
+    private leaves;
+    private tree;
+    private userMap;
+    private userData;
+    private hashFunction;
+    constructor(users: UserLiability[], hashFunction?: (data: string) => string);
+    private static defaultSHA256Hash;
+    private defaultSHA256Hash;
+    private hash;
+    private createLeafHash;
+    private buildTree;
+    getRootHash(): string;
+    generateProof(userHash: string, token?: string): MerkleProof;
+    static verifyProof(merkleProof: MerkleProof): boolean;
+}
+//# sourceMappingURL=por.d.ts.map

package/dist/por.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"por.d.ts","sourceRoot":"","sources":["../por.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,EAAE,CAAC,MAAM,GAAG,OAAO,CAAC,EAAE,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;CACzC;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,IAAI,CAAsB;IAClC,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,YAAY,CAA2B;gBAEnC,KAAK,EAAE,aAAa,EAAE,EAAE,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;IAO3E,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAMhC,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,IAAI;IAMZ,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,SAAS;IAgDjB,WAAW,IAAI,MAAM;IAQrB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,WAAW;IA4C5D,MAAM,CAAC,WAAW,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO;CAkBtD"}

package/dist/por.js

@@ -0,0 +1,164 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// por.ts
+var {CryptoHasher } = globalThis.Bun;
+
+class MerkleTreePoR {
+  leaves = [];
+  tree = [];
+  userMap = new Map;
+  userData = [];
+  hashFunction;
+  constructor(users, hashFunction) {
+    this.userData = [...users];
+    this.hashFunction = hashFunction || this.defaultSHA256Hash;
+    this.buildTree();
+  }
+  static defaultSHA256Hash(data) {
+    const hasher = new CryptoHasher("sha256");
+    hasher.update(data);
+    return hasher.digest("hex");
+  }
+  defaultSHA256Hash(data) {
+    return MerkleTreePoR.defaultSHA256Hash(data);
+  }
+  hash(data) {
+    return this.hashFunction(data);
+  }
+  createLeafHash(user) {
+    const leafData = `${user.userHash}:${user.balance}:${user.token || ""}`;
+    return this.hash(leafData);
+  }
+  buildTree() {
+    if (this.userData.length === 0) {
+      throw new Error("Cannot build tree with empty user data");
+    }
+    this.leaves = this.userData.map((user, index) => {
+      const leafHash = this.createLeafHash(user);
+      this.userMap.set(`${user.userHash}:${user.token || ""}`, index);
+      return leafHash;
+    });
+    let currentLevel = this.leaves;
+    this.tree.push(currentLevel.map((hash) => ({ hash })));
+    while (currentLevel.length > 1) {
+      const nextLevel = [];
+      const nextLevelNodes = [];
+      for (let i = 0;i < currentLevel.length; i += 2) {
+        const left = currentLevel[i];
+        const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : left;
+        const parentHash = this.hash(left + right);
+        nextLevel.push(parentHash);
+        const leftNode = this.tree[this.tree.length - 1][i];
+        const rightNode = i + 1 < currentLevel.length ? this.tree[this.tree.length - 1][i + 1] : leftNode;
+        nextLevelNodes.push({
+          hash: parentHash,
+          left: leftNode,
+          right: rightNode
+        });
+      }
+      currentLevel = nextLevel;
+      this.tree.push(nextLevelNodes);
+    }
+  }
+  getRootHash() {
+    if (this.tree.length === 0) {
+      throw new Error("Merkle tree not built");
+    }
+    return this.tree[this.tree.length - 1][0].hash;
+  }
+  generateProof(userHash, token) {
+    const key = `${userHash}:${token || ""}`;
+    const leafIndex = this.userMap.get(key);
+    if (leafIndex === undefined) {
+      throw new Error(`${userHash} not found in merkle tree for token ${token}`);
+    }
+    const user = this.userData[leafIndex];
+    const proof = [];
+    const positions = [];
+    let currentIndex = leafIndex;
+    for (let level = 0;level < this.tree.length - 1; level++) {
+      const currentLevelSize = this.tree[level].length;
+      const isRightNode = currentIndex % 2 === 1;
+      const siblingIndex = isRightNode ? currentIndex - 1 : currentIndex + 1;
+      if (siblingIndex < currentLevelSize) {
+        proof.push(this.tree[level][siblingIndex].hash);
+        positions.push(isRightNode ? "left" : "right");
+      } else {
+        proof.push(this.tree[level][currentIndex].hash);
+        positions.push(isRightNode ? "left" : "right");
+      }
+      currentIndex = Math.floor(currentIndex / 2);
+    }
+    return {
+      userHash: user.userHash,
+      balance: user.balance,
+      token: user.token,
+      proof,
+      positions,
+      rootHash: this.getRootHash(),
+      leafIndex,
+      hashFunction: this.hashFunction !== this.defaultSHA256Hash ? this.hashFunction : undefined
+    };
+  }
+  static verifyProof(merkleProof) {
+    const leafData = `${merkleProof.userHash}:${merkleProof.balance}:${merkleProof.token || ""}`;
+    const hashFunction = merkleProof.hashFunction || MerkleTreePoR.defaultSHA256Hash;
+    let currentHash = hashFunction(leafData);
+    for (let i = 0;i < merkleProof.proof.length; i++) {
+      const siblingHash = merkleProof.proof[i];
+      const position = merkleProof.positions[i];
+      if (position === "left") {
+        currentHash = hashFunction(siblingHash + currentHash);
+      } else {
+        currentHash = hashFunction(currentHash + siblingHash);
+      }
+    }
+    return currentHash === merkleProof.rootHash;
+  }
+}
+export {
+  MerkleTreePoR
+};

package/dist/s3.d.ts

@@ -0,0 +1,21 @@
+import { S3Client, ObjectCannedACL } from "@aws-sdk/client-s3";
+declare function getS3(forceNew?: boolean): S3Client;
+declare function readFile(bucketName: string, key: string, verbose?: boolean): Promise<string>;
+declare function hasFile(bucketName: string, key: string): Promise<boolean>;
+declare function getFileSize(bucketName: string, key: string): Promise<number>;
+declare function writeFile(bucketName: string, key: string, body: string, options?: {
+    verbose?: boolean;
+    skipIfExists?: boolean;
+    acl?: ObjectCannedACL;
+    contentType?: string;
+}): Promise<void>;
+declare function deleteFile(bucketName: string, key: string, verbose?: boolean): Promise<any>;
+declare function listKeys(bucketName: string, prefix?: string, continuationToken?: string): Promise<{
+    keys: any[];
+    continuationToken?: undefined;
+} | {
+    keys: string[];
+    continuationToken: string;
+}>;
+export { getS3, hasFile, readFile, writeFile, deleteFile, getFileSize, listKeys };
+//# sourceMappingURL=s3.d.ts.map

package/dist/s3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"s3.d.ts","sourceRoot":"","sources":["../s3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQR,eAAe,EAChB,MAAM,oBAAoB,CAAC;AAK5B,iBAAS,KAAK,CAAC,QAAQ,UAAQ,YAK9B;AAED,iBAAe,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,UAAQ,mBAmBvE;AAED,iBAAe,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,oBAcrD;AAED,iBAAe,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,mBAUzD;AAED,iBAAe,SAAS,CACtB,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IACP,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,GAAG,CAAC,EAAE,eAAe,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;CACjB,iBA2BP;AAED,iBAAe,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,UAAQ,gBAkBzE;AAED,iBAAe,QAAQ,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,MAAM;;;;;;GA4BtF;AAED,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC"}