@clarigen/core 0.3.1 → 1.0.0-next.4

package/dist/core.esm.js

@@ -1,4 +1,8 @@
-import { contractPrincipalCV, ClarityType, isClarityAbiTuple, tupleCV, isClarityAbiList, listCV, isClarityAbiOptional, noneCV, someCV, isClarityAbiStringAscii, stringAsciiCV, isClarityAbiStringUtf8, stringUtf8CV, parseToCV as parseToCV$1, uintCV, intCV, addressToString } from '@stacks/transactions';
+import { contractPrincipalCV, ClarityType, hexToCV, tupleCV, listCV, noneCV, someCV, stringAsciiCV, stringUtf8CV, uintCV, intCV, bufferCV, addressToString } from 'micro-stacks/clarity';
+import { isClarityAbiTuple, isClarityAbiList, isClarityAbiOptional, isClarityAbiStringAscii, isClarityAbiStringUtf8, parseToCV as parseToCV$1, isClarityAbiBuffer, broadcastTransaction } from 'micro-stacks/transactions';
+import { bytesToAscii, bytesToHex } from 'micro-stacks/common';
+import { ok, err } from 'neverthrow';
+import { callReadOnlyFunction } from 'micro-stacks/api';
 
 var TESTNET_BURN_ADDRESS = 'ST000000000000000000002AMW42H';
 var MAINNET_BURN_ADDRESS = 'SP000000000000000000002Q6VF78';
@@ -54,6 +58,27 @@ var CoreNodeEventType;
   CoreNodeEventType["FtBurnEvent"] = "ft_burn_event";
 })(CoreNodeEventType || (CoreNodeEventType = {}));
 
+function makeContracts(contracts, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var instances = {};
+
+  for (var k in contracts) {
+    var contract = contracts[k];
+    var address = options.deployerAddress || contract.address;
+    var identifier = address + "." + contract.name;
+    var instance = contract.contract(address, contract.name);
+    instances[k] = {
+      identifier: identifier,
+      contract: instance
+    };
+  }
+
+  return instances;
+}
+
 function principalToString(principal) {
   if (principal.type === ClarityType.PrincipalStandard) {
     return addressToString(principal.address);
@@ -64,8 +89,18 @@ function principalToString(principal) {
     throw new Error("Unexpected principal data: " + JSON.stringify(principal));
   }
 }
+/**
+ * @param val - ClarityValue
+ * @param returnResponse - if true, this will return a "response" object from the `neverthrow`
+ * library. Otherwise, it returns the inner value of the response (whether ok or err)
+ */
+
+
+function cvToValue(val, returnResponse) {
+  if (returnResponse === void 0) {
+    returnResponse = false;
+  }
 
-function cvToValue(val) {
   switch (val.type) {
     case ClarityType.BoolTrue:
       return true;
@@ -74,8 +109,6 @@ function cvToValue(val) {
       return false;
 
     case ClarityType.Int:
-      return val.value;
-
     case ClarityType.UInt:
       return val.value;
 
@@ -89,9 +122,11 @@ function cvToValue(val) {
       return cvToValue(val.value);
 
     case ClarityType.ResponseErr:
+      if (returnResponse) return err(cvToValue(val.value));
       return cvToValue(val.value);
 
     case ClarityType.ResponseOk:
+      if (returnResponse) return ok(cvToValue(val.value));
       return cvToValue(val.value);
 
     case ClarityType.PrincipalStandard:
@@ -105,8 +140,13 @@ function cvToValue(val) {
 
     case ClarityType.Tuple:
       var result = {};
-      Object.keys(val.data).forEach(function (key) {
-        result[key] = cvToValue(val.data[key]);
+      var arr = Object.keys(val.data).map(function (key) {
+        return [key, cvToValue(val.data[key])];
+      });
+      arr.forEach(function (_ref) {
+        var key = _ref[0],
+            value = _ref[1];
+        result[key] = value;
       });
       return result;
 
@@ -117,6 +157,19 @@ function cvToValue(val) {
       return val.data;
   }
 }
+/**
+ * Converts a hex encoded string to the javascript clarity value object {type: string; value: any}
+ * @param hex - the hex encoded string with or without `0x` prefix
+ * @param jsonCompat - enable to serialize bigints to strings
+ */
+
+function hexToCvValue(hex, jsonCompat) {
+  if (jsonCompat === void 0) {
+    jsonCompat = false;
+  }
+
+  return cvToValue(hexToCV(hex), jsonCompat);
+}
 
 function inputToBigInt(input) {
   var isBigInt = typeof input === 'bigint';
@@ -174,6 +227,16 @@ function parseToCV(input, type) {
     var _bigi = inputToBigInt(input);
 
     return intCV(_bigi.toString());
+  } else if (type === 'trait_reference') {
+    if (typeof input !== 'string') throw new Error('Invalid input for trait_reference');
+
+    var _input$split = input.split('.'),
+        addr = _input$split[0],
+        name = _input$split[1];
+
+    return contractPrincipalCV(addr, name);
+  } else if (isClarityAbiBuffer(type)) {
+    return bufferCV(input);
   }
 
   return parseToCV$1(input, type);
@@ -198,14 +261,14 @@ function cvToString(val, encoding) {
 
     case ClarityType.Buffer:
       if (encoding === 'tryAscii') {
-        var str = val.buffer.toString('ascii');
+        var str = bytesToAscii(val.buffer);
 
         if (/[ -~]/.test(str)) {
           return JSON.stringify(str);
         }
       }
 
-      return "0x" + val.buffer.toString('hex');
+      return "0x" + bytesToHex(val.buffer);
 
     case ClarityType.OptionalNone:
       return 'none';
@@ -240,6 +303,80 @@ function cvToString(val, encoding) {
       return "u\"" + val.data + "\"";
   }
 }
+function transformArgsToCV(func, args) {
+  return args.map(function (arg, index) {
+    return parseToCV(arg, func.args[index].type);
+  });
+}
+function expectOk(response) {
+  return response.match(function (ok) {
+    return ok;
+  }, function (err) {
+    throw new Error("Expected OK, received error: " + err);
+  });
+}
+function expectErr(response) {
+  return response.match(function (ok) {
+    throw new Error("Expected Err, received Ok: " + ok);
+  }, function (err) {
+    return err;
+  });
+}
+
+function transformArguments(func, args) {
+  return transformArgsToCV(func, args);
+}
+
+function getter(contract, property) {
+  var foundFunction = contract.abi.functions.find(function (func) {
+    return toCamelCase(func.name) === property;
+  });
+
+  if (foundFunction) {
+    return function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      var functionArgs = transformArguments(foundFunction, args);
+      return {
+        functionArgs: functionArgs,
+        contractAddress: contract.contractAddress,
+        contractName: contract.contractName,
+        "function": foundFunction,
+        nativeArgs: args
+      };
+    };
+  }
+
+  var foundMap = contract.abi.maps.find(function (map) {
+    return toCamelCase(map.name) === property;
+  });
+
+  if (foundMap) {
+    return function (key) {
+      var keyCV = parseToCV(key, foundMap.key);
+      var mapGet = {
+        contractAddress: contract.contractAddress,
+        contractName: contract.contractName,
+        map: foundMap,
+        nativeKey: key,
+        key: keyCV
+      };
+      return mapGet;
+    };
+  } // TODO: variables, tokens
+
+
+  throw new Error("Invalid function call: no function exists for " + String(property));
+}
+
+var proxyHandler = {
+  get: getter
+};
+var pureProxy = function pureProxy(target) {
+  return new Proxy(target, proxyHandler);
+};
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -1043,6 +1180,136 @@ var BaseProvider = /*#__PURE__*/function () {
   return BaseProvider;
 }();
 
+function ro(_x, _x2) {
+  return _ro.apply(this, arguments);
+}
+
+function _ro() {
+  _ro = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(tx, options) {
+    var result;
+    return runtime_1.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return callReadOnlyFunction({
+              contractAddress: tx.contractAddress,
+              contractName: tx.contractName,
+              functionArgs: tx.functionArgs,
+              functionName: tx["function"].name,
+              network: options.network
+            });
+
+          case 2:
+            result = _context.sent;
+            return _context.abrupt("return", cvToValue(result, true));
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _ro.apply(this, arguments);
+}
+
+function roOk(_x3, _x4) {
+  return _roOk.apply(this, arguments);
+}
+
+function _roOk() {
+  _roOk = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(tx, options) {
+    var result;
+    return runtime_1.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return ro(tx, options);
+
+          case 2:
+            result = _context2.sent;
+            return _context2.abrupt("return", expectOk(result));
+
+          case 4:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _roOk.apply(this, arguments);
+}
+
+function roErr(_x5, _x6) {
+  return _roErr.apply(this, arguments);
+}
+
+function _roErr() {
+  _roErr = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(tx, options) {
+    var result;
+    return runtime_1.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.next = 2;
+            return ro(tx, options);
+
+          case 2:
+            result = _context3.sent;
+            return _context3.abrupt("return", expectErr(result));
+
+          case 4:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _roErr.apply(this, arguments);
+}
+
+function broadcast(_x7, _x8) {
+  return _broadcast.apply(this, arguments);
+}
+
+function _broadcast() {
+  _broadcast = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(transaction, options) {
+    var result;
+    return runtime_1.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            _context4.next = 2;
+            return broadcastTransaction(transaction, options.network);
+
+          case 2:
+            result = _context4.sent;
+
+            if (!('error' in result)) {
+              _context4.next = 7;
+              break;
+            }
+
+            throw new Error("Error broadcasting tx: " + result.error + " - " + result.reason + " - " + result.reason_data);
+
+          case 7:
+            return _context4.abrupt("return", {
+              txId: result.txid,
+              stacksTransaction: transaction
+            });
+
+          case 8:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _broadcast.apply(this, arguments);
+}
+
 var makeHandler = function makeHandler(provider) {
   var handler = {
     get: function get(contract, property) {
@@ -1080,5 +1347,5 @@ var proxy = function proxy(target, provider) {
   return new Proxy(target, makeHandler(provider));
 };
 
-export { BaseProvider, CoreNodeEventType, MAINNET_BURN_ADDRESS, TESTNET_BURN_ADDRESS, bootContractIdentifier, cvToString, cvToValue, getContractIdentifier, getContractNameFromPath, getContractPrincipalCV, parseToCV, proxy, toCamelCase };
+export { BaseProvider, CoreNodeEventType, MAINNET_BURN_ADDRESS, TESTNET_BURN_ADDRESS, bootContractIdentifier, broadcast, cvToString, cvToValue, expectErr, expectOk, getContractIdentifier, getContractNameFromPath, getContractPrincipalCV, hexToCvValue, makeContracts, parseToCV, proxy, pureProxy, ro, roErr, roOk, toCamelCase };
 //# sourceMappingURL=core.esm.js.map