@hodlmarkets/sdk 0.1.0 → 0.1.2

package/dist/events.js

@@ -1,6 +1,240 @@
-import { BorshCoder, EventParser } from '@coral-xyz/anchor';
+import { BorshCoder, utils } from '@coral-xyz/anchor';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
+
+// node_modules/safe-buffer/index.js
+var require_safe_buffer = __commonJS({
+  "node_modules/safe-buffer/index.js"(exports$1, module) {
+    var buffer = __require("buffer");
+    var Buffer2 = buffer.Buffer;
+    function copyProps(src, dst) {
+      for (var key in src) {
+        dst[key] = src[key];
+      }
+    }
+    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
+      module.exports = buffer;
+    } else {
+      copyProps(buffer, exports$1);
+      exports$1.Buffer = SafeBuffer;
+    }
+    function SafeBuffer(arg, encodingOrOffset, length) {
+      return Buffer2(arg, encodingOrOffset, length);
+    }
+    SafeBuffer.prototype = Object.create(Buffer2.prototype);
+    copyProps(Buffer2, SafeBuffer);
+    SafeBuffer.from = function(arg, encodingOrOffset, length) {
+      if (typeof arg === "number") {
+        throw new TypeError("Argument must not be a number");
+      }
+      return Buffer2(arg, encodingOrOffset, length);
+    };
+    SafeBuffer.alloc = function(size, fill, encoding) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      var buf = Buffer2(size);
+      if (fill !== void 0) {
+        if (typeof encoding === "string") {
+          buf.fill(fill, encoding);
+        } else {
+          buf.fill(fill);
+        }
+      } else {
+        buf.fill(0);
+      }
+      return buf;
+    };
+    SafeBuffer.allocUnsafe = function(size) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      return Buffer2(size);
+    };
+    SafeBuffer.allocUnsafeSlow = function(size) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      return buffer.SlowBuffer(size);
+    };
+  }
+});
+
+// node_modules/base-x/src/index.js
+var require_src = __commonJS({
+  "node_modules/base-x/src/index.js"(exports$1, module) {
+    var _Buffer = require_safe_buffer().Buffer;
+    function base(ALPHABET) {
+      if (ALPHABET.length >= 255) {
+        throw new TypeError("Alphabet too long");
+      }
+      var BASE_MAP = new Uint8Array(256);
+      for (var j = 0; j < BASE_MAP.length; j++) {
+        BASE_MAP[j] = 255;
+      }
+      for (var i = 0; i < ALPHABET.length; i++) {
+        var x = ALPHABET.charAt(i);
+        var xc = x.charCodeAt(0);
+        if (BASE_MAP[xc] !== 255) {
+          throw new TypeError(x + " is ambiguous");
+        }
+        BASE_MAP[xc] = i;
+      }
+      var BASE = ALPHABET.length;
+      var LEADER = ALPHABET.charAt(0);
+      var FACTOR = Math.log(BASE) / Math.log(256);
+      var iFACTOR = Math.log(256) / Math.log(BASE);
+      function encode(source) {
+        if (Array.isArray(source) || source instanceof Uint8Array) {
+          source = _Buffer.from(source);
+        }
+        if (!_Buffer.isBuffer(source)) {
+          throw new TypeError("Expected Buffer");
+        }
+        if (source.length === 0) {
+          return "";
+        }
+        var zeroes = 0;
+        var length = 0;
+        var pbegin = 0;
+        var pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+          pbegin++;
+          zeroes++;
+        }
+        var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+        var b58 = new Uint8Array(size);
+        while (pbegin !== pend) {
+          var carry = source[pbegin];
+          var i2 = 0;
+          for (var it1 = size - 1; (carry !== 0 || i2 < length) && it1 !== -1; it1--, i2++) {
+            carry += 256 * b58[it1] >>> 0;
+            b58[it1] = carry % BASE >>> 0;
+            carry = carry / BASE >>> 0;
+          }
+          if (carry !== 0) {
+            throw new Error("Non-zero carry");
+          }
+          length = i2;
+          pbegin++;
+        }
+        var it2 = size - length;
+        while (it2 !== size && b58[it2] === 0) {
+          it2++;
+        }
+        var str = LEADER.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+          str += ALPHABET.charAt(b58[it2]);
+        }
+        return str;
+      }
+      function decodeUnsafe(source) {
+        if (typeof source !== "string") {
+          throw new TypeError("Expected String");
+        }
+        if (source.length === 0) {
+          return _Buffer.alloc(0);
+        }
+        var psz = 0;
+        var zeroes = 0;
+        var length = 0;
+        while (source[psz] === LEADER) {
+          zeroes++;
+          psz++;
+        }
+        var size = (source.length - psz) * FACTOR + 1 >>> 0;
+        var b256 = new Uint8Array(size);
+        while (psz < source.length) {
+          var charCode = source.charCodeAt(psz);
+          if (charCode > 255) {
+            return;
+          }
+          var carry = BASE_MAP[charCode];
+          if (carry === 255) {
+            return;
+          }
+          var i2 = 0;
+          for (var it3 = size - 1; (carry !== 0 || i2 < length) && it3 !== -1; it3--, i2++) {
+            carry += BASE * b256[it3] >>> 0;
+            b256[it3] = carry % 256 >>> 0;
+            carry = carry / 256 >>> 0;
+          }
+          if (carry !== 0) {
+            throw new Error("Non-zero carry");
+          }
+          length = i2;
+          psz++;
+        }
+        var it4 = size - length;
+        while (it4 !== size && b256[it4] === 0) {
+          it4++;
+        }
+        var vch = _Buffer.allocUnsafe(zeroes + (size - it4));
+        vch.fill(0, 0, zeroes);
+        var j2 = zeroes;
+        while (it4 !== size) {
+          vch[j2++] = b256[it4++];
+        }
+        return vch;
+      }
+      function decode(string) {
+        var buffer = decodeUnsafe(string);
+        if (buffer) {
+          return buffer;
+        }
+        throw new Error("Non-base" + BASE + " character");
+      }
+      return {
+        encode,
+        decodeUnsafe,
+        decode
+      };
+    }
+    module.exports = base;
+  }
+});
+
+// node_modules/bs58/index.js
+var require_bs58 = __commonJS({
+  "node_modules/bs58/index.js"(exports$1, module) {
+    var basex = require_src();
+    var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    module.exports = basex(ALPHABET);
+  }
+});
 
 // src/events.ts
+var import_bs58 = __toESM(require_bs58());
 
 // src/idl/hodl.json
 var hodl_default = {
@@ -1466,6 +1700,27 @@ var hodl_default = {
             ],
             type: "u64"
           },
+          {
+            name: "migration_complete",
+            docs: [
+              "One-way flag: set to true once vamm_real_sol >= MIGRATION_SOL_THRESHOLD, never reverts"
+            ],
+            type: "bool"
+          },
+          {
+            name: "total_fees_sol",
+            docs: [
+              "Cumulative SOL fees collected from buys (lamports)"
+            ],
+            type: "u64"
+          },
+          {
+            name: "total_fees_tokens",
+            docs: [
+              "Cumulative token fees collected from sells"
+            ],
+            type: "u64"
+          },
           {
             name: "bump_vault_auth",
             docs: [
@@ -1831,18 +2086,77 @@ var hodl_default = {
 };
 
 // src/events.ts
+var PROGRAM_DATA_PREFIX = "Program data: ";
+function toCamelCase(name) {
+  return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function snakeToCamelKeys(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = key.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+    result[camelKey] = value;
+  }
+  return result;
+}
+function tryDecodeEvent(coder, data) {
+  try {
+    const event = coder.events.decode(data);
+    if (event) {
+      return {
+        name: toCamelCase(event.name),
+        data: snakeToCamelKeys(event.data)
+      };
+    }
+  } catch {
+  }
+  return null;
+}
 function parseTransactionEvents(input, config) {
   if (!input) return [];
-  const logs = Array.isArray(input) ? input : input.meta?.logMessages ?? [];
-  if (logs.length === 0) return [];
   const coder = new BorshCoder(hodl_default);
-  const parser = new EventParser(config.programId, coder);
   const events = [];
-  try {
-    for (const event of parser.parseLogs(logs)) {
-      events.push({ name: event.name, data: event.data });
+  if (Array.isArray(input)) {
+    for (const log of input) {
+      if (!log.startsWith(PROGRAM_DATA_PREFIX)) continue;
+      const b64 = log.slice(PROGRAM_DATA_PREFIX.length);
+      const event = tryDecodeEvent(coder, b64);
+      if (event) events.push(event);
+    }
+    return events;
+  }
+  const tx = input;
+  const logs = tx.meta?.logMessages ?? [];
+  for (const log of logs) {
+    if (!log.startsWith(PROGRAM_DATA_PREFIX)) continue;
+    const b64 = log.slice(PROGRAM_DATA_PREFIX.length);
+    const event = tryDecodeEvent(coder, b64);
+    if (event) events.push(event);
+  }
+  const programId = config.programId.toBase58();
+  const staticKeys = tx.transaction.message.staticAccountKeys;
+  const loadedWritable = tx.meta?.loadedAddresses?.writable ?? [];
+  const loadedReadonly = tx.meta?.loadedAddresses?.readonly ?? [];
+  const allKeys = [...staticKeys, ...loadedWritable, ...loadedReadonly];
+  for (const inner of tx.meta?.innerInstructions ?? []) {
+    for (const ix of inner.instructions) {
+      const ixProgramKey = allKeys[ix.programIdIndex];
+      if (!ixProgramKey || ixProgramKey.toBase58() !== programId) continue;
+      try {
+        const bytes = import_bs58.default.decode(ix.data);
+        const b64Full = utils.bytes.base64.encode(Buffer.from(bytes));
+        const eventFull = tryDecodeEvent(coder, b64Full);
+        if (eventFull) {
+          events.push(eventFull);
+          continue;
+        }
+        if (bytes.length > 8) {
+          const b64Skip = utils.bytes.base64.encode(Buffer.from(bytes.slice(8)));
+          const eventSkip = tryDecodeEvent(coder, b64Skip);
+          if (eventSkip) events.push(eventSkip);
+        }
+      } catch {
+      }
     }
-  } catch {
   }
   return events;
 }
@@ -1856,7 +2170,6 @@ async function fetchAndParseTransaction(connection, signature, config) {
 function subscribeToEvents(connection, config, onEvent, opts = {}) {
   const commitment = opts.commitment ?? "confirmed";
   const coder = new BorshCoder(hodl_default);
-  const parser = new EventParser(config.programId, coder);
   return connection.onLogs(
     config.programId,
     ({ logs, err, signature }, context) => {
@@ -1865,12 +2178,13 @@ function subscribeToEvents(connection, config, onEvent, opts = {}) {
         return;
       }
       try {
-        for (const event of parser.parseLogs(logs)) {
-          onEvent(
-            { name: event.name, data: event.data },
-            context.slot,
-            signature
-          );
+        for (const log of logs) {
+          if (!log.startsWith(PROGRAM_DATA_PREFIX)) continue;
+          const b64 = log.slice(PROGRAM_DATA_PREFIX.length);
+          const event = tryDecodeEvent(coder, b64);
+          if (event) {
+            onEvent(event, context.slot, signature);
+          }
         }
       } catch (e) {
         opts.onError?.(e instanceof Error ? e : new Error(String(e)));
@@ -1907,6 +2221,11 @@ function subscribeToPositionClosed(connection, config, onEvent, opts) {
     if (event.name === "positionClosed") onEvent(event.data, slot, sig);
   }, opts);
 }
+/*! Bundled license information:
+
+safe-buffer/index.js:
+  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+*/
 
 export { fetchAndParseTransaction, parseTransactionEvents, subscribeToAccrualClaimed, subscribeToEvents, subscribeToPositionClosed, subscribeToTokenCreated, subscribeToTokenPurchased, subscribeToTokenSold, unsubscribeFromEvents };
 //# sourceMappingURL=events.js.map