@digitalworld/digital-world-sdk 16.0.0

package/lib/esm/base/scval.js

@@ -0,0 +1,249 @@
+import { Buffer } from 'buffer';
+import types from './generated/curr_generated.js';
+import { Keypair } from './keypair.js';
+import { Address } from './address.js';
+import { Contract } from './contract.js';
+import { scValToBigInt } from './numbers/index.js';
+import { XdrLargeInt } from './numbers/xdr_large_int.js';
+import { ScInt } from './numbers/sc_int.js';
+
+function nativeToScVal(val, opts = {}) {
+  switch (typeof val) {
+    case "object": {
+      if (val === null) {
+        return types.ScVal.scvVoid();
+      }
+      if (val instanceof types.ScVal) {
+        return val;
+      }
+      if (val instanceof Address) {
+        return val.toScVal();
+      }
+      if (val instanceof Keypair) {
+        return nativeToScVal(val.publicKey(), { type: "address" });
+      }
+      if (val instanceof Contract) {
+        return val.address().toScVal();
+      }
+      if (val instanceof Uint8Array || Buffer.isBuffer(val)) {
+        const copy = Buffer.from(val);
+        switch (opts?.type ?? "bytes") {
+          case "bytes":
+            return types.ScVal.scvBytes(copy);
+          case "symbol":
+            return types.ScVal.scvSymbol(copy);
+          case "string":
+            return types.ScVal.scvString(copy);
+          default:
+            throw new TypeError(
+              `invalid type (${JSON.stringify(opts.type)}) specified for bytes-like value`
+            );
+        }
+      }
+      if (Array.isArray(val)) {
+        return types.ScVal.scvVec(
+          val.map((v, idx) => {
+            if (Array.isArray(opts.type)) {
+              return nativeToScVal(
+                v,
+                // only include a `{ type: ... }` if it's present (safer than
+                // `{type: undefined}`)
+                {
+                  ...opts.type.length > idx && {
+                    type: opts.type[idx]
+                  }
+                }
+              );
+            }
+            return nativeToScVal(v, opts);
+          })
+        );
+      }
+      if (Object.getPrototypeOf(val) !== Object.prototype) {
+        throw new TypeError(
+          `cannot interpret ${val.constructor?.name} value as ScVal (${JSON.stringify(val)})`
+        );
+      }
+      const mapTypeSpec = opts?.type ?? {};
+      return types.ScVal.scvMap(
+        Object.entries(val).sort(([key1], [key2]) => key1 < key2 ? -1 : key1 > key2 ? 1 : 0).map(([k, v]) => {
+          const [keyType, valType] = Object.hasOwn(mapTypeSpec, k) ? mapTypeSpec[k] ?? [null, null] : [null, null];
+          const keyOpts = keyType ? { type: keyType } : {};
+          const valOpts = valType ? { type: valType } : {};
+          return new types.ScMapEntry({
+            key: nativeToScVal(k, keyOpts),
+            val: nativeToScVal(v, valOpts)
+          });
+        })
+      );
+    }
+    case "number":
+    case "bigint": {
+      const bigintVal = BigInt(val);
+      switch (opts?.type) {
+        case "u32":
+          if (bigintVal < BigInt(types.Uint32.MIN_VALUE) || bigintVal > BigInt(types.Uint32.MAX_VALUE)) {
+            throw new TypeError(`invalid value (${val}) for type u32`);
+          }
+          return types.ScVal.scvU32(Number(val));
+        case "i32":
+          if (bigintVal < -BigInt(types.Int32.MIN_VALUE) || bigintVal > BigInt(types.Int32.MAX_VALUE)) {
+            throw new TypeError(`invalid value (${val}) for type i32`);
+          }
+          return types.ScVal.scvI32(Number(val));
+      }
+      return new ScInt(val, { type: opts?.type }).toScVal();
+    }
+    case "string": {
+      const optType = opts?.type ?? "string";
+      switch (optType) {
+        case "string":
+          return types.ScVal.scvString(val);
+        case "symbol":
+          return types.ScVal.scvSymbol(val);
+        case "address":
+          return new Address(val).toScVal();
+        case "u32": {
+          const bigintVal = BigInt(val);
+          if (bigintVal < BigInt(types.Uint32.MIN_VALUE) || bigintVal > BigInt(types.Uint32.MAX_VALUE)) {
+            throw new TypeError(`invalid value (${val}) for type u32`);
+          }
+          return types.ScVal.scvU32(Number(bigintVal));
+        }
+        case "i32": {
+          const bigintVal = BigInt(val);
+          if (bigintVal < -BigInt(types.Int32.MIN_VALUE) || bigintVal > BigInt(types.Int32.MAX_VALUE)) {
+            throw new TypeError(`invalid value (${val}) for type i32`);
+          }
+          return types.ScVal.scvI32(Number(bigintVal));
+        }
+        default:
+          if (XdrLargeInt.isType(optType)) {
+            return new XdrLargeInt(optType, val).toScVal();
+          }
+          throw new TypeError(
+            `invalid type (${JSON.stringify(opts.type)}) specified for string value`
+          );
+      }
+    }
+    case "boolean":
+      return types.ScVal.scvBool(val);
+    case "undefined":
+      return types.ScVal.scvVoid();
+    case "function":
+      return nativeToScVal(val());
+    default:
+      throw new TypeError(
+        `failed to convert typeof ${typeof val} (${JSON.stringify(val)})`
+      );
+  }
+}
+function scValToNative(scv) {
+  switch (scv.switch().value) {
+    case types.ScValType.scvVoid().value:
+      return null;
+    // these can be converted to bigints directly
+    case types.ScValType.scvU64().value:
+    case types.ScValType.scvI64().value:
+      return scv.value().toBigInt();
+    // these can be parsed by internal abstractions note that this can also
+    // handle the above two cases, but it's not as efficient (another
+    // type-check, parsing, etc.)
+    case types.ScValType.scvU128().value:
+    case types.ScValType.scvI128().value:
+    case types.ScValType.scvU256().value:
+    case types.ScValType.scvI256().value:
+      return scValToBigInt(scv);
+    case types.ScValType.scvVec().value:
+      return (scv.vec() ?? []).map(scValToNative);
+    case types.ScValType.scvAddress().value:
+      return Address.fromScVal(scv).toString();
+    case types.ScValType.scvMap().value:
+      return Object.fromEntries(
+        (scv.map() ?? []).map((entry) => [
+          scValToNative(entry.key()),
+          scValToNative(entry.val())
+        ])
+      );
+    // these return the primitive type directly
+    case types.ScValType.scvBool().value:
+    case types.ScValType.scvU32().value:
+    case types.ScValType.scvI32().value:
+    case types.ScValType.scvBytes().value:
+      return scv.value();
+    // Symbols are limited to [a-zA-Z0-9_]+, so we can safely make ascii strings
+    //
+    // Strings, however, are "presented" as strings and we treat them as such
+    // (in other words, string = bytes with a hint that it's text). If the user
+    // encoded non-printable bytes in their string value, that's on them.
+    //
+    // Note that we assume a utf8 encoding (ascii-compatible). For other
+    // encodings, you should probably use bytes anyway. If it cannot be decoded,
+    // the raw bytes are returned.
+    case types.ScValType.scvSymbol().value: {
+      const v = scv.sym();
+      if (Buffer.isBuffer(v) || ArrayBuffer.isView(v) && typeof v !== "string") {
+        try {
+          return new TextDecoder().decode(v);
+        } catch {
+          return new Uint8Array(v.buffer);
+        }
+      }
+      return v;
+    }
+    case types.ScValType.scvString().value: {
+      const v = scv.str();
+      if (Buffer.isBuffer(v) || ArrayBuffer.isView(v) && typeof v !== "string") {
+        try {
+          return new TextDecoder().decode(v);
+        } catch {
+          return new Uint8Array(v.buffer);
+        }
+      }
+      return v;
+    }
+    // these can be converted to bigint
+    case types.ScValType.scvTimepoint().value:
+    case types.ScValType.scvDuration().value:
+      return scv.value().toBigInt();
+    case types.ScValType.scvError().value:
+      switch (scv.error().switch().value) {
+        // Distinguish errors from the user contract.
+        case types.ScErrorType.sceContract().value:
+          return { type: "contract", code: scv.error().contractCode() };
+        default: {
+          const err = scv.error();
+          return {
+            type: "system",
+            code: err.code().value,
+            value: err.code().name
+          };
+        }
+      }
+    // in the fallthrough case, just return the underlying value directly
+    default:
+      return scv.value();
+  }
+}
+function scvSortedMap(items) {
+  const sorted = Array.from(items).sort((a, b) => {
+    const nativeA = scValToNative(a.key());
+    const nativeB = scValToNative(b.key());
+    switch (typeof nativeA) {
+      case "number":
+      case "bigint":
+        if (nativeA === nativeB) return 0;
+        return nativeA < nativeB ? -1 : 1;
+      default: {
+        const strA = nativeA.toString();
+        const strB = nativeB.toString();
+        return strA < strB ? -1 : strA > strB ? 1 : 0;
+      }
+    }
+  });
+  return types.ScVal.scvMap(sorted);
+}
+types.scvSortedMap = scvSortedMap;
+
+export { nativeToScVal, scValToNative, scvSortedMap };
+//# sourceMappingURL=scval.js.map

package/lib/esm/base/scval.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scval.js","sources":["../../../src/base/scval.ts"],"sourcesContent":["import xdr from \"./xdr.js\";\nimport { Keypair } from \"./keypair.js\";\nimport { Address } from \"./address.js\";\nimport { Contract } from \"./contract.js\";\nimport { ScInt, XdrLargeInt, scValToBigInt } from \"./numbers/index.js\";\nimport type { ScIntType } from \"./numbers/index.js\";\n\ntype ScValIntType = ScIntType | \"i32\" | \"u32\";\ntype ScValStringType = ScValIntType | \"address\" | \"string\" | \"symbol\";\ntype ScValBytesType = \"bytes\" | \"string\" | \"symbol\";\ntype ScValType = ScValBytesType | ScValIntType | ScValStringType;\n\ntype ScValMapTypeSpec = Record<\n  string,\n  [(ScValType | null)?, (ScValType | null)?]\n>;\n\nexport interface NativeToScValOpts {\n  type?: (ScValType | null)[] | ScValMapTypeSpec | ScValType | undefined;\n}\n\n/**\n * Attempts to convert native types into smart contract values\n * ({@link xdr.ScVal}).\n *\n * Provides conversions from smart contract XDR values ({@link xdr.ScVal}) to\n * native JavaScript types.\n *\n * The conversions are as follows:\n *\n *  - `xdr.ScVal` → passthrough\n *  - `null` / `undefined` → `scvVoid`\n *  - `string` → `scvString` (a copy is made)\n *  - `UintArray8` → `scvBytes` (a copy is made)\n *  - `boolean` → `scvBool`\n *\n *  - `number` / `bigint` → the smallest possible XDR integer type that will fit\n *    the input value (if you want a specific type, use {@link ScInt})\n *\n *  - {@link Address} or {@link Contract} → `scvAddress` (for contracts and\n *    public keys)\n *\n *  - `Array<T>` → `scvVec` after attempting to convert each item of type `T` to\n *    an `xdr.ScVal` (recursively). note that all values must be the same type!\n *\n *  - `object` → `scvMap` after attempting to convert each key and value to an\n *    `xdr.ScVal` (recursively). note that there is no restriction on types\n *    matching anywhere (unlike arrays)\n *\n * When passing an integer-like native value, you can also optionally specify a\n * type which will force a particular interpretation of that value.\n *\n * Note that not all type specifications are compatible with all `ScVal`s, e.g.\n * `toScVal(\"a string\", {type: \"i256\"})` will throw.\n *\n * @param val -       a native (or convertible) input value to wrap\n * @param opts - an optional set of hints around the type of\n *    conversion you'd like to see\n *   - `type`: there is different behavior for different input\n *    types for `val`:\n *\n *     - when `val` is an integer-like type (i.e. number|bigint), this will be\n *       forwarded to {@link ScInt} or forced to be u32/i32.\n *\n *     - when `val` is an array type, this is forwarded to the recursion\n *\n *     - when `val` is an object type (key-value entries), this should be an\n *       object in which each key has a pair of types (to represent forced types\n *       for the key and the value), where `null` (or a missing entry) indicates\n *       the default interpretation(s) (refer to the examples, below)\n *\n *     - when `val` is a string type, this can be 'string' or 'symbol' to force\n *       a particular interpretation of `val`.\n *\n *     - when `val` is a bytes-like type, this can be 'string', 'symbol', or\n *       'bytes' to force a particular interpretation\n *\n *    As a simple example, `nativeToScVal(\"hello\", {type: 'symbol'})` will\n *    return an `scvSymbol`, whereas without the type it would have been an\n *    `scvString`.\n *\n * @throws if...\n *  - there are arrays with more than one type in them\n *  - there are values that do not have a sensible conversion (e.g. random XDR\n *    types, custom classes)\n *  - the type of the input object (or some inner value of said object) cannot\n *    be determined (via `typeof`)\n *  - the type you specified (via `opts.type`) is incompatible with the value\n *    you passed in (`val`), e.g. `nativeToScVal(\"a string\", { type: 'i128' })`,\n *    though this does not apply for types that ignore `opts` (e.g. addresses).\n * @see scValToNative\n *\n * @example\n * ```ts\n * nativeToScVal(1000);                   // gives ScValType === scvU64\n * nativeToScVal(1000n);                  // gives ScValType === scvU64\n * nativeToScVal(1n << 100n);             // gives ScValType === scvU128\n * nativeToScVal(1000, { type: 'u32' });  // gives ScValType === scvU32\n * nativeToScVal(1000, { type: 'i125' }); // gives ScValType === scvI256\n * nativeToScVal(\"a string\");                     // gives ScValType === scvString\n * nativeToScVal(\"a string\", { type: 'symbol' }); // gives scvSymbol\n * nativeToScVal(new Uint8Array(5));                      // scvBytes\n * nativeToScVal(new Uint8Array(5), { type: 'symbol' });  // scvSymbol\n * nativeToScVal(null); // scvVoid\n * nativeToScVal(true); // scvBool\n * nativeToScVal([1, 2, 3]);                    // gives scvVec with each element as scvU64\n * nativeToScVal([1, 2, 3], { type: 'i128' });  // scvVec<scvI128>\n * nativeToScVal([1, '2'], { type: ['i128', 'symbol'] });  // scvVec with diff types\n * nativeToScVal([1, '2', 3], { type: ['i128', 'symbol'] });\n *    // scvVec with diff types, using the default when omitted\n * nativeToScVal({ 'hello': 1, 'world': [ true, false ] }, {\n *   type: {\n *     'hello': [ 'symbol', 'i128' ],\n *   }\n * })\n * // gives scvMap with entries: [\n * //     [ scvSymbol, scvI128 ],\n * //     [ scvString, scvArray<scvBool> ]\n * // ]\n * ```\n *\n * @example\n * ```ts\n * import {\n *   nativeToScVal,\n *   scValToNative,\n *   ScInt,\n *   xdr\n * } from '@digitalworld/digital-world-sdk';\n *\n * let gigaMap = {\n *   bool: true,\n *   void: null,\n *   u32: xdr.ScVal.scvU32(1),\n *   i32: xdr.ScVal.scvI32(1),\n *   u64: 1n,\n *   i64: -1n,\n *   u128: new ScInt(1).toU128(),\n *   i128: new ScInt(1).toI128(),\n *   u256: new ScInt(1).toU256(),\n *   i256: new ScInt(1).toI256(),\n *   map: {\n *     arbitrary: 1n,\n *     nested: 'values',\n *     etc: false\n *   },\n *   vec: ['same', 'type', 'list'],\n *   vec: ['diff', 1, 'type', 2, 'list'],\n * };\n *\n * // then, simply:\n * let scv = nativeToScVal(gigaMap);    // scv.switch() == xdr.ScValType.scvMap()\n *\n * // then...\n * someContract.call(\"method\", scv);\n *\n * // Similarly, the inverse should work:\n * scValToNative(scv) == gigaMap;       // true\n * ```\n */\nexport function nativeToScVal(\n  val: unknown,\n  opts: NativeToScValOpts = {},\n): xdr.ScVal {\n  switch (typeof val) {\n    case \"object\": {\n      if (val === null) {\n        return xdr.ScVal.scvVoid();\n      }\n\n      if (val instanceof xdr.ScVal) {\n        return val; // should we copy?\n      }\n\n      if (val instanceof Address) {\n        return val.toScVal();\n      }\n\n      if (val instanceof Keypair) {\n        return nativeToScVal(val.publicKey(), { type: \"address\" });\n      }\n\n      if (val instanceof Contract) {\n        return val.address().toScVal();\n      }\n\n      if (val instanceof Uint8Array || Buffer.isBuffer(val)) {\n        const copy = Buffer.from(val);\n        switch ((opts?.type as string) ?? \"bytes\") {\n          case \"bytes\":\n            return xdr.ScVal.scvBytes(copy);\n          case \"symbol\":\n            return xdr.ScVal.scvSymbol(copy);\n          case \"string\":\n            return xdr.ScVal.scvString(copy);\n          default:\n            throw new TypeError(\n              `invalid type (${JSON.stringify(opts.type)}) specified for bytes-like value`,\n            );\n        }\n      }\n\n      if (Array.isArray(val)) {\n        return xdr.ScVal.scvVec(\n          val.map((v: unknown, idx: number) => {\n            // There may be different type specifications for each element in\n            // the array, so we need to apply those accordingly.\n            if (Array.isArray(opts.type)) {\n              return nativeToScVal(\n                v,\n                // only include a `{ type: ... }` if it's present (safer than\n                // `{type: undefined}`)\n                {\n                  ...(opts.type.length > idx && {\n                    type: opts.type[idx] as ScValType,\n                  }),\n                },\n              );\n            }\n\n            // Otherwise apply a generic (or missing) type specifier on it.\n            return nativeToScVal(v, opts);\n          }),\n        );\n      }\n\n      if (Object.getPrototypeOf(val) !== Object.prototype) {\n        throw new TypeError(\n          `cannot interpret ${\n            val.constructor?.name\n          } value as ScVal (${JSON.stringify(val)})`,\n        );\n      }\n\n      const mapTypeSpec = (opts?.type ?? {}) as ScValMapTypeSpec;\n\n      return xdr.ScVal.scvMap(\n        Object.entries(val as Record<string, unknown>)\n          // The Soroban runtime expects maps to have their keys in sorted\n          // order, so let's do that here as part of the conversion to prevent\n          // confusing error messages on execution.\n          .sort(([key1], [key2]) => (key1 < key2 ? -1 : key1 > key2 ? 1 : 0))\n          .map(([k, v]) => {\n            // the type can be specified with an entry for the key and the value,\n            // e.g. val = { 'hello': 1 } and opts.type = { hello: [ 'symbol',\n            // 'u128' ]} or you can use `null` for the default interpretation\n            const [keyType, valType] = Object.hasOwn(mapTypeSpec, k)\n              ? (mapTypeSpec[k] ?? [null, null])\n              : [null, null];\n            const keyOpts: NativeToScValOpts = keyType ? { type: keyType } : {};\n            const valOpts: NativeToScValOpts = valType ? { type: valType } : {};\n\n            return new xdr.ScMapEntry({\n              key: nativeToScVal(k, keyOpts),\n              val: nativeToScVal(v, valOpts),\n            });\n          }),\n      );\n    }\n\n    case \"number\":\n    case \"bigint\": {\n      const bigintVal = BigInt(val);\n      switch (opts?.type) {\n        case \"u32\":\n          if (\n            bigintVal < BigInt(xdr.Uint32.MIN_VALUE) ||\n            bigintVal > BigInt(xdr.Uint32.MAX_VALUE)\n          ) {\n            throw new TypeError(`invalid value (${val}) for type u32`);\n          }\n          return xdr.ScVal.scvU32(Number(val));\n        case \"i32\":\n          if (\n            bigintVal < -BigInt(xdr.Int32.MIN_VALUE) ||\n            bigintVal > BigInt(xdr.Int32.MAX_VALUE)\n          ) {\n            throw new TypeError(`invalid value (${val}) for type i32`);\n          }\n          return xdr.ScVal.scvI32(Number(val));\n\n        default:\n          break;\n      }\n\n      return new ScInt(val, { type: opts?.type as ScIntType }).toScVal();\n    }\n    case \"string\": {\n      const optType = (opts?.type as string) ?? \"string\";\n      switch (optType) {\n        case \"string\":\n          return xdr.ScVal.scvString(val);\n\n        case \"symbol\":\n          return xdr.ScVal.scvSymbol(val);\n\n        case \"address\":\n          return new Address(val).toScVal();\n\n        case \"u32\": {\n          const bigintVal = BigInt(val);\n          if (\n            bigintVal < BigInt(xdr.Uint32.MIN_VALUE) ||\n            bigintVal > BigInt(xdr.Uint32.MAX_VALUE)\n          ) {\n            throw new TypeError(`invalid value (${val}) for type u32`);\n          }\n          return xdr.ScVal.scvU32(Number(bigintVal));\n        }\n\n        case \"i32\": {\n          const bigintVal = BigInt(val);\n          // TODO: Update this check once xdr.Int32.MIN_VALUE in XDR is properly\n          // set to negative. Check this globally.\n          if (\n            bigintVal < -BigInt(xdr.Int32.MIN_VALUE) ||\n            bigintVal > BigInt(xdr.Int32.MAX_VALUE)\n          ) {\n            throw new TypeError(`invalid value (${val}) for type i32`);\n          }\n          return xdr.ScVal.scvI32(Number(bigintVal));\n        }\n\n        default:\n          if (XdrLargeInt.isType(optType)) {\n            return new XdrLargeInt(optType, val).toScVal();\n          }\n\n          throw new TypeError(\n            `invalid type (${JSON.stringify(opts.type)}) specified for string value`,\n          );\n      }\n    }\n\n    case \"boolean\":\n      return xdr.ScVal.scvBool(val);\n\n    case \"undefined\":\n      return xdr.ScVal.scvVoid();\n\n    case \"function\": // FIXME: Is this too helpful?\n      return nativeToScVal((val as () => unknown)());\n\n    default:\n      throw new TypeError(\n        `failed to convert typeof ${typeof val} (${JSON.stringify(val)})`,\n      );\n  }\n}\n\n/**\n * Given a smart contract value, attempt to convert it to a native type.\n * Possible conversions include:\n *\n *  - `void` → `null`\n *  - `u32`, `i32` → `number`\n *  - `u64`, `i64`, `u128`, `i128`, `u256`, `i256`, `timepoint`, `duration` →\n *    `bigint`\n *  - `vec` → `Array` of any of the above (via recursion)\n *  - `map` → key-value object of any of the above (via recursion)\n *  - `bool` → `boolean`\n *  - `bytes` → `Uint8Array`\n *  - `symbol` → `string`\n *  - `string` → `string` IF the underlying buffer can be decoded as ascii/utf8,\n *              `Uint8Array` of the raw contents in any error case\n *\n * If no viable conversion can be determined, this just \"unwraps\" the smart\n * value to return its underlying XDR value.\n *\n * @param scv - the input smart contract value\n *\n * @see nativeToScVal\n */\n\nexport function scValToNative(scv: xdr.ScVal): any {\n  // we use the verbose xdr.ScValType.<type>.value form here because it's faster\n  // than string comparisons and the underlying constants never need to be\n  // updated\n  switch (scv.switch().value) {\n    case xdr.ScValType.scvVoid().value:\n      return null;\n\n    // these can be converted to bigints directly\n    case xdr.ScValType.scvU64().value:\n    case xdr.ScValType.scvI64().value:\n      return (scv.value() as xdr.Int64 | xdr.Uint64).toBigInt();\n\n    // these can be parsed by internal abstractions note that this can also\n    // handle the above two cases, but it's not as efficient (another\n    // type-check, parsing, etc.)\n    case xdr.ScValType.scvU128().value:\n    case xdr.ScValType.scvI128().value:\n    case xdr.ScValType.scvU256().value:\n    case xdr.ScValType.scvI256().value:\n      return scValToBigInt(scv);\n\n    case xdr.ScValType.scvVec().value:\n      return (scv.vec() ?? []).map(scValToNative);\n\n    case xdr.ScValType.scvAddress().value:\n      return Address.fromScVal(scv).toString();\n\n    case xdr.ScValType.scvMap().value:\n      return Object.fromEntries(\n        (scv.map() ?? []).map((entry: xdr.ScMapEntry) => [\n          scValToNative(entry.key()),\n          scValToNative(entry.val()),\n        ]),\n      );\n\n    // these return the primitive type directly\n    case xdr.ScValType.scvBool().value:\n    case xdr.ScValType.scvU32().value:\n    case xdr.ScValType.scvI32().value:\n    case xdr.ScValType.scvBytes().value:\n      return scv.value();\n\n    // Symbols are limited to [a-zA-Z0-9_]+, so we can safely make ascii strings\n    //\n    // Strings, however, are \"presented\" as strings and we treat them as such\n    // (in other words, string = bytes with a hint that it's text). If the user\n    // encoded non-printable bytes in their string value, that's on them.\n    //\n    // Note that we assume a utf8 encoding (ascii-compatible). For other\n    // encodings, you should probably use bytes anyway. If it cannot be decoded,\n    // the raw bytes are returned.\n    case xdr.ScValType.scvSymbol().value: {\n      const v = scv.sym();\n      if (\n        Buffer.isBuffer(v) ||\n        (ArrayBuffer.isView(v) && typeof v !== \"string\")\n      ) {\n        try {\n          return new TextDecoder().decode(v);\n        } catch {\n          return new Uint8Array((v as ArrayBufferView).buffer); // copy of bytes\n        }\n      }\n      return v; // string already\n    }\n    case xdr.ScValType.scvString().value: {\n      const v = scv.str();\n      if (\n        Buffer.isBuffer(v) ||\n        (ArrayBuffer.isView(v) && typeof v !== \"string\")\n      ) {\n        try {\n          return new TextDecoder().decode(v);\n        } catch {\n          return new Uint8Array((v as ArrayBufferView).buffer); // copy of bytes\n        }\n      }\n      return v; // string already\n    }\n\n    // these can be converted to bigint\n    case xdr.ScValType.scvTimepoint().value:\n    case xdr.ScValType.scvDuration().value:\n      return (scv.value() as xdr.Uint64).toBigInt();\n\n    case xdr.ScValType.scvError().value:\n      switch (scv.error().switch().value) {\n        // Distinguish errors from the user contract.\n        case xdr.ScErrorType.sceContract().value:\n          return { type: \"contract\", code: scv.error().contractCode() };\n        default: {\n          const err = scv.error();\n          return {\n            type: \"system\",\n            code: err.code().value,\n            value: err.code().name,\n          };\n        }\n      }\n\n    // in the fallthrough case, just return the underlying value directly\n    default:\n      return scv.value();\n  }\n}\n\n/**\n * Build a sorted ScVal map from unsorted entries, sorted by key.\n *\n * @param items - the unsorted map entries\n */\nexport function scvSortedMap(items: xdr.ScMapEntry[]): xdr.ScVal {\n  const sorted = Array.from(items).sort((a, b) => {\n    // Both a and b are `ScMapEntry`s, so we need to sort by underlying key.\n    //\n    // We couldn't possibly handle every combination of keys since Soroban\n    // maps don't enforce consistent types, so we do a best-effort and try\n    // sorting by \"number-like\" or \"string-like.\"\n    const nativeA = scValToNative(a.key()) as bigint | number | string;\n    const nativeB = scValToNative(b.key()) as bigint | number | string;\n\n    switch (typeof nativeA) {\n      case \"number\":\n      case \"bigint\":\n        if (nativeA === nativeB) return 0;\n        return nativeA < (nativeB as bigint | number) ? -1 : 1;\n\n      default: {\n        const strA = nativeA.toString();\n        const strB = nativeB.toString();\n        return strA < strB ? -1 : strA > strB ? 1 : 0;\n      }\n    }\n  });\n\n  return xdr.ScVal.scvMap(sorted);\n}\n\n// Inject a sortable map builder into the xdr module for backwards compatibility.\nxdr.scvSortedMap = scvSortedMap;\n"],"names":["xdr"],"mappings":"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"}

package/lib/esm/base/signerkey.d.ts

@@ -0,0 +1,27 @@
+import xdr from "./xdr.js";
+/**
+ * A container class with helpers to convert between signer keys
+ * (`xdr.SignerKey`) and {@link StrKey}s.
+ *
+ * It's primarily used for manipulating the `extraSigners` precondition on a
+ * {@link Transaction}.
+ *
+ * @see {@link TransactionBuilder.setExtraSigners}
+ */
+export declare class SignerKey {
+    /**
+     * Decodes a StrKey address into an xdr.SignerKey instance.
+     *
+     * Only ED25519 public keys (G...), pre-auth transactions (T...), hashes
+     * (H...), and signed payloads (P...) can be signer keys.
+     *
+     * @param address - a StrKey-encoded signer address
+     */
+    static decodeAddress(address: string): xdr.SignerKey;
+    /**
+     * Encodes a signer key into its StrKey equivalent.
+     *
+     * @param signerKey - the signer
+     */
+    static encodeSignerKey(signerKey: xdr.SignerKey): string;
+}

package/lib/esm/base/signerkey.js

@@ -0,0 +1,70 @@
+import types from './generated/curr_generated.js';
+import { StrKey, decodeCheck, encodeCheck } from './strkey.js';
+
+class SignerKey {
+  /**
+   * Decodes a StrKey address into an xdr.SignerKey instance.
+   *
+   * Only ED25519 public keys (G...), pre-auth transactions (T...), hashes
+   * (H...), and signed payloads (P...) can be signer keys.
+   *
+   * @param address - a StrKey-encoded signer address
+   */
+  static decodeAddress(address) {
+    const vb = StrKey.getVersionByteForPrefix(address);
+    if (vb === void 0) {
+      throw new Error(`invalid signer key type (${vb})`);
+    }
+    const raw = decodeCheck(vb, address);
+    switch (vb) {
+      case "signedPayload":
+        return types.SignerKey.signerKeyTypeEd25519SignedPayload(
+          new types.SignerKeyEd25519SignedPayload({
+            ed25519: raw.subarray(0, 32),
+            payload: raw.subarray(36, 36 + raw.readUInt32BE(32))
+          })
+        );
+      case "ed25519PublicKey":
+        return types.SignerKey.signerKeyTypeEd25519(raw);
+      case "preAuthTx":
+        return types.SignerKey.signerKeyTypePreAuthTx(raw);
+      case "sha256Hash":
+        return types.SignerKey.signerKeyTypeHashX(raw);
+      default:
+        throw new Error(`invalid signer key type (${vb})`);
+    }
+  }
+  /**
+   * Encodes a signer key into its StrKey equivalent.
+   *
+   * @param signerKey - the signer
+   */
+  static encodeSignerKey(signerKey) {
+    let strkeyType;
+    let raw;
+    switch (signerKey.switch()) {
+      case types.SignerKeyType.signerKeyTypeEd25519():
+        strkeyType = "ed25519PublicKey";
+        raw = signerKey.value();
+        break;
+      case types.SignerKeyType.signerKeyTypePreAuthTx():
+        strkeyType = "preAuthTx";
+        raw = signerKey.value();
+        break;
+      case types.SignerKeyType.signerKeyTypeHashX():
+        strkeyType = "sha256Hash";
+        raw = signerKey.value();
+        break;
+      case types.SignerKeyType.signerKeyTypeEd25519SignedPayload():
+        strkeyType = "signedPayload";
+        raw = signerKey.ed25519SignedPayload().toXDR("raw");
+        break;
+      default:
+        throw new Error(`invalid SignerKey (type: ${signerKey.switch().name})`);
+    }
+    return encodeCheck(strkeyType, raw);
+  }
+}
+
+export { SignerKey };
+//# sourceMappingURL=signerkey.js.map

package/lib/esm/base/signerkey.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signerkey.js","sources":["../../../src/base/signerkey.ts"],"sourcesContent":["import xdr from \"./xdr.js\";\nimport { StrKey, encodeCheck, decodeCheck } from \"./strkey.js\";\n\ntype SignerStrKeyType =\n  | \"ed25519PublicKey\"\n  | \"preAuthTx\"\n  | \"sha256Hash\"\n  | \"signedPayload\";\n\n/**\n * A container class with helpers to convert between signer keys\n * (`xdr.SignerKey`) and {@link StrKey}s.\n *\n * It's primarily used for manipulating the `extraSigners` precondition on a\n * {@link Transaction}.\n *\n * @see {@link TransactionBuilder.setExtraSigners}\n */\nexport class SignerKey {\n  /**\n   * Decodes a StrKey address into an xdr.SignerKey instance.\n   *\n   * Only ED25519 public keys (G...), pre-auth transactions (T...), hashes\n   * (H...), and signed payloads (P...) can be signer keys.\n   *\n   * @param address - a StrKey-encoded signer address\n   */\n  static decodeAddress(address: string): xdr.SignerKey {\n    const vb = StrKey.getVersionByteForPrefix(address);\n    if (vb === undefined) {\n      throw new Error(`invalid signer key type (${vb})`);\n    }\n\n    const raw = decodeCheck(vb, address);\n    switch (vb) {\n      case \"signedPayload\":\n        return xdr.SignerKey.signerKeyTypeEd25519SignedPayload(\n          new xdr.SignerKeyEd25519SignedPayload({\n            ed25519: raw.subarray(0, 32),\n            payload: raw.subarray(36, 36 + raw.readUInt32BE(32)),\n          }),\n        );\n\n      case \"ed25519PublicKey\":\n        return xdr.SignerKey.signerKeyTypeEd25519(raw);\n\n      case \"preAuthTx\":\n        return xdr.SignerKey.signerKeyTypePreAuthTx(raw);\n\n      case \"sha256Hash\":\n        return xdr.SignerKey.signerKeyTypeHashX(raw);\n\n      default:\n        throw new Error(`invalid signer key type (${vb})`);\n    }\n  }\n\n  /**\n   * Encodes a signer key into its StrKey equivalent.\n   *\n   * @param signerKey - the signer\n   */\n  static encodeSignerKey(signerKey: xdr.SignerKey): string {\n    let strkeyType: SignerStrKeyType;\n    let raw: Buffer;\n\n    switch (signerKey.switch()) {\n      case xdr.SignerKeyType.signerKeyTypeEd25519():\n        strkeyType = \"ed25519PublicKey\";\n        raw = signerKey.value() as Buffer;\n        break;\n\n      case xdr.SignerKeyType.signerKeyTypePreAuthTx():\n        strkeyType = \"preAuthTx\";\n        raw = signerKey.value() as Buffer;\n        break;\n\n      case xdr.SignerKeyType.signerKeyTypeHashX():\n        strkeyType = \"sha256Hash\";\n        raw = signerKey.value() as Buffer;\n        break;\n\n      case xdr.SignerKeyType.signerKeyTypeEd25519SignedPayload():\n        strkeyType = \"signedPayload\";\n        raw = signerKey.ed25519SignedPayload().toXDR(\"raw\");\n        break;\n\n      default:\n        throw new Error(`invalid SignerKey (type: ${signerKey.switch().name})`);\n    }\n\n    return encodeCheck(strkeyType, raw);\n  }\n}\n"],"names":["xdr"],"mappings":";;;AAkBO,MAAM,SAAA,CAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASrB,OAAO,cAAc,OAAA,EAAgC;AACnD,IAAA,MAAM,EAAA,GAAK,MAAA,CAAO,uBAAA,CAAwB,OAAO,CAAA;AACjD,IAAA,IAAI,OAAO,MAAA,EAAW;AACpB,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,yBAAA,EAA4B,EAAE,CAAA,CAAA,CAAG,CAAA;AAAA,IACnD;AAEA,IAAA,MAAM,GAAA,GAAM,WAAA,CAAY,EAAA,EAAI,OAAO,CAAA;AACnC,IAAA,QAAQ,EAAA;AAAI,MACV,KAAK,eAAA;AACH,QAAA,OAAOA,MAAI,SAAA,CAAU,iCAAA;AAAA,UACnB,IAAIA,MAAI,6BAAA,CAA8B;AAAA,YACpC,OAAA,EAAS,GAAA,CAAI,QAAA,CAAS,CAAA,EAAG,EAAE,CAAA;AAAA,YAC3B,OAAA,EAAS,IAAI,QAAA,CAAS,EAAA,EAAI,KAAK,GAAA,CAAI,YAAA,CAAa,EAAE,CAAC;AAAA,WACpD;AAAA,SACH;AAAA,MAEF,KAAK,kBAAA;AACH,QAAA,OAAOA,KAAA,CAAI,SAAA,CAAU,oBAAA,CAAqB,GAAG,CAAA;AAAA,MAE/C,KAAK,WAAA;AACH,QAAA,OAAOA,KAAA,CAAI,SAAA,CAAU,sBAAA,CAAuB,GAAG,CAAA;AAAA,MAEjD,KAAK,YAAA;AACH,QAAA,OAAOA,KAAA,CAAI,SAAA,CAAU,kBAAA,CAAmB,GAAG,CAAA;AAAA,MAE7C;AACE,QAAA,MAAM,IAAI,KAAA,CAAM,CAAA,yBAAA,EAA4B,EAAE,CAAA,CAAA,CAAG,CAAA;AAAA;AACrD,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAO,gBAAgB,SAAA,EAAkC;AACvD,IAAA,IAAI,UAAA;AACJ,IAAA,IAAI,GAAA;AAEJ,IAAA,QAAQ,SAAA,CAAU,QAAO;AAAG,MAC1B,KAAKA,KAAA,CAAI,aAAA,CAAc,oBAAA,EAAqB;AAC1C,QAAA,UAAA,GAAa,kBAAA;AACb,QAAA,GAAA,GAAM,UAAU,KAAA,EAAM;AACtB,QAAA;AAAA,MAEF,KAAKA,KAAA,CAAI,aAAA,CAAc,sBAAA,EAAuB;AAC5C,QAAA,UAAA,GAAa,WAAA;AACb,QAAA,GAAA,GAAM,UAAU,KAAA,EAAM;AACtB,QAAA;AAAA,MAEF,KAAKA,KAAA,CAAI,aAAA,CAAc,kBAAA,EAAmB;AACxC,QAAA,UAAA,GAAa,YAAA;AACb,QAAA,GAAA,GAAM,UAAU,KAAA,EAAM;AACtB,QAAA;AAAA,MAEF,KAAKA,KAAA,CAAI,aAAA,CAAc,iCAAA,EAAkC;AACvD,QAAA,UAAA,GAAa,eAAA;AACb,QAAA,GAAA,GAAM,SAAA,CAAU,oBAAA,EAAqB,CAAE,KAAA,CAAM,KAAK,CAAA;AAClD,QAAA;AAAA,MAEF;AACE,QAAA,MAAM,IAAI,KAAA,CAAM,CAAA,yBAAA,EAA4B,UAAU,MAAA,EAAO,CAAE,IAAI,CAAA,CAAA,CAAG,CAAA;AAAA;AAG1E,IAAA,OAAO,WAAA,CAAY,YAAY,GAAG,CAAA;AAAA,EACpC;AACF;;;;"}

package/lib/esm/base/signing.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Derives an Ed25519 public key from a secret key.
+ *
+ * @param secretKey - the raw Ed25519 secret key
+ */
+export declare function generate(secretKey: Buffer | Uint8Array): Buffer;
+/**
+ * Signs data using an Ed25519 secret key.
+ *
+ * @param data - the data to sign
+ * @param rawSecret - the raw Ed25519 secret key
+ */
+export declare function sign(data: Buffer, rawSecret: Buffer | Uint8Array): Buffer;
+/**
+ * Verifies an Ed25519 signature against the given data and public key.
+ *
+ * @param data - the original signed data
+ * @param signature - the signature to verify
+ * @param rawPublicKey - the raw Ed25519 public key
+ */
+export declare function verify(data: Buffer, signature: Buffer, rawPublicKey: Buffer | Uint8Array): boolean;

package/lib/esm/base/signing.js

@@ -0,0 +1,24 @@
+import { Buffer } from 'buffer';
+import * as ed from '@noble/ed25519';
+import { sha512 } from '@noble/hashes/sha2.js';
+
+ed.hashes.sha512 = sha512;
+function generate(secretKey) {
+  return Buffer.from(ed.getPublicKey(secretKey));
+}
+function sign(data, rawSecret) {
+  return Buffer.from(ed.sign(Buffer.from(data), rawSecret));
+}
+function verify(data, signature, rawPublicKey) {
+  return ed.verify(
+    Buffer.from(signature),
+    Buffer.from(data),
+    Buffer.from(rawPublicKey),
+    {
+      zip215: false
+    }
+  );
+}
+
+export { generate, sign, verify };
+//# sourceMappingURL=signing.js.map

package/lib/esm/base/signing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signing.js","sources":["../../../src/base/signing.ts"],"sourcesContent":["import * as ed from \"@noble/ed25519\";\nimport { sha512 } from \"@noble/hashes/sha2.js\";\n\ned.hashes.sha512 = sha512;\n/**\n * Derives an Ed25519 public key from a secret key.\n *\n * @param secretKey - the raw Ed25519 secret key\n */\nexport function generate(secretKey: Buffer | Uint8Array): Buffer {\n  return Buffer.from(ed.getPublicKey(secretKey));\n}\n\n/**\n * Signs data using an Ed25519 secret key.\n *\n * @param data - the data to sign\n * @param rawSecret - the raw Ed25519 secret key\n */\nexport function sign(data: Buffer, rawSecret: Buffer | Uint8Array): Buffer {\n  return Buffer.from(ed.sign(Buffer.from(data), rawSecret));\n}\n\n/**\n * Verifies an Ed25519 signature against the given data and public key.\n *\n * @param data - the original signed data\n * @param signature - the signature to verify\n * @param rawPublicKey - the raw Ed25519 public key\n */\nexport function verify(\n  data: Buffer,\n  signature: Buffer,\n  rawPublicKey: Buffer | Uint8Array,\n): boolean {\n  return ed.verify(\n    Buffer.from(signature),\n    Buffer.from(data),\n    Buffer.from(rawPublicKey),\n    {\n      zip215: false,\n    },\n  );\n}\n"],"names":[],"mappings":";;;;AAGA,EAAA,CAAG,OAAO,MAAA,GAAS,MAAA;AAMZ,SAAS,SAAS,SAAA,EAAwC;AAC/D,EAAA,OAAO,MAAA,CAAO,IAAA,CAAK,EAAA,CAAG,YAAA,CAAa,SAAS,CAAC,CAAA;AAC/C;AAQO,SAAS,IAAA,CAAK,MAAc,SAAA,EAAwC;AACzE,EAAA,OAAO,MAAA,CAAO,KAAK,EAAA,CAAG,IAAA,CAAK,OAAO,IAAA,CAAK,IAAI,CAAA,EAAG,SAAS,CAAC,CAAA;AAC1D;AASO,SAAS,MAAA,CACd,IAAA,EACA,SAAA,EACA,YAAA,EACS;AACT,EAAA,OAAO,EAAA,CAAG,MAAA;AAAA,IACR,MAAA,CAAO,KAAK,SAAS,CAAA;AAAA,IACrB,MAAA,CAAO,KAAK,IAAI,CAAA;AAAA,IAChB,MAAA,CAAO,KAAK,YAAY,CAAA;AAAA,IACxB;AAAA,MACE,MAAA,EAAQ;AAAA;AACV,GACF;AACF;;;;"}

package/lib/esm/base/soroban.d.ts

@@ -0,0 +1,45 @@
+/** Helper class to assist with formatting and parsing token amounts.*/
+export declare class Soroban {
+    /**
+     * Given a whole number smart contract amount of a token and an amount of
+     * decimal places (if the token has any), it returns a "display" value.
+     *
+     * All arithmetic inside the contract is performed on integers to avoid
+     * potential precision and consistency issues of floating-point.
+     *
+     * @param amount - the token amount you want to display
+     * @param decimals - specify how many decimal places a token has
+     *
+     * @throws if the given amount has a decimal point already
+     * @example
+     * ```ts
+     * formatTokenAmount("123000", 4) === "12.3";
+     * formatTokenAmount("123000", 3) === "123.0";
+     * formatTokenAmount("123", 3) === "0.123";
+     * ```
+     */
+    static formatTokenAmount(amount: string, decimals: number): string;
+    /**
+     * Parse a token amount to use it on smart contract
+     *
+     * This function takes the display value and its decimals (if the token has
+     * any) and returns a string that'll be used within the smart contract.
+     *
+     * Returns the whole number token amount represented by the display value
+     * with the decimal places shifted over.
+     *
+     * @param value - the token amount you want to use on a smart contract
+     *    which you've been displaying in a UI
+     * @param decimals - the number of decimal places expected in the
+     *    display value (different than the "actual" number, because suffix zeroes
+     *    might not be present)
+     *
+     * @example
+     * ```ts
+     * const displayValueAmount = "123.4560"
+     * const parsedAmtForSmartContract = parseTokenAmount(displayValueAmount, 5);
+     * parsedAmtForSmartContract === "12345600"
+     * ```
+     */
+    static parseTokenAmount(value: string, decimals: number): string;
+}

package/lib/esm/base/soroban.js

@@ -0,0 +1,89 @@
+class Soroban {
+  /**
+   * Given a whole number smart contract amount of a token and an amount of
+   * decimal places (if the token has any), it returns a "display" value.
+   *
+   * All arithmetic inside the contract is performed on integers to avoid
+   * potential precision and consistency issues of floating-point.
+   *
+   * @param amount - the token amount you want to display
+   * @param decimals - specify how many decimal places a token has
+   *
+   * @throws if the given amount has a decimal point already
+   * @example
+   * ```ts
+   * formatTokenAmount("123000", 4) === "12.3";
+   * formatTokenAmount("123000", 3) === "123.0";
+   * formatTokenAmount("123", 3) === "0.123";
+   * ```
+   */
+  static formatTokenAmount(amount, decimals) {
+    if (amount.includes(".")) {
+      throw new TypeError("No decimals are allowed");
+    }
+    const negative = amount.startsWith("-");
+    let formatted = negative ? amount.slice(1) : amount;
+    if (decimals > 0) {
+      if (decimals > formatted.length) {
+        formatted = ["0", formatted.toString().padStart(decimals, "0")].join(
+          "."
+        );
+      } else {
+        formatted = [
+          formatted.slice(0, -decimals),
+          formatted.slice(-decimals)
+        ].join(".");
+      }
+    }
+    if (formatted.includes(".")) {
+      formatted = formatted.replace(/0+$/, "");
+      if (formatted.endsWith(".")) {
+        formatted += "0";
+      }
+    }
+    if (formatted.startsWith(".")) {
+      formatted = `0${formatted}`;
+    }
+    return negative ? `-${formatted}` : formatted;
+  }
+  /**
+   * Parse a token amount to use it on smart contract
+   *
+   * This function takes the display value and its decimals (if the token has
+   * any) and returns a string that'll be used within the smart contract.
+   *
+   * Returns the whole number token amount represented by the display value
+   * with the decimal places shifted over.
+   *
+   * @param value - the token amount you want to use on a smart contract
+   *    which you've been displaying in a UI
+   * @param decimals - the number of decimal places expected in the
+   *    display value (different than the "actual" number, because suffix zeroes
+   *    might not be present)
+   *
+   * @example
+   * ```ts
+   * const displayValueAmount = "123.4560"
+   * const parsedAmtForSmartContract = parseTokenAmount(displayValueAmount, 5);
+   * parsedAmtForSmartContract === "12345600"
+   * ```
+   */
+  static parseTokenAmount(value, decimals) {
+    const [whole, fraction, ...rest] = value.split(".").slice();
+    if (rest.length) {
+      throw new Error(`Invalid decimal value: ${value}`);
+    }
+    if (fraction?.length && fraction.length > decimals) {
+      throw new Error(
+        `Too many decimal places in "${value}": expected at most ${decimals}, got ${fraction.length}`
+      );
+    }
+    const shifted = BigInt(
+      whole + (fraction?.padEnd(decimals, "0") ?? "0".repeat(decimals))
+    );
+    return shifted.toString();
+  }
+}
+
+export { Soroban };
+//# sourceMappingURL=soroban.js.map

package/lib/esm/base/soroban.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"soroban.js","sources":["../../../src/base/soroban.ts"],"sourcesContent":["/** Helper class to assist with formatting and parsing token amounts.*/\nexport class Soroban {\n  /**\n   * Given a whole number smart contract amount of a token and an amount of\n   * decimal places (if the token has any), it returns a \"display\" value.\n   *\n   * All arithmetic inside the contract is performed on integers to avoid\n   * potential precision and consistency issues of floating-point.\n   *\n   * @param amount - the token amount you want to display\n   * @param decimals - specify how many decimal places a token has\n   *\n   * @throws if the given amount has a decimal point already\n   * @example\n   * ```ts\n   * formatTokenAmount(\"123000\", 4) === \"12.3\";\n   * formatTokenAmount(\"123000\", 3) === \"123.0\";\n   * formatTokenAmount(\"123\", 3) === \"0.123\";\n   * ```\n   */\n  static formatTokenAmount(amount: string, decimals: number): string {\n    if (amount.includes(\".\")) {\n      throw new TypeError(\"No decimals are allowed\");\n    }\n\n    const negative = amount.startsWith(\"-\");\n    let formatted = negative ? amount.slice(1) : amount;\n\n    if (decimals > 0) {\n      if (decimals > formatted.length) {\n        formatted = [\"0\", formatted.toString().padStart(decimals, \"0\")].join(\n          \".\",\n        );\n      } else {\n        formatted = [\n          formatted.slice(0, -decimals),\n          formatted.slice(-decimals),\n        ].join(\".\");\n      }\n    }\n\n    if (formatted.includes(\".\")) {\n      formatted = formatted.replace(/0+$/, \"\"); // strip trailing zeroes\n      if (formatted.endsWith(\".\")) {\n        formatted += \"0\"; // but keep at least one\n      }\n    }\n    if (formatted.startsWith(\".\")) {\n      formatted = `0${formatted}`; // and a leading one\n    }\n\n    return negative ? `-${formatted}` : formatted;\n  }\n\n  /**\n   * Parse a token amount to use it on smart contract\n   *\n   * This function takes the display value and its decimals (if the token has\n   * any) and returns a string that'll be used within the smart contract.\n   *\n   * Returns the whole number token amount represented by the display value\n   * with the decimal places shifted over.\n   *\n   * @param value - the token amount you want to use on a smart contract\n   *    which you've been displaying in a UI\n   * @param decimals - the number of decimal places expected in the\n   *    display value (different than the \"actual\" number, because suffix zeroes\n   *    might not be present)\n   *\n   * @example\n   * ```ts\n   * const displayValueAmount = \"123.4560\"\n   * const parsedAmtForSmartContract = parseTokenAmount(displayValueAmount, 5);\n   * parsedAmtForSmartContract === \"12345600\"\n   * ```\n   */\n  static parseTokenAmount(value: string, decimals: number): string {\n    const [whole, fraction, ...rest] = value.split(\".\").slice();\n\n    if (rest.length) {\n      throw new Error(`Invalid decimal value: ${value}`);\n    }\n\n    if (fraction?.length && fraction.length > decimals) {\n      throw new Error(\n        `Too many decimal places in \"${value}\": expected at most ${decimals}, got ${fraction.length}`,\n      );\n    }\n\n    const shifted = BigInt(\n      whole + (fraction?.padEnd(decimals, \"0\") ?? \"0\".repeat(decimals)),\n    );\n\n    return shifted.toString();\n  }\n}\n"],"names":[],"mappings":"AACO,MAAM,OAAA,CAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBnB,OAAO,iBAAA,CAAkB,MAAA,EAAgB,QAAA,EAA0B;AACjE,IAAA,IAAI,MAAA,CAAO,QAAA,CAAS,GAAG,CAAA,EAAG;AACxB,MAAA,MAAM,IAAI,UAAU,yBAAyB,CAAA;AAAA,IAC/C;AAEA,IAAA,MAAM,QAAA,GAAW,MAAA,CAAO,UAAA,CAAW,GAAG,CAAA;AACtC,IAAA,IAAI,SAAA,GAAY,QAAA,GAAW,MAAA,CAAO,KAAA,CAAM,CAAC,CAAA,GAAI,MAAA;AAE7C,IAAA,IAAI,WAAW,CAAA,EAAG;AAChB,MAAA,IAAI,QAAA,GAAW,UAAU,MAAA,EAAQ;AAC/B,QAAA,SAAA,GAAY,CAAC,KAAK,SAAA,CAAU,QAAA,GAAW,QAAA,CAAS,QAAA,EAAU,GAAG,CAAC,CAAA,CAAE,IAAA;AAAA,UAC9D;AAAA,SACF;AAAA,MACF,CAAA,MAAO;AACL,QAAA,SAAA,GAAY;AAAA,UACV,SAAA,CAAU,KAAA,CAAM,CAAA,EAAG,CAAC,QAAQ,CAAA;AAAA,UAC5B,SAAA,CAAU,KAAA,CAAM,CAAC,QAAQ;AAAA,SAC3B,CAAE,KAAK,GAAG,CAAA;AAAA,MACZ;AAAA,IACF;AAEA,IAAA,IAAI,SAAA,CAAU,QAAA,CAAS,GAAG,CAAA,EAAG;AAC3B,MAAA,SAAA,GAAY,SAAA,CAAU,OAAA,CAAQ,KAAA,EAAO,EAAE,CAAA;AACvC,MAAA,IAAI,SAAA,CAAU,QAAA,CAAS,GAAG,CAAA,EAAG;AAC3B,QAAA,SAAA,IAAa,GAAA;AAAA,MACf;AAAA,IACF;AACA,IAAA,IAAI,SAAA,CAAU,UAAA,CAAW,GAAG,CAAA,EAAG;AAC7B,MAAA,SAAA,GAAY,IAAI,SAAS,CAAA,CAAA;AAAA,IAC3B;AAEA,IAAA,OAAO,QAAA,GAAW,CAAA,CAAA,EAAI,SAAS,CAAA,CAAA,GAAK,SAAA;AAAA,EACtC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAwBA,OAAO,gBAAA,CAAiB,KAAA,EAAe,QAAA,EAA0B;AAC/D,IAAA,MAAM,CAAC,KAAA,EAAO,QAAA,EAAU,GAAG,IAAI,IAAI,KAAA,CAAM,KAAA,CAAM,GAAG,CAAA,CAAE,KAAA,EAAM;AAE1D,IAAA,IAAI,KAAK,MAAA,EAAQ;AACf,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,uBAAA,EAA0B,KAAK,CAAA,CAAE,CAAA;AAAA,IACnD;AAEA,IAAA,IAAI,QAAA,EAAU,MAAA,IAAU,QAAA,CAAS,MAAA,GAAS,QAAA,EAAU;AAClD,MAAA,MAAM,IAAI,KAAA;AAAA,QACR,+BAA+B,KAAK,CAAA,oBAAA,EAAuB,QAAQ,CAAA,MAAA,EAAS,SAAS,MAAM,CAAA;AAAA,OAC7F;AAAA,IACF;AAEA,IAAA,MAAM,OAAA,GAAU,MAAA;AAAA,MACd,KAAA,IAAS,UAAU,MAAA,CAAO,QAAA,EAAU,GAAG,CAAA,IAAK,GAAA,CAAI,OAAO,QAAQ,CAAA;AAAA,KACjE;AAEA,IAAA,OAAO,QAAQ,QAAA,EAAS;AAAA,EAC1B;AACF;;;;"}