stxer 0.3.3 → 0.4.0

package/dist/stxer.esm.js

@@ -1,5 +1,5 @@
-import { serializeCV, deserializeCV, tupleCV, uintCV, bufferCV, serializeCVBytes, contractPrincipalCV, stringAsciiCV, ClarityVersion, makeUnsignedContractDeploy, PostConditionMode, makeUnsignedSTXTokenTransfer, makeUnsignedContractCall, deserializeTransaction } from '@stacks/transactions';
-import { richFetch, getNodeInfo } from 'ts-clarity';
+import { serializeCV, deserializeCV, tupleCV, uintCV, bufferCV, serializeCVBytes, contractPrincipalCV, stringAsciiCV, ClarityVersion, makeUnsignedContractDeploy, PostConditionMode, makeUnsignedSTXTokenTransfer, makeUnsignedContractCall, deserializeTransaction, ClarityType } from '@stacks/transactions';
+import { richFetch, getNodeInfo, encodeAbi, decodeAbi } from 'ts-clarity';
 import { STACKS_MAINNET, STACKS_TESTNET } from '@stacks/network';
 import { c32addressDecode } from 'c32check';
 
@@ -457,62 +457,6 @@ function _batchRead() {
   }));
   return _batchRead.apply(this, arguments);
 }
-function batchReadonly(_x3, _x4) {
-  return _batchReadonly.apply(this, arguments);
-}
-function _batchReadonly() {
-  _batchReadonly = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(req, options) {
-    var _options$stxerApi2;
-    var payload, ibh, url, data, text, results, rs, _iterator5, _step5, result;
-    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
-        case 0:
-          if (options === void 0) {
-            options = {};
-          }
-          payload = req.readonly.map(function (r) {
-            return [serializeCV(r.contract), r.functionName].concat(r.functionArgs.map(function (arg) {
-              return serializeCV(arg);
-            }));
-          });
-          ibh = req.index_block_hash == null ? null : req.index_block_hash.startsWith('0x') ? req.index_block_hash.substring(2) : req.index_block_hash;
-          url = ((_options$stxerApi2 = options.stxerApi) != null ? _options$stxerApi2 : DEFAULT_STXER_API) + "/sidecar/v2/batch-readonly" + (ibh == null ? '' : "?tip=" + ibh);
-          _context2.next = 6;
-          return fetch(url, {
-            method: 'POST',
-            body: JSON.stringify(payload)
-          });
-        case 6:
-          data = _context2.sent;
-          _context2.next = 9;
-          return data.text();
-        case 9:
-          text = _context2.sent;
-          if (!(!text.includes('Ok') && !text.includes('Err'))) {
-            _context2.next = 12;
-            break;
-          }
-          throw new Error("Requesting batch readonly failed: " + text + ", url: " + url + ", payload: " + JSON.stringify(payload));
-        case 12:
-          results = JSON.parse(text);
-          rs = [];
-          for (_iterator5 = _createForOfIteratorHelperLoose(results); !(_step5 = _iterator5()).done;) {
-            result = _step5.value;
-            if ('Ok' in result) {
-              rs.push(deserializeCV(result.Ok));
-            } else {
-              rs.push(new Error(result.Err));
-            }
-          }
-          return _context2.abrupt("return", rs);
-        case 16:
-        case "end":
-          return _context2.stop();
-      }
-    }, _callee2);
-  }));
-  return _batchReadonly.apply(this, arguments);
-}
 
 function runTx(tx) {
   // type 0: run transaction
@@ -959,5 +903,318 @@ var SimulationBuilder = /*#__PURE__*/function () {
   return SimulationBuilder;
 }();
 
-export { SimulationBuilder, batchRead, batchReadonly, runEval, runSimulation };
+var BatchProcessor = /*#__PURE__*/function () {
+  function BatchProcessor(options) {
+    var _options$stxerAPIEndp;
+    this.queues = new Map();
+    this.timeoutIds = new Map();
+    this.stxerAPIEndpoint = void 0;
+    this.batchDelayMs = void 0;
+    this.stxerAPIEndpoint = (_options$stxerAPIEndp = options.stxerAPIEndpoint) != null ? _options$stxerAPIEndp : 'https://api.stxer.xyz';
+    this.batchDelayMs = options.batchDelayMs;
+  }
+  var _proto = BatchProcessor.prototype;
+  _proto.getQueueKey = function getQueueKey(tip) {
+    return tip != null ? tip : '_undefined';
+  };
+  _proto.enqueue = function enqueue(request) {
+    var _this$queues$get,
+      _this = this;
+    var queueKey = this.getQueueKey(request.tip);
+    var queue = (_this$queues$get = this.queues.get(queueKey)) != null ? _this$queues$get : [];
+    if (!this.queues.has(queueKey)) {
+      this.queues.set(queueKey, queue);
+    }
+    queue.push(request);
+    if (!this.timeoutIds.has(queueKey)) {
+      var timeoutId = setTimeout(function () {
+        return _this.processBatch(queueKey);
+      }, this.batchDelayMs);
+      this.timeoutIds.set(queueKey, timeoutId);
+    }
+  };
+  _proto.processBatch = /*#__PURE__*/function () {
+    var _processBatch = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(queueKey) {
+      var _this$queues$get2;
+      var currentQueue, timeoutId, readonlyRequests, mapRequests, variableRequests, tip, batchRequest, results, _iterator, _step, _step$value, index, result, _iterator2, _step2, _step2$value, _index, _result, _iterator3, _step3, _step3$value, _index2, _result2, _iterator4, _step4, item;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            currentQueue = (_this$queues$get2 = this.queues.get(queueKey)) != null ? _this$queues$get2 : [];
+            this.queues["delete"](queueKey);
+            timeoutId = this.timeoutIds.get(queueKey);
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+              this.timeoutIds["delete"](queueKey);
+            }
+            if (!(currentQueue.length === 0)) {
+              _context.next = 6;
+              break;
+            }
+            return _context.abrupt("return");
+          case 6:
+            _context.prev = 6;
+            readonlyRequests = currentQueue.filter(function (q) {
+              return q.request.mode === 'readonly';
+            });
+            mapRequests = currentQueue.filter(function (q) {
+              return q.request.mode === 'mapEntry';
+            });
+            variableRequests = currentQueue.filter(function (q) {
+              return q.request.mode === 'variable';
+            });
+            tip = queueKey === '_undefined' ? undefined : queueKey;
+            batchRequest = {
+              readonly: readonlyRequests.map(function (_ref) {
+                var request = _ref.request;
+                return {
+                  contract: contractPrincipalCV(request.contractAddress, request.contractName),
+                  functionName: request.functionName,
+                  functionArgs: request.functionArgs
+                };
+              }),
+              maps: mapRequests.map(function (_ref2) {
+                var request = _ref2.request;
+                return {
+                  contract: contractPrincipalCV(request.contractAddress, request.contractName),
+                  mapName: request.mapName,
+                  mapKey: request.mapKey
+                };
+              }),
+              variables: variableRequests.map(function (_ref3) {
+                var request = _ref3.request;
+                return {
+                  contract: contractPrincipalCV(request.contractAddress, request.contractName),
+                  variableName: request.variableName
+                };
+              }),
+              index_block_hash: tip
+            };
+            _context.next = 14;
+            return batchRead(batchRequest, {
+              stxerApi: this.stxerAPIEndpoint
+            });
+          case 14:
+            results = _context.sent;
+            // Handle readonly results
+            for (_iterator = _createForOfIteratorHelperLoose(results.readonly.entries()); !(_step = _iterator()).done;) {
+              _step$value = _step.value, index = _step$value[0], result = _step$value[1];
+              if (result instanceof Error) {
+                readonlyRequests[index].reject(result);
+              } else {
+                readonlyRequests[index].resolve(result);
+              }
+            }
+            // Handle variable results
+            for (_iterator2 = _createForOfIteratorHelperLoose(results.vars.entries()); !(_step2 = _iterator2()).done;) {
+              _step2$value = _step2.value, _index = _step2$value[0], _result = _step2$value[1];
+              if (_result instanceof Error) {
+                variableRequests[_index].reject(_result);
+              } else {
+                variableRequests[_index].resolve(_result);
+              }
+            }
+            // Handle map results
+            for (_iterator3 = _createForOfIteratorHelperLoose(results.maps.entries()); !(_step3 = _iterator3()).done;) {
+              _step3$value = _step3.value, _index2 = _step3$value[0], _result2 = _step3$value[1];
+              if (_result2 instanceof Error) {
+                mapRequests[_index2].reject(_result2);
+              } else {
+                mapRequests[_index2].resolve(_result2);
+              }
+            }
+            _context.next = 23;
+            break;
+          case 20:
+            _context.prev = 20;
+            _context.t0 = _context["catch"](6);
+            for (_iterator4 = _createForOfIteratorHelperLoose(currentQueue); !(_step4 = _iterator4()).done;) {
+              item = _step4.value;
+              item.reject(_context.t0);
+            }
+          case 23:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this, [[6, 20]]);
+    }));
+    function processBatch(_x) {
+      return _processBatch.apply(this, arguments);
+    }
+    return processBatch;
+  }();
+  return BatchProcessor;
+}();
+
+// Shared processor instance with default settings
+var defaultProcessor = /*#__PURE__*/new BatchProcessor({
+  batchDelayMs: 100
+});
+function callReadonly(_x) {
+  return _callReadonly.apply(this, arguments);
+}
+function _callReadonly() {
+  _callReadonly = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(params) {
+    var _params$batchProcesso;
+    var processor, _params$contract$spli, deployer, contractName, fn, functionDef, argsKV, args, _iterator, _step, argDef;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          processor = (_params$batchProcesso = params.batchProcessor) != null ? _params$batchProcesso : defaultProcessor;
+          _params$contract$spli = params.contract.split('.', 2), deployer = _params$contract$spli[0], contractName = _params$contract$spli[1];
+          fn = String(params.functionName);
+          functionDef = params.abi.find(function (def) {
+            return def.name === params.functionName;
+          });
+          if (functionDef) {
+            _context.next = 6;
+            break;
+          }
+          throw new Error("failed to find function definition for " + params.functionName);
+        case 6:
+          argsKV = params.args;
+          args = [];
+          for (_iterator = _createForOfIteratorHelperLoose(functionDef.args); !(_step = _iterator()).done;) {
+            argDef = _step.value;
+            args.push(encodeAbi(argDef.type, argsKV[argDef.name]));
+          }
+          return _context.abrupt("return", new Promise(function (_resolve, reject) {
+            processor.enqueue({
+              request: {
+                mode: 'readonly',
+                contractAddress: deployer,
+                contractName: contractName,
+                functionName: fn,
+                functionArgs: args
+              },
+              tip: params.indexBlockHash,
+              resolve: function resolve(result) {
+                try {
+                  var decoded = decodeAbi(functionDef.outputs.type, result);
+                  _resolve(decoded);
+                } catch (error) {
+                  reject(error);
+                }
+              },
+              reject: reject
+            });
+          }));
+        case 10:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _callReadonly.apply(this, arguments);
+}
+function readMap(_x2) {
+  return _readMap.apply(this, arguments);
+}
+function _readMap() {
+  _readMap = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(params) {
+    var _params$batchProcesso2;
+    var processor, _params$contract$spli2, deployer, contractName, mapDef, key;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          processor = (_params$batchProcesso2 = params.batchProcessor) != null ? _params$batchProcesso2 : defaultProcessor;
+          _params$contract$spli2 = params.contract.split('.', 2), deployer = _params$contract$spli2[0], contractName = _params$contract$spli2[1];
+          mapDef = params.abi.find(function (m) {
+            return m.name === params.mapName;
+          });
+          if (mapDef) {
+            _context2.next = 5;
+            break;
+          }
+          throw new Error("failed to find map definition for " + params.mapName);
+        case 5:
+          key = encodeAbi(mapDef.key, params.key);
+          return _context2.abrupt("return", new Promise(function (_resolve2, reject) {
+            processor.enqueue({
+              request: {
+                mode: 'mapEntry',
+                contractAddress: deployer,
+                contractName: contractName,
+                mapName: params.mapName,
+                mapKey: key
+              },
+              tip: params.indexBlockHash,
+              resolve: function resolve(result) {
+                try {
+                  if (result.type === ClarityType.OptionalNone) {
+                    _resolve2(null);
+                    return;
+                  }
+                  if (result.type !== ClarityType.OptionalSome) {
+                    throw new Error("unexpected map value: " + result);
+                  }
+                  var someCV = result;
+                  var decoded = decodeAbi(mapDef.value, someCV.value);
+                  _resolve2(decoded);
+                } catch (error) {
+                  reject(error);
+                }
+              },
+              reject: reject
+            });
+          }));
+        case 7:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _readMap.apply(this, arguments);
+}
+function readVariable(_x3) {
+  return _readVariable.apply(this, arguments);
+}
+function _readVariable() {
+  _readVariable = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(params) {
+    var _params$batchProcesso3;
+    var processor, _params$contract$spli3, deployer, contractName, varDef;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          processor = (_params$batchProcesso3 = params.batchProcessor) != null ? _params$batchProcesso3 : defaultProcessor;
+          _params$contract$spli3 = params.contract.split('.', 2), deployer = _params$contract$spli3[0], contractName = _params$contract$spli3[1];
+          varDef = params.abi.find(function (def) {
+            return def.name === params.variableName;
+          });
+          if (varDef) {
+            _context3.next = 5;
+            break;
+          }
+          throw new Error("failed to find variable definition for " + params.variableName);
+        case 5:
+          return _context3.abrupt("return", new Promise(function (_resolve3, reject) {
+            processor.enqueue({
+              request: {
+                mode: 'variable',
+                contractAddress: deployer,
+                contractName: contractName,
+                variableName: params.variableName
+              },
+              tip: params.indexBlockHash,
+              resolve: function resolve(result) {
+                try {
+                  var decoded = decodeAbi(varDef.type, result);
+                  _resolve3(decoded);
+                } catch (error) {
+                  reject(error);
+                }
+              },
+              reject: reject
+            });
+          }));
+        case 6:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _readVariable.apply(this, arguments);
+}
+
+export { SimulationBuilder, batchRead, callReadonly, readMap, readVariable, runEval, runSimulation };
 //# sourceMappingURL=stxer.esm.js.map