@clarigen/core 0.2.3 → 1.0.0-next.3

package/dist/api.d.ts

@@ -0,0 +1,15 @@
+import { StacksNetwork } from 'micro-stacks/network';
+import { StacksTransaction } from 'micro-stacks/transactions';
+import { ClarityTypes } from './clarity-types';
+import { ContractCall } 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 broadcast(transaction: StacksTransaction, options: ApiOptions): Promise<{
+    txId: string;
+    stacksTransaction: StacksTransaction;
+}>;
+export {};

package/dist/base-provider.d.ts

@@ -1,4 +1,4 @@
-import { ClarityAbiFunction } from '@stacks/transactions';
+import { ClarityAbiFunction } from 'micro-stacks/clarity';
 import { Transaction } from './transaction';
 export declare abstract class BaseProvider {
     callReadOnly(func: ClarityAbiFunction, args: any[]): Promise<void>;

package/dist/clarity-types.d.ts

@@ -1,46 +1,34 @@
-import type * as Clarity from '@stacks/transactions';
-import { ClarityAbi as _ClarityAbi, ClarityAbiType, ClarityAbiTypeTuple, ClarityValue } from '@stacks/transactions';
+import { ClarityAbi as _ClarityAbi, ClarityAbiType, ClarityValue, ClarityAbiFunction } from 'micro-stacks/clarity';
 import { Result } from 'neverthrow';
+export declare namespace ClarityTypes {
+    type Response<Ok, Err> = Result<Ok, Err>;
+}
 export interface ClarityAbiMap {
     name: string;
-    key: {
-        name: string;
-        type: ClarityAbiType;
-    }[] | ClarityAbiTypeTuple | ClarityAbiType;
-    value: {
-        name: string;
-        type: ClarityAbiType;
-    }[] | ClarityAbiTypeTuple | ClarityAbiType;
+    key: ClarityAbiType;
+    value: ClarityAbiType;
 }
 export interface ClarityAbi extends Omit<_ClarityAbi, 'maps'> {
     maps: ClarityAbiMap[];
     clarity_version?: string;
 }
-export declare namespace ClarityTypes {
-    type BooleanCV = Clarity.BooleanCV;
-    type TrueCV = Clarity.TrueCV;
-    type FalseCV = Clarity.FalseCV;
-    type IntCV = Clarity.IntCV;
-    type UIntCV = Clarity.UIntCV;
-    type BufferCV = Clarity.BufferCV;
-    type OptionalCV = Clarity.OptionalCV;
-    type NoneCV = Clarity.NoneCV;
-    type SomeCV = Clarity.SomeCV;
-    type ResponseCV = Clarity.ResponseCV;
-    type ResponseOkCV = Clarity.ResponseOkCV;
-    type ResponseErrorCV = Clarity.ResponseErrorCV;
-    type PrincipalCV = Clarity.PrincipalCV;
-    type StandardPrincipalCV = Clarity.StandardPrincipalCV;
-    type ContractPrincipalCV = Clarity.ContractPrincipalCV;
-    type ListCV = Clarity.ListCV;
-    type TupleCV = Clarity.TupleCV;
-    type StringAsciiCV = Clarity.StringAsciiCV;
-    type StringUtf8CV = Clarity.StringUtf8CV;
-    type Response<Ok, Err> = Result<Ok, Err>;
-}
-export declare function cvToValue(val: ClarityValue): any;
+/**
+ * @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)
+ */
+export declare function cvToValue<T = any>(val: ClarityValue, returnResponse?: boolean): T;
+/**
+ * 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
+ */
+export declare function hexToCvValue<T>(hex: string, jsonCompat?: boolean): any;
 declare type TupleInput = Record<string, any>;
 declare type CVInput = string | boolean | TupleInput | number | bigint;
 export declare function parseToCV(input: CVInput, type: ClarityAbiType): ClarityValue;
 export declare function cvToString(val: ClarityValue, encoding?: 'tryAscii' | 'hex'): string;
+export declare function transformArgsToCV(func: ClarityAbiFunction, args: any[]): ClarityValue[];
+export declare function expectOk<Ok>(response: ClarityTypes.Response<Ok, any>): Ok;
+export declare function expectErr<Err>(response: ClarityTypes.Response<any, Err>): Err;
 export {};

package/dist/contracts.d.ts

@@ -0,0 +1,6 @@
+import { Contracts, ContractInstances } from './types';
+interface MakeContractsOptions {
+    deployerAddress?: string;
+}
+export declare function makeContracts<T extends Contracts<any>>(contracts: T, options?: MakeContractsOptions): ContractInstances<T>;
+export {};

package/dist/core.cjs.development.js

@@ -2,7 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var transactions = require('@stacks/transactions');
+var clarity = require('micro-stacks/clarity');
+var transactions = require('micro-stacks/transactions');
+var common = require('micro-stacks/common');
+var neverthrow = require('neverthrow');
+var api = require('micro-stacks/api');
 
 var TESTNET_BURN_ADDRESS = 'ST000000000000000000002AMW42H';
 var MAINNET_BURN_ADDRESS = 'SP000000000000000000002Q6VF78';
@@ -35,76 +39,118 @@ var getContractIdentifier = function getContractIdentifier(contract) {
 };
 var getContractPrincipalCV = function getContractPrincipalCV(contract) {
   var contractName = getContractNameFromPath(contract.contractFile);
-  return transactions.contractPrincipalCV(contract.address, contractName);
+  return clarity.contractPrincipalCV(contract.address, contractName);
 };
 function bootContractIdentifier(name, mainnet) {
   var addr = mainnet ? MAINNET_BURN_ADDRESS : TESTNET_BURN_ADDRESS;
   return addr + "." + name;
 }
 
+(function (CoreNodeEventType) {
+  CoreNodeEventType["ContractEvent"] = "contract_event";
+  CoreNodeEventType["StxTransferEvent"] = "stx_transfer_event";
+  CoreNodeEventType["StxMintEvent"] = "stx_mint_event";
+  CoreNodeEventType["StxBurnEvent"] = "stx_burn_event";
+  CoreNodeEventType["StxLockEvent"] = "stx_lock_event";
+  CoreNodeEventType["NftTransferEvent"] = "nft_transfer_event";
+  CoreNodeEventType["NftMintEvent"] = "nft_mint_event";
+  CoreNodeEventType["NftBurnEvent"] = "nft_burn_event";
+  CoreNodeEventType["FtTransferEvent"] = "ft_transfer_event";
+  CoreNodeEventType["FtMintEvent"] = "ft_mint_event";
+  CoreNodeEventType["FtBurnEvent"] = "ft_burn_event";
+})(exports.CoreNodeEventType || (exports.CoreNodeEventType = {}));
+
 function principalToString(principal) {
-  if (principal.type === transactions.ClarityType.PrincipalStandard) {
-    return transactions.addressToString(principal.address);
-  } else if (principal.type === transactions.ClarityType.PrincipalContract) {
-    var address = transactions.addressToString(principal.address);
+  if (principal.type === clarity.ClarityType.PrincipalStandard) {
+    return clarity.addressToString(principal.address);
+  } else if (principal.type === clarity.ClarityType.PrincipalContract) {
+    var address = clarity.addressToString(principal.address);
     return address + "." + principal.contractName.content;
   } else {
     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 transactions.ClarityType.BoolTrue:
+    case clarity.ClarityType.BoolTrue:
       return true;
 
-    case transactions.ClarityType.BoolFalse:
+    case clarity.ClarityType.BoolFalse:
       return false;
 
-    case transactions.ClarityType.Int:
-      return BigInt("0x" + val.value.toString('hex'));
-
-    case transactions.ClarityType.UInt:
-      return BigInt("0x" + val.value.toString('hex'));
+    case clarity.ClarityType.Int:
+    case clarity.ClarityType.UInt:
+      return val.value;
 
-    case transactions.ClarityType.Buffer:
+    case clarity.ClarityType.Buffer:
       return val.buffer;
 
-    case transactions.ClarityType.OptionalNone:
+    case clarity.ClarityType.OptionalNone:
       return null;
 
-    case transactions.ClarityType.OptionalSome:
+    case clarity.ClarityType.OptionalSome:
       return cvToValue(val.value);
 
-    case transactions.ClarityType.ResponseErr:
+    case clarity.ClarityType.ResponseErr:
+      if (returnResponse) return neverthrow.err(cvToValue(val.value));
       return cvToValue(val.value);
 
-    case transactions.ClarityType.ResponseOk:
+    case clarity.ClarityType.ResponseOk:
+      if (returnResponse) return neverthrow.ok(cvToValue(val.value));
       return cvToValue(val.value);
 
-    case transactions.ClarityType.PrincipalStandard:
-    case transactions.ClarityType.PrincipalContract:
+    case clarity.ClarityType.PrincipalStandard:
+    case clarity.ClarityType.PrincipalContract:
       return principalToString(val);
 
-    case transactions.ClarityType.List:
+    case clarity.ClarityType.List:
       return val.list.map(function (v) {
         return cvToValue(v);
       });
 
-    case transactions.ClarityType.Tuple:
+    case clarity.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;
 
-    case transactions.ClarityType.StringASCII:
+    case clarity.ClarityType.StringASCII:
       return val.data;
 
-    case transactions.ClarityType.StringUTF8:
+    case clarity.ClarityType.StringUTF8:
       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(clarity.hexToCV(hex), jsonCompat);
+}
 
 function inputToBigInt(input) {
   var isBigInt = typeof input === 'bigint';
@@ -130,105 +176,188 @@ function parseToCV(input, type) {
       var val = input[key.name];
       tuple[key.name] = parseToCV(val, key.type);
     });
-    return transactions.tupleCV(tuple);
+    return clarity.tupleCV(tuple);
   } else if (transactions.isClarityAbiList(type)) {
     var inputs = input;
     var values = inputs.map(function (input) {
       return parseToCV(input, type.list.type);
     });
-    return transactions.listCV(values);
+    return clarity.listCV(values);
   } else if (transactions.isClarityAbiOptional(type)) {
-    if (!input) return transactions.noneCV();
-    return transactions.someCV(parseToCV(input, type.optional));
+    if (!input) return clarity.noneCV();
+    return clarity.someCV(parseToCV(input, type.optional));
   } else if (transactions.isClarityAbiStringAscii(type)) {
     if (typeof input !== 'string') {
       throw new Error('Invalid string-ascii input');
     }
 
-    return transactions.stringAsciiCV(input);
+    return clarity.stringAsciiCV(input);
   } else if (transactions.isClarityAbiStringUtf8(type)) {
     if (typeof input !== 'string') {
       throw new Error('Invalid string-ascii input');
     }
 
-    return transactions.stringUtf8CV(input);
+    return clarity.stringUtf8CV(input);
   } else if (type === 'bool') {
     var inputString = typeof input === 'boolean' ? input.toString() : input;
     return transactions.parseToCV(inputString, type);
   } else if (type === 'uint128') {
     var bigi = inputToBigInt(input);
-    return transactions.uintCV(bigi.toString());
+    return clarity.uintCV(bigi.toString());
   } else if (type === 'int128') {
     var _bigi = inputToBigInt(input);
 
-    return transactions.uintCV(_bigi.toString());
+    return clarity.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 clarity.contractPrincipalCV(addr, name);
+  } else if (transactions.isClarityAbiBuffer(type)) {
+    return clarity.bufferCV(input);
   }
 
   return transactions.parseToCV(input, type);
 }
-var CLARITY_INT_SIZE = 128;
 function cvToString(val, encoding) {
   if (encoding === void 0) {
     encoding = 'hex';
   }
 
   switch (val.type) {
-    case transactions.ClarityType.BoolTrue:
+    case clarity.ClarityType.BoolTrue:
       return 'true';
 
-    case transactions.ClarityType.BoolFalse:
+    case clarity.ClarityType.BoolFalse:
       return 'false';
 
-    case transactions.ClarityType.Int:
-      return val.value.fromTwos(CLARITY_INT_SIZE).toString();
+    case clarity.ClarityType.Int:
+      return val.value.toString();
 
-    case transactions.ClarityType.UInt:
+    case clarity.ClarityType.UInt:
       return "u" + val.value.toString();
 
-    case transactions.ClarityType.Buffer:
+    case clarity.ClarityType.Buffer:
       if (encoding === 'tryAscii') {
-        var str = val.buffer.toString('ascii');
+        var str = common.bytesToAscii(val.buffer);
 
         if (/[ -~]/.test(str)) {
           return JSON.stringify(str);
         }
       }
 
-      return "0x" + val.buffer.toString('hex');
+      return "0x" + common.bytesToHex(val.buffer);
 
-    case transactions.ClarityType.OptionalNone:
+    case clarity.ClarityType.OptionalNone:
       return 'none';
 
-    case transactions.ClarityType.OptionalSome:
+    case clarity.ClarityType.OptionalSome:
       return "(some " + cvToString(val.value, encoding) + ")";
 
-    case transactions.ClarityType.ResponseErr:
+    case clarity.ClarityType.ResponseErr:
       return "(err " + cvToString(val.value, encoding) + ")";
 
-    case transactions.ClarityType.ResponseOk:
+    case clarity.ClarityType.ResponseOk:
       return "(ok " + cvToString(val.value, encoding) + ")";
 
-    case transactions.ClarityType.PrincipalStandard:
-    case transactions.ClarityType.PrincipalContract:
+    case clarity.ClarityType.PrincipalStandard:
+    case clarity.ClarityType.PrincipalContract:
       return "'" + principalToString(val);
 
-    case transactions.ClarityType.List:
+    case clarity.ClarityType.List:
       return "(list " + val.list.map(function (v) {
         return cvToString(v, encoding);
       }).join(' ') + ")";
 
-    case transactions.ClarityType.Tuple:
+    case clarity.ClarityType.Tuple:
       return "(tuple " + Object.keys(val.data).map(function (key) {
         return "(" + key + " " + cvToString(val.data[key], encoding) + ")";
       }).join(' ') + ")";
 
-    case transactions.ClarityType.StringASCII:
+    case clarity.ClarityType.StringASCII:
       return "\"" + val.data + "\"";
 
-    case transactions.ClarityType.StringUTF8:
+    case clarity.ClarityType.StringUTF8:
       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 {
@@ -1032,6 +1161,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 api.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 transactions.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) {
@@ -1073,12 +1332,20 @@ exports.BaseProvider = BaseProvider;
 exports.MAINNET_BURN_ADDRESS = MAINNET_BURN_ADDRESS;
 exports.TESTNET_BURN_ADDRESS = TESTNET_BURN_ADDRESS;
 exports.bootContractIdentifier = bootContractIdentifier;
+exports.broadcast = broadcast;
 exports.cvToString = cvToString;
 exports.cvToValue = cvToValue;
+exports.expectErr = expectErr;
+exports.expectOk = expectOk;
 exports.getContractIdentifier = getContractIdentifier;
 exports.getContractNameFromPath = getContractNameFromPath;
 exports.getContractPrincipalCV = getContractPrincipalCV;
+exports.hexToCvValue = hexToCvValue;
 exports.parseToCV = parseToCV;
 exports.proxy = proxy;
+exports.pureProxy = pureProxy;
+exports.ro = ro;
+exports.roErr = roErr;
+exports.roOk = roOk;
 exports.toCamelCase = toCamelCase;
 //# sourceMappingURL=core.cjs.development.js.map