@clarigen/core 1.0.0-next.6 → 1.0.0-next.9

package/dist/api.d.ts

@@ -1,13 +1,14 @@
 import { StacksNetwork } from 'micro-stacks/network';
 import { StacksTransaction } from 'micro-stacks/transactions';
 import { ClarityTypes } from './clarity-types';
-import { ContractCall } from './pure';
+import { ContractCall, ContractCalls } from './pure';
 interface ApiOptions {
     network: StacksNetwork;
 }
 export declare function ro<T>(tx: ContractCall<T>, options: ApiOptions): Promise<T>;
 export declare function roOk<Ok>(tx: ContractCall<ClarityTypes.Response<Ok, any>>, options: ApiOptions): Promise<Ok>;
 export declare function roErr<Err>(tx: ContractCall<ClarityTypes.Response<any, Err>>, options: ApiOptions): Promise<Err>;
+export declare function fetchMapGet<T extends ContractCalls.Map<any, Val>, Val>(map: T, options: ApiOptions): Promise<Val | null>;
 export declare function broadcast(transaction: StacksTransaction, options: ApiOptions): Promise<{
     txId: string;
     stacksTransaction: StacksTransaction;

package/dist/core.cjs.development.js

@@ -34,8 +34,7 @@ var getContractNameFromPath = function getContractNameFromPath(path) {
   return contractName;
 };
 var getContractIdentifier = function getContractIdentifier(contract) {
-  var contractName = getContractNameFromPath(contract.contractFile);
-  return contract.address + "." + contractName;
+  return contract.address + "." + contract.name;
 };
 var getContractPrincipalCV = function getContractPrincipalCV(contract) {
   var contractName = getContractNameFromPath(contract.contractFile);
@@ -60,6 +59,12 @@ function bootContractIdentifier(name, mainnet) {
   CoreNodeEventType["FtBurnEvent"] = "ft_burn_event";
 })(exports.CoreNodeEventType || (exports.CoreNodeEventType = {}));
 
+function filterEvents(events, type) {
+  return events.filter(function (event) {
+    return event.type === type;
+  });
+}
+
 function makeContracts(contracts, options) {
   if (options === void 0) {
     options = {};
@@ -1188,31 +1193,69 @@ function ro(_x, _x2) {
 
 function _ro() {
   _ro = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(tx, options) {
-    var result;
+    var urlBase, url, body, response, msg, parsed;
     return runtime_1.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            _context.next = 2;
-            return api.callReadOnlyFunction({
-              contractAddress: tx.contractAddress,
-              contractName: tx.contractName,
-              functionArgs: tx.functionArgs,
-              functionName: tx["function"].name,
-              network: options.network,
-              tip: 'latest'
+            urlBase = options.network.getReadOnlyFunctionCallApiUrl(tx.contractAddress, tx.contractName, tx["function"].name);
+            url = urlBase + "?tip=latest";
+            body = JSON.stringify({
+              sender: tx.contractAddress,
+              arguments: tx.functionArgs.map(function (arg) {
+                return typeof arg === 'string' ? arg : clarity.cvToHex(arg);
+              })
+            });
+            _context.next = 5;
+            return common.fetchPrivate(url, {
+              method: 'POST',
+              body: body,
+              headers: {
+                'Content-Type': 'application/json'
+              }
             });
 
-          case 2:
-            result = _context.sent;
-            return _context.abrupt("return", cvToValue(result, true));
+          case 5:
+            response = _context.sent;
 
-          case 4:
+            if (response.ok) {
+              _context.next = 17;
+              break;
+            }
+
+            msg = '';
+            _context.prev = 8;
+            _context.next = 11;
+            return response.text();
+
+          case 11:
+            msg = _context.sent;
+            _context.next = 16;
+            break;
+
+          case 14:
+            _context.prev = 14;
+            _context.t0 = _context["catch"](8);
+
+          case 16:
+            throw new Error("Error calling read-only function. Response " + response.status + ": " + response.statusText + ". Attempted to fetch " + url + " and failed with the message: \"" + msg + "\"");
+
+          case 17:
+            _context.t1 = api.parseReadOnlyResponse;
+            _context.next = 20;
+            return response.json();
+
+          case 20:
+            _context.t2 = _context.sent;
+            parsed = (0, _context.t1)(_context.t2);
+            return _context.abrupt("return", cvToValue(parsed, true));
+
+          case 23:
           case "end":
             return _context.stop();
         }
       }
-    }, _callee);
+    }, _callee, null, [[8, 14]]);
   }));
   return _ro.apply(this, arguments);
 }
@@ -1273,42 +1316,80 @@ function _roErr() {
   return _roErr.apply(this, arguments);
 }
 
-function broadcast(_x7, _x8) {
+function fetchMapGet(_x7, _x8) {
+  return _fetchMapGet.apply(this, arguments);
+}
+
+function _fetchMapGet() {
+  _fetchMapGet = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(map, options) {
+    var lookupKey, response, valueCV;
+    return runtime_1.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            lookupKey = clarity.cvToHex(map.key);
+            _context4.next = 3;
+            return api.fetchContractDataMapEntry({
+              contract_address: map.contractAddress,
+              contract_name: map.contractName,
+              map_name: map.map.name,
+              lookup_key: lookupKey,
+              tip: 'latest',
+              url: options.network.getCoreApiUrl(),
+              proof: 0
+            });
+
+          case 3:
+            response = _context4.sent;
+            valueCV = clarity.hexToCV(response.data);
+            return _context4.abrupt("return", cvToValue(valueCV, true));
+
+          case 6:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _fetchMapGet.apply(this, arguments);
+}
+
+function broadcast(_x9, _x10) {
   return _broadcast.apply(this, arguments);
 }
 
 function _broadcast() {
-  _broadcast = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(transaction, options) {
+  _broadcast = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(transaction, options) {
     var result;
-    return runtime_1.wrap(function _callee4$(_context4) {
+    return runtime_1.wrap(function _callee5$(_context5) {
       while (1) {
-        switch (_context4.prev = _context4.next) {
+        switch (_context5.prev = _context5.next) {
           case 0:
-            _context4.next = 2;
+            _context5.next = 2;
             return transactions.broadcastTransaction(transaction, options.network);
 
           case 2:
-            result = _context4.sent;
+            result = _context5.sent;
 
             if (!('error' in result)) {
-              _context4.next = 7;
+              _context5.next = 7;
               break;
             }
 
             throw new Error("Error broadcasting tx: " + result.error + " - " + result.reason + " - " + result.reason_data);
 
           case 7:
-            return _context4.abrupt("return", {
+            return _context5.abrupt("return", {
               txId: result.txid,
               stacksTransaction: transaction
             });
 
           case 8:
           case "end":
-            return _context4.stop();
+            return _context5.stop();
         }
       }
-    }, _callee4);
+    }, _callee5);
   }));
   return _broadcast.apply(this, arguments);
 }
@@ -1359,6 +1440,8 @@ exports.cvToString = cvToString;
 exports.cvToValue = cvToValue;
 exports.expectErr = expectErr;
 exports.expectOk = expectOk;
+exports.fetchMapGet = fetchMapGet;
+exports.filterEvents = filterEvents;
 exports.getContractIdentifier = getContractIdentifier;
 exports.getContractNameFromPath = getContractNameFromPath;
 exports.getContractPrincipalCV = getContractPrincipalCV;