@nadohq/shared 0.1.0-alpha.4

package/dist/utils/isWriteableContract.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/isWriteableContract.ts
+var isWriteableContract_exports = {};
+__export(isWriteableContract_exports, {
+  isWriteableContract: () => isWriteableContract
+});
+module.exports = __toCommonJS(isWriteableContract_exports);
+function isWriteableContract(contract) {
+  return "write" in contract;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isWriteableContract
+});
+//# sourceMappingURL=isWriteableContract.cjs.map

package/dist/utils/isWriteableContract.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/isWriteableContract.ts"],"sourcesContent":["import { Abi } from 'viem';\nimport {\n  ContractInstance,\n  WriteableContractInstance,\n} from '../types/viemTypes';\n\nexport function isWriteableContract<TAbi extends Abi>(\n  contract: ContractInstance<TAbi>,\n): contract is WriteableContractInstance<TAbi> {\n  return 'write' in contract;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,SAAS,oBACd,UAC6C;AAC7C,SAAO,WAAW;AACpB;","names":[]}

package/dist/utils/isWriteableContract.d.cts

@@ -0,0 +1,6 @@
+import { Abi } from 'viem';
+import { ContractInstance, WriteableContractInstance } from '../types/viemTypes.cjs';
+
+declare function isWriteableContract<TAbi extends Abi>(contract: ContractInstance<TAbi>): contract is WriteableContractInstance<TAbi>;
+
+export { isWriteableContract };

package/dist/utils/isWriteableContract.d.ts

@@ -0,0 +1,6 @@
+import { Abi } from 'viem';
+import { ContractInstance, WriteableContractInstance } from '../types/viemTypes.js';
+
+declare function isWriteableContract<TAbi extends Abi>(contract: ContractInstance<TAbi>): contract is WriteableContractInstance<TAbi>;
+
+export { isWriteableContract };

package/dist/utils/isWriteableContract.js

@@ -0,0 +1,10 @@
+import "../chunk-5WRI5ZAA.js";
+
+// src/utils/isWriteableContract.ts
+function isWriteableContract(contract) {
+  return "write" in contract;
+}
+export {
+  isWriteableContract
+};
+//# sourceMappingURL=isWriteableContract.js.map

package/dist/utils/isWriteableContract.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/isWriteableContract.ts"],"sourcesContent":["import { Abi } from 'viem';\nimport {\n  ContractInstance,\n  WriteableContractInstance,\n} from '../types/viemTypes';\n\nexport function isWriteableContract<TAbi extends Abi>(\n  contract: ContractInstance<TAbi>,\n): contract is WriteableContractInstance<TAbi> {\n  return 'write' in contract;\n}\n"],"mappings":";;;AAMO,SAAS,oBACd,UAC6C;AAC7C,SAAO,WAAW;AACpB;","names":[]}

package/dist/utils/mapValues.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/mapValues.ts
+var mapValues_exports = {};
+__export(mapValues_exports, {
+  mapValues: () => mapValues
+});
+module.exports = __toCommonJS(mapValues_exports);
+function mapValues(obj, mapFn) {
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value], index) => [
+      key,
+      mapFn(value, key, index)
+    ])
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mapValues
+});
+//# sourceMappingURL=mapValues.cjs.map

package/dist/utils/mapValues.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/mapValues.ts"],"sourcesContent":["/**\n * Map values of an object given mapFn. Avoids needing to pull in lodash\n */\nexport function mapValues<\n  TKey extends string | number | symbol,\n  TValue,\n  TNewValue,\n>(\n  obj: Record<TKey, TValue>,\n  mapFn: (value: TValue, key: TKey, index: number) => TNewValue,\n): Record<TKey, TNewValue> {\n  return Object.fromEntries(\n    Object.entries(obj).map(([key, value], index) => [\n      key,\n      mapFn(value as TValue, key as TKey, index),\n    ]),\n  ) as Record<TKey, TNewValue>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGO,SAAS,UAKd,KACA,OACyB;AACzB,SAAO,OAAO;AAAA,IACZ,OAAO,QAAQ,GAAG,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,GAAG,UAAU;AAAA,MAC/C;AAAA,MACA,MAAM,OAAiB,KAAa,KAAK;AAAA,IAC3C,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/utils/mapValues.d.cts

@@ -0,0 +1,6 @@
+/**
+ * Map values of an object given mapFn. Avoids needing to pull in lodash
+ */
+declare function mapValues<TKey extends string | number | symbol, TValue, TNewValue>(obj: Record<TKey, TValue>, mapFn: (value: TValue, key: TKey, index: number) => TNewValue): Record<TKey, TNewValue>;
+
+export { mapValues };

package/dist/utils/mapValues.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Map values of an object given mapFn. Avoids needing to pull in lodash
+ */
+declare function mapValues<TKey extends string | number | symbol, TValue, TNewValue>(obj: Record<TKey, TValue>, mapFn: (value: TValue, key: TKey, index: number) => TNewValue): Record<TKey, TNewValue>;
+
+export { mapValues };

package/dist/utils/mapValues.js

@@ -0,0 +1,15 @@
+import "../chunk-5WRI5ZAA.js";
+
+// src/utils/mapValues.ts
+function mapValues(obj, mapFn) {
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, value], index) => [
+      key,
+      mapFn(value, key, index)
+    ])
+  );
+}
+export {
+  mapValues
+};
+//# sourceMappingURL=mapValues.js.map

package/dist/utils/mapValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/mapValues.ts"],"sourcesContent":["/**\n * Map values of an object given mapFn. Avoids needing to pull in lodash\n */\nexport function mapValues<\n  TKey extends string | number | symbol,\n  TValue,\n  TNewValue,\n>(\n  obj: Record<TKey, TValue>,\n  mapFn: (value: TValue, key: TKey, index: number) => TNewValue,\n): Record<TKey, TNewValue> {\n  return Object.fromEntries(\n    Object.entries(obj).map(([key, value], index) => [\n      key,\n      mapFn(value as TValue, key as TKey, index),\n    ]),\n  ) as Record<TKey, TNewValue>;\n}\n"],"mappings":";;;AAGO,SAAS,UAKd,KACA,OACyB;AACzB,SAAO,OAAO;AAAA,IACZ,OAAO,QAAQ,GAAG,EAAE,IAAI,CAAC,CAAC,KAAK,KAAK,GAAG,UAAU;AAAA,MAC/C;AAAA,MACA,MAAM,OAAiB,KAAa,KAAK;AAAA,IAC3C,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/utils/math/BigDecimals.cjs

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/math/BigDecimals.ts
+var BigDecimals_exports = {};
+__export(BigDecimals_exports, {
+  BigDecimals: () => BigDecimals
+});
+module.exports = __toCommonJS(BigDecimals_exports);
+var import_bigDecimal = require("./bigDecimal.cjs");
+var BigDecimals = Object.freeze({
+  ZERO: (0, import_bigDecimal.toBigDecimal)(0),
+  ONE: (0, import_bigDecimal.toBigDecimal)(1),
+  INF: (0, import_bigDecimal.toBigDecimal)(Infinity),
+  MAX_I128: (0, import_bigDecimal.toBigDecimal)("170141183460469231731687303715884105727")
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BigDecimals
+});
+//# sourceMappingURL=BigDecimals.cjs.map

package/dist/utils/math/BigDecimals.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/math/BigDecimals.ts"],"sourcesContent":["import { toBigDecimal } from './bigDecimal';\n\nexport const BigDecimals = Object.freeze({\n  ZERO: toBigDecimal(0),\n  ONE: toBigDecimal(1),\n  INF: toBigDecimal(Infinity),\n  MAX_I128: toBigDecimal('170141183460469231731687303715884105727'),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAA6B;AAEtB,IAAM,cAAc,OAAO,OAAO;AAAA,EACvC,UAAM,gCAAa,CAAC;AAAA,EACpB,SAAK,gCAAa,CAAC;AAAA,EACnB,SAAK,gCAAa,QAAQ;AAAA,EAC1B,cAAU,gCAAa,yCAAyC;AAClE,CAAC;","names":[]}

package/dist/utils/math/BigDecimals.d.cts

@@ -0,0 +1,8 @@
+declare const BigDecimals: Readonly<{
+    ZERO: BigNumber;
+    ONE: BigNumber;
+    INF: BigNumber;
+    MAX_I128: BigNumber;
+}>;
+
+export { BigDecimals };

package/dist/utils/math/BigDecimals.d.ts

@@ -0,0 +1,8 @@
+declare const BigDecimals: Readonly<{
+    ZERO: BigNumber;
+    ONE: BigNumber;
+    INF: BigNumber;
+    MAX_I128: BigNumber;
+}>;
+
+export { BigDecimals };

package/dist/utils/math/BigDecimals.js

@@ -0,0 +1,14 @@
+import "../../chunk-5WRI5ZAA.js";
+
+// src/utils/math/BigDecimals.ts
+import { toBigDecimal } from "./bigDecimal.js";
+var BigDecimals = Object.freeze({
+  ZERO: toBigDecimal(0),
+  ONE: toBigDecimal(1),
+  INF: toBigDecimal(Infinity),
+  MAX_I128: toBigDecimal("170141183460469231731687303715884105727")
+});
+export {
+  BigDecimals
+};
+//# sourceMappingURL=BigDecimals.js.map

package/dist/utils/math/BigDecimals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/math/BigDecimals.ts"],"sourcesContent":["import { toBigDecimal } from './bigDecimal';\n\nexport const BigDecimals = Object.freeze({\n  ZERO: toBigDecimal(0),\n  ONE: toBigDecimal(1),\n  INF: toBigDecimal(Infinity),\n  MAX_I128: toBigDecimal('170141183460469231731687303715884105727'),\n});\n"],"mappings":";;;AAAA,SAAS,oBAAoB;AAEtB,IAAM,cAAc,OAAO,OAAO;AAAA,EACvC,MAAM,aAAa,CAAC;AAAA,EACpB,KAAK,aAAa,CAAC;AAAA,EACnB,KAAK,aAAa,QAAQ;AAAA,EAC1B,UAAU,aAAa,yCAAyC;AAClE,CAAC;","names":[]}

package/dist/utils/math/bigDecimal.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/math/bigDecimal.ts
+var bigDecimal_exports = {};
+__export(bigDecimal_exports, {
+  BigDecimal: () => import_bignumber2.default,
+  toBigDecimal: () => toBigDecimal
+});
+module.exports = __toCommonJS(bigDecimal_exports);
+var import_bignumber = __toESM(require("bignumber.js"), 1);
+var import_bignumber2 = __toESM(require("bignumber.js"), 1);
+function toBigDecimal(val) {
+  const bnConstructorVal = (() => {
+    if (val instanceof import_bignumber.default) {
+      return val;
+    } else if (typeof val === "string" || typeof val === "number") {
+      return val;
+    } else if (typeof val === "bigint") {
+      return val.toString();
+    }
+    return JSON.stringify(val);
+  })();
+  return new import_bignumber.default(bnConstructorVal);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BigDecimal,
+  toBigDecimal
+});
+//# sourceMappingURL=bigDecimal.cjs.map

package/dist/utils/math/bigDecimal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/math/bigDecimal.ts"],"sourcesContent":["import { default as BigDecimal } from 'bignumber.js';\n\n// Renames `BigNumber` type from `bignumber.js`.\nexport { default as BigDecimal } from 'bignumber.js';\n\n/**\n * BigDecimal is a renamed `BigNumber` type from `bignumber.js`.\n * Includes valid values & instances for BigDecimal.\n *\n * @see https://mikemcl.github.io/bignumber.js/\n */\nexport type BigDecimalish = BigDecimal | BigDecimal.Value | bigint;\n\n/**\n * Converts a value to an instance of BigDecimal\n *\n * @param val\n */\nexport function toBigDecimal(val: BigDecimalish): BigDecimal {\n  const bnConstructorVal = (() => {\n    if (val instanceof BigDecimal) {\n      return val;\n    } else if (typeof val === 'string' || typeof val === 'number') {\n      return val;\n    } else if (typeof val === 'bigint') {\n      return val.toString();\n    }\n    // This is unlikely to occur, but it's here for completeness. Uses the suggestion here: https://typescript-eslint.io/rules/no-base-to-string/#alternatives\n    return JSON.stringify(val);\n  })();\n  return new BigDecimal(bnConstructorVal);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,uBAAsC;AAGtC,IAAAA,oBAAsC;AAe/B,SAAS,aAAa,KAAgC;AAC3D,QAAM,oBAAoB,MAAM;AAC9B,QAAI,eAAe,iBAAAC,SAAY;AAC7B,aAAO;AAAA,IACT,WAAW,OAAO,QAAQ,YAAY,OAAO,QAAQ,UAAU;AAC7D,aAAO;AAAA,IACT,WAAW,OAAO,QAAQ,UAAU;AAClC,aAAO,IAAI,SAAS;AAAA,IACtB;AAEA,WAAO,KAAK,UAAU,GAAG;AAAA,EAC3B,GAAG;AACH,SAAO,IAAI,iBAAAA,QAAW,gBAAgB;AACxC;","names":["import_bignumber","BigDecimal"]}

package/dist/utils/math/bigDecimal.d.cts

@@ -0,0 +1,18 @@
+import BigDecimal from 'bignumber.js';
+export { default as BigDecimal } from 'bignumber.js';
+
+/**
+ * BigDecimal is a renamed `BigNumber` type from `bignumber.js`.
+ * Includes valid values & instances for BigDecimal.
+ *
+ * @see https://mikemcl.github.io/bignumber.js/
+ */
+type BigDecimalish = BigDecimal | BigDecimal.Value | bigint;
+/**
+ * Converts a value to an instance of BigDecimal
+ *
+ * @param val
+ */
+declare function toBigDecimal(val: BigDecimalish): BigDecimal;
+
+export { type BigDecimalish, toBigDecimal };

package/dist/utils/math/bigDecimal.d.ts

@@ -0,0 +1,18 @@
+import BigDecimal from 'bignumber.js';
+export { default as BigDecimal } from 'bignumber.js';
+
+/**
+ * BigDecimal is a renamed `BigNumber` type from `bignumber.js`.
+ * Includes valid values & instances for BigDecimal.
+ *
+ * @see https://mikemcl.github.io/bignumber.js/
+ */
+type BigDecimalish = BigDecimal | BigDecimal.Value | bigint;
+/**
+ * Converts a value to an instance of BigDecimal
+ *
+ * @param val
+ */
+declare function toBigDecimal(val: BigDecimalish): BigDecimal;
+
+export { type BigDecimalish, toBigDecimal };

package/dist/utils/math/bigDecimal.js

@@ -0,0 +1,23 @@
+import "../../chunk-5WRI5ZAA.js";
+
+// src/utils/math/bigDecimal.ts
+import { default as BigDecimal } from "bignumber.js";
+import { default as default2 } from "bignumber.js";
+function toBigDecimal(val) {
+  const bnConstructorVal = (() => {
+    if (val instanceof BigDecimal) {
+      return val;
+    } else if (typeof val === "string" || typeof val === "number") {
+      return val;
+    } else if (typeof val === "bigint") {
+      return val.toString();
+    }
+    return JSON.stringify(val);
+  })();
+  return new BigDecimal(bnConstructorVal);
+}
+export {
+  default2 as BigDecimal,
+  toBigDecimal
+};
+//# sourceMappingURL=bigDecimal.js.map

package/dist/utils/math/bigDecimal.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/math/bigDecimal.ts"],"sourcesContent":["import { default as BigDecimal } from 'bignumber.js';\n\n// Renames `BigNumber` type from `bignumber.js`.\nexport { default as BigDecimal } from 'bignumber.js';\n\n/**\n * BigDecimal is a renamed `BigNumber` type from `bignumber.js`.\n * Includes valid values & instances for BigDecimal.\n *\n * @see https://mikemcl.github.io/bignumber.js/\n */\nexport type BigDecimalish = BigDecimal | BigDecimal.Value | bigint;\n\n/**\n * Converts a value to an instance of BigDecimal\n *\n * @param val\n */\nexport function toBigDecimal(val: BigDecimalish): BigDecimal {\n  const bnConstructorVal = (() => {\n    if (val instanceof BigDecimal) {\n      return val;\n    } else if (typeof val === 'string' || typeof val === 'number') {\n      return val;\n    } else if (typeof val === 'bigint') {\n      return val.toString();\n    }\n    // This is unlikely to occur, but it's here for completeness. Uses the suggestion here: https://typescript-eslint.io/rules/no-base-to-string/#alternatives\n    return JSON.stringify(val);\n  })();\n  return new BigDecimal(bnConstructorVal);\n}\n"],"mappings":";;;AAAA,SAAS,WAAW,kBAAkB;AAGtC,SAAoB,WAAXA,gBAA6B;AAe/B,SAAS,aAAa,KAAgC;AAC3D,QAAM,oBAAoB,MAAM;AAC9B,QAAI,eAAe,YAAY;AAC7B,aAAO;AAAA,IACT,WAAW,OAAO,QAAQ,YAAY,OAAO,QAAQ,UAAU;AAC7D,aAAO;AAAA,IACT,WAAW,OAAO,QAAQ,UAAU;AAClC,aAAO,IAAI,SAAS;AAAA,IACtB;AAEA,WAAO,KAAK,UAAU,GAAG;AAAA,EAC3B,GAAG;AACH,SAAO,IAAI,WAAW,gBAAgB;AACxC;","names":["default"]}

package/dist/utils/math/clamp.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/math/clamp.ts
+var clamp_exports = {};
+__export(clamp_exports, {
+  clampBigDecimal: () => clampBigDecimal
+});
+module.exports = __toCommonJS(clamp_exports);
+function clampBigDecimal(val, opts) {
+  if (opts.min != null && val.lt(opts.min)) {
+    return opts.min;
+  } else if (opts.max != null && val.gt(opts.max)) {
+    return opts.max;
+  }
+  return val;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clampBigDecimal
+});
+//# sourceMappingURL=clamp.cjs.map

package/dist/utils/math/clamp.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/math/clamp.ts"],"sourcesContent":["import { BigDecimal } from './bigDecimal';\n\ninterface ClampOptions {\n  // Inclusive minimum value\n  min?: BigDecimal;\n  // Inclusive maximum value\n  max?: BigDecimal;\n}\n\n/**\n * Clamps a value between optional minimum and maximum values.\n *\n * @param val\n * @param opts Clamp options\n */\nexport function clampBigDecimal(\n  val: BigDecimal,\n  opts: ClampOptions,\n): BigDecimal {\n  if (opts.min != null && val.lt(opts.min)) {\n    return opts.min;\n  } else if (opts.max != null && val.gt(opts.max)) {\n    return opts.max;\n  }\n  return val;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAeO,SAAS,gBACd,KACA,MACY;AACZ,MAAI,KAAK,OAAO,QAAQ,IAAI,GAAG,KAAK,GAAG,GAAG;AACxC,WAAO,KAAK;AAAA,EACd,WAAW,KAAK,OAAO,QAAQ,IAAI,GAAG,KAAK,GAAG,GAAG;AAC/C,WAAO,KAAK;AAAA,EACd;AACA,SAAO;AACT;","names":[]}

package/dist/utils/math/clamp.d.cts

@@ -0,0 +1,15 @@
+import BigDecimal from 'bignumber.js';
+
+interface ClampOptions {
+    min?: BigDecimal;
+    max?: BigDecimal;
+}
+/**
+ * Clamps a value between optional minimum and maximum values.
+ *
+ * @param val
+ * @param opts Clamp options
+ */
+declare function clampBigDecimal(val: BigDecimal, opts: ClampOptions): BigDecimal;
+
+export { clampBigDecimal };

package/dist/utils/math/clamp.d.ts

@@ -0,0 +1,15 @@
+import BigDecimal from 'bignumber.js';
+
+interface ClampOptions {
+    min?: BigDecimal;
+    max?: BigDecimal;
+}
+/**
+ * Clamps a value between optional minimum and maximum values.
+ *
+ * @param val
+ * @param opts Clamp options
+ */
+declare function clampBigDecimal(val: BigDecimal, opts: ClampOptions): BigDecimal;
+
+export { clampBigDecimal };

package/dist/utils/math/clamp.js

@@ -0,0 +1,15 @@
+import "../../chunk-5WRI5ZAA.js";
+
+// src/utils/math/clamp.ts
+function clampBigDecimal(val, opts) {
+  if (opts.min != null && val.lt(opts.min)) {
+    return opts.min;
+  } else if (opts.max != null && val.gt(opts.max)) {
+    return opts.max;
+  }
+  return val;
+}
+export {
+  clampBigDecimal
+};
+//# sourceMappingURL=clamp.js.map

package/dist/utils/math/clamp.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/math/clamp.ts"],"sourcesContent":["import { BigDecimal } from './bigDecimal';\n\ninterface ClampOptions {\n  // Inclusive minimum value\n  min?: BigDecimal;\n  // Inclusive maximum value\n  max?: BigDecimal;\n}\n\n/**\n * Clamps a value between optional minimum and maximum values.\n *\n * @param val\n * @param opts Clamp options\n */\nexport function clampBigDecimal(\n  val: BigDecimal,\n  opts: ClampOptions,\n): BigDecimal {\n  if (opts.min != null && val.lt(opts.min)) {\n    return opts.min;\n  } else if (opts.max != null && val.gt(opts.max)) {\n    return opts.max;\n  }\n  return val;\n}\n"],"mappings":";;;AAeO,SAAS,gBACd,KACA,MACY;AACZ,MAAI,KAAK,OAAO,QAAQ,IAAI,GAAG,KAAK,GAAG,GAAG;AACxC,WAAO,KAAK;AAAA,EACd,WAAW,KAAK,OAAO,QAAQ,IAAI,GAAG,KAAK,GAAG,GAAG;AAC/C,WAAO,KAAK;AAAA,EACd;AACA,SAAO;AACT;","names":[]}

package/dist/utils/math/decimalAdjustment.cjs

@@ -0,0 +1,60 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/math/decimalAdjustment.ts
+var decimalAdjustment_exports = {};
+__export(decimalAdjustment_exports, {
+  NADO_PRODUCT_DECIMALS: () => NADO_PRODUCT_DECIMALS,
+  addDecimals: () => addDecimals,
+  removeDecimals: () => removeDecimals
+});
+module.exports = __toCommonJS(decimalAdjustment_exports);
+var import_bigDecimal = require("./bigDecimal.cjs");
+var NADO_PRODUCT_DECIMALS = 18;
+function addDecimals(value, decimals = NADO_PRODUCT_DECIMALS) {
+  const getResult = () => {
+    if (value == null) {
+      return void 0;
+    }
+    const adjustedValue = (0, import_bigDecimal.toBigDecimal)(value).multipliedBy(
+      (0, import_bigDecimal.toBigDecimal)(10).pow(decimals)
+    );
+    return typeof value === "number" ? adjustedValue.toNumber() : adjustedValue;
+  };
+  return getResult();
+}
+function removeDecimals(value, decimals = NADO_PRODUCT_DECIMALS) {
+  const getResult = () => {
+    if (value == null) {
+      return void 0;
+    }
+    const adjustedValue = (0, import_bigDecimal.toBigDecimal)(value).dividedBy(
+      (0, import_bigDecimal.toBigDecimal)(10).pow(decimals)
+    );
+    return typeof value === "number" ? adjustedValue.toNumber() : adjustedValue;
+  };
+  return getResult();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NADO_PRODUCT_DECIMALS,
+  addDecimals,
+  removeDecimals
+});
+//# sourceMappingURL=decimalAdjustment.cjs.map

package/dist/utils/math/decimalAdjustment.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/math/decimalAdjustment.ts"],"sourcesContent":["import { BigDecimal, BigDecimalish, toBigDecimal } from './bigDecimal';\n\n/**\n * All Nado balances have 18 decimals. Ex. 1e18 = 1.0\n */\nexport const NADO_PRODUCT_DECIMALS = 18;\n\n/**\n * Determines the result type after adjusting decimals based on the input type `T`.\n *\n * - If `T` is `undefined`, the result is `undefined`.\n * - If `T` is a `number`, the result is a `number`.\n * - Otherwise, the result is a `BigDecimal`.\n */\ntype AdjustDecimalsResult<T extends BigDecimalish | undefined> =\n  T extends undefined ? undefined : T extends number ? number : BigDecimal;\n\n/**\n * Adds the specified # of decimals to the number. For example, value = 1, decimals = 2, returns 100.\n *\n * @param value can be undefined for better developer experience. If undefined, returns undefined.\n * @param decimals number of decimal places to add, defaults to 18, which is the standard within Nado\n */\n\nexport function addDecimals<T extends BigDecimalish | undefined>(\n  value: T,\n  decimals: number = NADO_PRODUCT_DECIMALS,\n): AdjustDecimalsResult<T> {\n  const getResult = () => {\n    if (value == null) {\n      return undefined;\n    }\n\n    const adjustedValue = toBigDecimal(value).multipliedBy(\n      toBigDecimal(10).pow(decimals),\n    );\n    return typeof value === 'number' ? adjustedValue.toNumber() : adjustedValue;\n  };\n\n  return getResult() as AdjustDecimalsResult<T>;\n}\n\n/**\n * Removes the specified # of decimals from the number. For example, value = 100, decimals = 2, returns 1.\n *\n * @param value can be undefined for better developer experience. If undefined, returns undefined.\n * @param decimals number of decimal places to remove, defaults to 18, which is the standard within Nado\n */\nexport function removeDecimals<T extends BigDecimalish | undefined>(\n  value: T,\n  decimals: number = NADO_PRODUCT_DECIMALS,\n): AdjustDecimalsResult<T> {\n  const getResult = () => {\n    if (value == null) {\n      return undefined;\n    }\n\n    const adjustedValue = toBigDecimal(value).dividedBy(\n      toBigDecimal(10).pow(decimals),\n    );\n    return typeof value === 'number' ? adjustedValue.toNumber() : adjustedValue;\n  };\n\n  return getResult() as AdjustDecimalsResult<T>;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,wBAAwD;AAKjD,IAAM,wBAAwB;AAmB9B,SAAS,YACd,OACA,WAAmB,uBACM;AACzB,QAAM,YAAY,MAAM;AACtB,QAAI,SAAS,MAAM;AACjB,aAAO;AAAA,IACT;AAEA,UAAM,oBAAgB,gCAAa,KAAK,EAAE;AAAA,UACxC,gCAAa,EAAE,EAAE,IAAI,QAAQ;AAAA,IAC/B;AACA,WAAO,OAAO,UAAU,WAAW,cAAc,SAAS,IAAI;AAAA,EAChE;AAEA,SAAO,UAAU;AACnB;AAQO,SAAS,eACd,OACA,WAAmB,uBACM;AACzB,QAAM,YAAY,MAAM;AACtB,QAAI,SAAS,MAAM;AACjB,aAAO;AAAA,IACT;AAEA,UAAM,oBAAgB,gCAAa,KAAK,EAAE;AAAA,UACxC,gCAAa,EAAE,EAAE,IAAI,QAAQ;AAAA,IAC/B;AACA,WAAO,OAAO,UAAU,WAAW,cAAc,SAAS,IAAI;AAAA,EAChE;AAEA,SAAO,UAAU;AACnB;","names":[]}

package/dist/utils/math/decimalAdjustment.d.cts

@@ -0,0 +1,31 @@
+import { BigDecimalish } from './bigDecimal.cjs';
+import BigDecimal from 'bignumber.js';
+
+/**
+ * All Nado balances have 18 decimals. Ex. 1e18 = 1.0
+ */
+declare const NADO_PRODUCT_DECIMALS = 18;
+/**
+ * Determines the result type after adjusting decimals based on the input type `T`.
+ *
+ * - If `T` is `undefined`, the result is `undefined`.
+ * - If `T` is a `number`, the result is a `number`.
+ * - Otherwise, the result is a `BigDecimal`.
+ */
+type AdjustDecimalsResult<T extends BigDecimalish | undefined> = T extends undefined ? undefined : T extends number ? number : BigDecimal;
+/**
+ * Adds the specified # of decimals to the number. For example, value = 1, decimals = 2, returns 100.
+ *
+ * @param value can be undefined for better developer experience. If undefined, returns undefined.
+ * @param decimals number of decimal places to add, defaults to 18, which is the standard within Nado
+ */
+declare function addDecimals<T extends BigDecimalish | undefined>(value: T, decimals?: number): AdjustDecimalsResult<T>;
+/**
+ * Removes the specified # of decimals from the number. For example, value = 100, decimals = 2, returns 1.
+ *
+ * @param value can be undefined for better developer experience. If undefined, returns undefined.
+ * @param decimals number of decimal places to remove, defaults to 18, which is the standard within Nado
+ */
+declare function removeDecimals<T extends BigDecimalish | undefined>(value: T, decimals?: number): AdjustDecimalsResult<T>;
+
+export { NADO_PRODUCT_DECIMALS, addDecimals, removeDecimals };

package/dist/utils/math/decimalAdjustment.d.ts

@@ -0,0 +1,31 @@
+import { BigDecimalish } from './bigDecimal.js';
+import BigDecimal from 'bignumber.js';
+
+/**
+ * All Nado balances have 18 decimals. Ex. 1e18 = 1.0
+ */
+declare const NADO_PRODUCT_DECIMALS = 18;
+/**
+ * Determines the result type after adjusting decimals based on the input type `T`.
+ *
+ * - If `T` is `undefined`, the result is `undefined`.
+ * - If `T` is a `number`, the result is a `number`.
+ * - Otherwise, the result is a `BigDecimal`.
+ */
+type AdjustDecimalsResult<T extends BigDecimalish | undefined> = T extends undefined ? undefined : T extends number ? number : BigDecimal;
+/**
+ * Adds the specified # of decimals to the number. For example, value = 1, decimals = 2, returns 100.
+ *
+ * @param value can be undefined for better developer experience. If undefined, returns undefined.
+ * @param decimals number of decimal places to add, defaults to 18, which is the standard within Nado
+ */
+declare function addDecimals<T extends BigDecimalish | undefined>(value: T, decimals?: number): AdjustDecimalsResult<T>;
+/**
+ * Removes the specified # of decimals from the number. For example, value = 100, decimals = 2, returns 1.
+ *
+ * @param value can be undefined for better developer experience. If undefined, returns undefined.
+ * @param decimals number of decimal places to remove, defaults to 18, which is the standard within Nado
+ */
+declare function removeDecimals<T extends BigDecimalish | undefined>(value: T, decimals?: number): AdjustDecimalsResult<T>;
+
+export { NADO_PRODUCT_DECIMALS, addDecimals, removeDecimals };

package/dist/utils/math/decimalAdjustment.js

@@ -0,0 +1,35 @@
+import "../../chunk-5WRI5ZAA.js";
+
+// src/utils/math/decimalAdjustment.ts
+import { toBigDecimal } from "./bigDecimal.js";
+var NADO_PRODUCT_DECIMALS = 18;
+function addDecimals(value, decimals = NADO_PRODUCT_DECIMALS) {
+  const getResult = () => {
+    if (value == null) {
+      return void 0;
+    }
+    const adjustedValue = toBigDecimal(value).multipliedBy(
+      toBigDecimal(10).pow(decimals)
+    );
+    return typeof value === "number" ? adjustedValue.toNumber() : adjustedValue;
+  };
+  return getResult();
+}
+function removeDecimals(value, decimals = NADO_PRODUCT_DECIMALS) {
+  const getResult = () => {
+    if (value == null) {
+      return void 0;
+    }
+    const adjustedValue = toBigDecimal(value).dividedBy(
+      toBigDecimal(10).pow(decimals)
+    );
+    return typeof value === "number" ? adjustedValue.toNumber() : adjustedValue;
+  };
+  return getResult();
+}
+export {
+  NADO_PRODUCT_DECIMALS,
+  addDecimals,
+  removeDecimals
+};
+//# sourceMappingURL=decimalAdjustment.js.map

package/dist/utils/math/decimalAdjustment.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/utils/math/decimalAdjustment.ts"],"sourcesContent":["import { BigDecimal, BigDecimalish, toBigDecimal } from './bigDecimal';\n\n/**\n * All Nado balances have 18 decimals. Ex. 1e18 = 1.0\n */\nexport const NADO_PRODUCT_DECIMALS = 18;\n\n/**\n * Determines the result type after adjusting decimals based on the input type `T`.\n *\n * - If `T` is `undefined`, the result is `undefined`.\n * - If `T` is a `number`, the result is a `number`.\n * - Otherwise, the result is a `BigDecimal`.\n */\ntype AdjustDecimalsResult<T extends BigDecimalish | undefined> =\n  T extends undefined ? undefined : T extends number ? number : BigDecimal;\n\n/**\n * Adds the specified # of decimals to the number. For example, value = 1, decimals = 2, returns 100.\n *\n * @param value can be undefined for better developer experience. If undefined, returns undefined.\n * @param decimals number of decimal places to add, defaults to 18, which is the standard within Nado\n */\n\nexport function addDecimals<T extends BigDecimalish | undefined>(\n  value: T,\n  decimals: number = NADO_PRODUCT_DECIMALS,\n): AdjustDecimalsResult<T> {\n  const getResult = () => {\n    if (value == null) {\n      return undefined;\n    }\n\n    const adjustedValue = toBigDecimal(value).multipliedBy(\n      toBigDecimal(10).pow(decimals),\n    );\n    return typeof value === 'number' ? adjustedValue.toNumber() : adjustedValue;\n  };\n\n  return getResult() as AdjustDecimalsResult<T>;\n}\n\n/**\n * Removes the specified # of decimals from the number. For example, value = 100, decimals = 2, returns 1.\n *\n * @param value can be undefined for better developer experience. If undefined, returns undefined.\n * @param decimals number of decimal places to remove, defaults to 18, which is the standard within Nado\n */\nexport function removeDecimals<T extends BigDecimalish | undefined>(\n  value: T,\n  decimals: number = NADO_PRODUCT_DECIMALS,\n): AdjustDecimalsResult<T> {\n  const getResult = () => {\n    if (value == null) {\n      return undefined;\n    }\n\n    const adjustedValue = toBigDecimal(value).dividedBy(\n      toBigDecimal(10).pow(decimals),\n    );\n    return typeof value === 'number' ? adjustedValue.toNumber() : adjustedValue;\n  };\n\n  return getResult() as AdjustDecimalsResult<T>;\n}\n"],"mappings":";;;AAAA,SAAoC,oBAAoB;AAKjD,IAAM,wBAAwB;AAmB9B,SAAS,YACd,OACA,WAAmB,uBACM;AACzB,QAAM,YAAY,MAAM;AACtB,QAAI,SAAS,MAAM;AACjB,aAAO;AAAA,IACT;AAEA,UAAM,gBAAgB,aAAa,KAAK,EAAE;AAAA,MACxC,aAAa,EAAE,EAAE,IAAI,QAAQ;AAAA,IAC/B;AACA,WAAO,OAAO,UAAU,WAAW,cAAc,SAAS,IAAI;AAAA,EAChE;AAEA,SAAO,UAAU;AACnB;AAQO,SAAS,eACd,OACA,WAAmB,uBACM;AACzB,QAAM,YAAY,MAAM;AACtB,QAAI,SAAS,MAAM;AACjB,aAAO;AAAA,IACT;AAEA,UAAM,gBAAgB,aAAa,KAAK,EAAE;AAAA,MACxC,aAAa,EAAE,EAAE,IAAI,QAAQ;AAAA,IAC/B;AACA,WAAO,OAAO,UAAU,WAAW,cAAc,SAAS,IAAI;AAAA,EAChE;AAEA,SAAO,UAAU;AACnB;","names":[]}