stxer 0.3.3 → 0.4.1

package/README.md

@@ -12,12 +12,43 @@ yarn add stxer
 
 ## Features
 
-### 1. Batch Operations
+### 1. Transaction Simulation
 
-The SDK provides efficient batch reading capabilities for Stacks blockchain:
+Simulate complex transaction sequences before executing them on-chain:
+
+```typescript
+import { SimulationBuilder } from 'stxer';
+
+const simulationId = await SimulationBuilder.new({
+  network: 'mainnet', // or 'testnet'
+})
+  .withSender('ST...') // Set default sender
+  .addContractCall({
+    contract_id: 'ST...contract-name',
+    function_name: 'my-function',
+    function_args: [/* clarity values */]
+  })
+  .addSTXTransfer({
+    recipient: 'ST...',
+    amount: 1000000 // in microSTX
+  })
+  .addContractDeploy({
+    contract_name: 'my-contract',
+    source_code: '(define-public (hello) (ok "world"))'
+  })
+  .run();
+
+// View simulation results at: https://stxer.xyz/simulations/{network}/{simulationId}
+```
+
+### 2. Batch Operations
+
+The SDK provides two approaches for efficient batch reading from the Stacks blockchain:
+
+#### Direct Batch Reading
 
 ```typescript
-import { batchRead, batchReadonly } from 'stxer';
+import { batchRead } from 'stxer';
 
 // Batch read variables and maps
 const result = await batchRead({
@@ -29,11 +60,7 @@ const result = await batchRead({
     contract: contractPrincipalCV(...),
     mapName: 'my-map',
     mapKey: someCV
-  }]
-});
-
-// Batch readonly function calls
-const readonlyResult = await batchReadonly({
+  }],
   readonly: [{
     contract: contractPrincipalCV(...),
     functionName: 'my-function',
@@ -42,35 +69,94 @@ const readonlyResult = await batchReadonly({
 });
 ```
 
-### 2. Transaction Simulation
+#### BatchProcessor for Queue-based Operations
 
-Simulate complex transaction sequences before executing them on-chain:
+The BatchProcessor allows you to queue multiple read operations and automatically batch them together after a specified delay:
 
 ```typescript
-import { SimulationBuilder } from 'stxer';
+import { BatchProcessor } from 'stxer';
 
-const simulationId = await SimulationBuilder.new({
-  network: 'mainnet', // or 'testnet'
-})
-  .withSender('ST...') // Set default sender
-  .addContractCall({
-    contract_id: 'ST...contract-name',
-    function_name: 'my-function',
-    function_args: [/* clarity values */]
-  })
-  .addSTXTransfer({
-    recipient: 'ST...',
-    amount: 1000000 // in microSTX
-  })
-  .addContractDeploy({
-    contract_name: 'my-contract',
-    source_code: '(define-public (hello) (ok "world"))'
+const processor = new BatchProcessor({
+  stxerAPIEndpoint: 'https://api.stxer.xyz', // optional
+  batchDelayMs: 1000, // delay before processing batch
+});
+
+// Queue multiple operations that will be batched together
+const [resultA, resultB] = await Promise.all([
+  processor.read({
+    mode: 'variable',
+    contractAddress: 'SP...',
+    contractName: 'my-contract',
+    variableName: 'variable-a'
+  }),
+  processor.read({
+    mode: 'variable',
+    contractAddress: 'SP...',
+    contractName: 'my-contract',
+    variableName: 'variable-b'
   })
-  .run();
+]);
+
+// You can also queue different types of operations
+processor.read({
+  mode: 'readonly',
+  contractAddress: 'SP...',
+  contractName: 'my-contract',
+  functionName: 'get-value',
+  functionArgs: []
+});
 
-// View simulation results at: https://stxer.xyz/simulations/{network}/{simulationId}
+processor.read({
+  mode: 'mapEntry',
+  contractAddress: 'SP...',
+  contractName: 'my-contract',
+  mapName: 'my-map',
+  mapKey: someKey
+});
 ```
 
+The BatchProcessor automatically:
+- Queues read operations
+- Batches them together after the specified delay
+- Makes a single API call for all queued operations
+- Distributes results back to the respective promises
+
+This is particularly useful when you need to make multiple blockchain reads and want to optimize network calls.
+
+### 3. Clarity API Utilities
+
+The SDK provides convenient utilities for reading data from Clarity contracts:
+
+```typescript
+import { callReadonly, readVariable, readMap } from 'stxer';
+import { SIP010TraitABI } from 'clarity-abi/abis';
+import { unwrapResponse } from 'ts-clarity';
+
+// Read from a contract function
+const supply = await callReadonly({
+  abi: SIP010TraitABI.functions,
+  functionName: 'get-total-supply',
+  contract: 'SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.token-alex',
+}).then(unwrapResponse);
+
+// Read a contract variable
+const paused = await readVariable({
+  abi: [{ name: 'paused', type: 'bool', access: 'variable' }],
+  variableName: 'paused',
+  contract: 'SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-vault-v2-01',
+});
+
+// Read from a contract map
+const approved = await readMap({
+  abi: [{ key: 'principal', name: 'approved-tokens', value: 'bool' }],
+  mapName: 'approved-tokens',
+  key: 'SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.token-alex',
+  contract: 'SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-vault-v2-01',
+});
+```
+
+These utilities provide type-safe ways to interact with Clarity contracts, with built-in ABI support and response unwrapping.
+
 ## Configuration
 
 You can customize the API endpoints:

package/dist/{batch-api.d.ts → BatchAPI.d.ts}

@@ -32,12 +32,3 @@ export interface BatchApiOptions {
     stxerApi?: string;
 }
 export declare function batchRead(reads: BatchReads, options?: BatchApiOptions): Promise<BatchReadsResult>;
-export interface BatchReadonlyRequest {
-    readonly: {
-        contract: ContractPrincipalCV;
-        functionName: string;
-        functionArgs: ClarityValue[];
-    }[];
-    index_block_hash?: string;
-}
-export declare function batchReadonly(req: BatchReadonlyRequest, options?: BatchApiOptions): Promise<(ClarityValue | Error)[]>;

package/dist/BatchProcessor.d.ts

@@ -0,0 +1,48 @@
+/**
+ * WARNING:
+ *
+ * this file will be used in cross-runtime environments (browser, cloudflare workers, XLinkSDK, etc.),
+ * so please be careful when adding `import`s to it.
+ */
+import { type ClarityValue, type OptionalCV } from '@stacks/transactions';
+export interface ReadOnlyRequest {
+    mode: 'readonly';
+    contractAddress: string;
+    contractName: string;
+    functionName: string;
+    functionArgs: ClarityValue[];
+}
+export interface MapEntryRequest {
+    mode: 'mapEntry';
+    contractAddress: string;
+    contractName: string;
+    mapName: string;
+    mapKey: ClarityValue;
+}
+export interface VariableRequest {
+    mode: 'variable';
+    contractAddress: string;
+    contractName: string;
+    variableName: string;
+}
+export type BatchRequest = MapEntryRequest | VariableRequest | ReadOnlyRequest;
+export interface QueuedRequest {
+    request: BatchRequest;
+    tip?: string;
+    resolve: (value: ClarityValue | OptionalCV) => void;
+    reject: (error: Error) => void;
+}
+export declare class BatchProcessor {
+    private queues;
+    private timeoutIds;
+    private readonly stxerAPIEndpoint;
+    private readonly batchDelayMs;
+    constructor(options: {
+        stxerAPIEndpoint?: string;
+        batchDelayMs: number;
+    });
+    private getQueueKey;
+    read(request: BatchRequest): Promise<ClarityValue | OptionalCV>;
+    enqueue(request: QueuedRequest): void;
+    private processBatch;
+}

package/dist/clarity-api.d.ts

@@ -0,0 +1,27 @@
+import type { ClarityAbiFunction, ClarityAbiMap, ClarityAbiVariable, TContractPrincipal, TPrincipal } from 'clarity-abi';
+import type { InferReadonlyCallParameterType, InferReadonlyCallResultType, InferMapValueType, InferReadMapParameterType, InferReadVariableParameterType, InferVariableType } from 'ts-clarity';
+import { BatchProcessor } from './BatchProcessor';
+export type ReadonlyCallRuntimeOptions = {
+    sender?: TPrincipal;
+    contract: TContractPrincipal;
+    stacksEndpoint?: string;
+    indexBlockHash?: string;
+    batchProcessor?: BatchProcessor;
+};
+export type ReadMapRuntimeParameters = {
+    contract: TContractPrincipal;
+    stacksEndpoint?: string;
+    proof?: boolean;
+    indexBlockHash?: string;
+    batchProcessor?: BatchProcessor;
+};
+export type ReadVariableRuntimeParameterType = {
+    contract: TContractPrincipal;
+    stacksEndpoint?: string;
+    proof?: boolean;
+    indexBlockHash?: string;
+    batchProcessor?: BatchProcessor;
+};
+export declare function callReadonly<Functions extends readonly ClarityAbiFunction[] | readonly unknown[], FunctionName extends string>(params: InferReadonlyCallParameterType<Functions, FunctionName> & ReadonlyCallRuntimeOptions): Promise<InferReadonlyCallResultType<Functions, FunctionName>>;
+export declare function readMap<Maps extends readonly ClarityAbiMap[] | readonly unknown[] = readonly ClarityAbiMap[], MapName extends string = string>(params: InferReadMapParameterType<Maps, MapName> & ReadMapRuntimeParameters): Promise<InferMapValueType<Maps, MapName> | null>;
+export declare function readVariable<Variables extends readonly ClarityAbiVariable[] | readonly unknown[] = readonly ClarityAbiVariable[], VariableName extends string = string>(params: InferReadVariableParameterType<Variables, VariableName> & ReadVariableRuntimeParameterType): Promise<InferVariableType<Variables, VariableName>>;

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export * from './batch-api';
+export * from './BatchAPI';
 export * from './simulation';
+export * from './clarity-api';

package/dist/stxer.cjs.development.js

@@ -461,62 +461,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 [transactions.serializeCV(r.contract), r.functionName].concat(r.functionArgs.map(function (arg) {
-              return transactions.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(transactions.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
@@ -963,9 +907,334 @@ var SimulationBuilder = /*#__PURE__*/function () {
   return SimulationBuilder;
 }();
 
+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.read = function read(request) {
+    var _this = this;
+    return new Promise(function (resolve, reject) {
+      _this.enqueue({
+        request: request,
+        resolve: resolve,
+        reject: reject
+      });
+    });
+  };
+  _proto.enqueue = function enqueue(request) {
+    var _this$queues$get,
+      _this2 = 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 _this2.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: transactions.contractPrincipalCV(request.contractAddress, request.contractName),
+                  functionName: request.functionName,
+                  functionArgs: request.functionArgs
+                };
+              }),
+              maps: mapRequests.map(function (_ref2) {
+                var request = _ref2.request;
+                return {
+                  contract: transactions.contractPrincipalCV(request.contractAddress, request.contractName),
+                  mapName: request.mapName,
+                  mapKey: request.mapKey
+                };
+              }),
+              variables: variableRequests.map(function (_ref3) {
+                var request = _ref3.request;
+                return {
+                  contract: transactions.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(tsClarity.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 = tsClarity.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 = tsClarity.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 === transactions.ClarityType.OptionalNone) {
+                    _resolve2(null);
+                    return;
+                  }
+                  if (result.type !== transactions.ClarityType.OptionalSome) {
+                    throw new Error("unexpected map value: " + result);
+                  }
+                  var someCV = result;
+                  var decoded = tsClarity.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 = tsClarity.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);
+}
+
 exports.SimulationBuilder = SimulationBuilder;
 exports.batchRead = batchRead;
-exports.batchReadonly = batchReadonly;
+exports.callReadonly = callReadonly;
+exports.readMap = readMap;
+exports.readVariable = readVariable;
 exports.runEval = runEval;
 exports.runSimulation = runSimulation;
 //# sourceMappingURL=stxer.cjs.development.js.map