@attocash/commons-test 6.0.0

package/commons-commons-core/cash/atto/commons/AttoAddress.mjs

@@ -0,0 +1,278 @@
+import { AttoHasher_instance3904w4qpo055r as AttoHasher_instance } from './AttoHasher.js.mjs';
+import {
+  _UByte___get_data__impl__jof9qr2p2xx2i2jvnz8 as _UByte___get_data__impl__jof9qr,
+  _UByte___init__impl__g9hnc43ude1dscg1q30 as _UByte___init__impl__g9hnc4,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UByte.mjs';
+import { Companion_getInstance19ckbg90y6ov9 as Companion_getInstance } from './AttoAlgorithm.mjs';
+import { until1jbpn0z3f8lbg as until } from '../../../../kotlin-kotlin-stdlib/kotlin/ranges/_Ranges.mjs';
+import { sliceArray2hu2ljigibgmi as sliceArray } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_Arrays.mjs';
+import { AttoPublicKey2ecx82jmcdweu as AttoPublicKey } from './AttoPublicKey.mjs';
+import { to2cs3ny02qtbcb as to } from '../../../../kotlin-kotlin-stdlib/kotlin/Tuples.mjs';
+import { Regexxgw0gjiagf4z as Regex } from '../../../../kotlin-kotlin-stdlib/kotlin/text/regex.mjs';
+import { contentEquals1cdp6c846cfdi as contentEquals } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_ArraysJs.mjs';
+import { primitiveArrayConcatwxgknw08pmlb as primitiveArrayConcat } from '../../../../kotlin-kotlin-stdlib/noPackageHacks.mjs';
+import {
+  startsWith26w8qjqapeeq6 as startsWith,
+  replace3le3ie7l9k8aq as replace,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/text/stringsCode.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { Buffergs925ekssbch as Buffer } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs';
+import { writeUByte3nig1vidorr05 as writeUByte } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Sinks.mjs';
+import { STRING_getInstance2ou4lro9xn2qn as STRING_getInstance } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/descriptors/SerialKinds.mjs';
+import { PrimitiveSerialDescriptor3egfp53lutxj2 as PrimitiveSerialDescriptor } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/descriptors/SerialDescriptors.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+import { Base32_getInstance1zhax53mffzee as Base32_getInstance } from './utils/Base32.mjs';
+import { substring3saq8ornu0luv as substring } from '../../../../kotlin-kotlin-stdlib/kotlin/text/stringJs.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+function checksum($this, algorithm, publicKey) {
+  return AttoHasher_instance.g4l(5, [algorithm, publicKey]);
+}
+function checksum_0($this, algorithm, publicKey) {
+  // Inline function 'kotlin.UByte.toByte' call
+  var this_0 = algorithm.code;
+  var tmp$ret$0 = _UByte___get_data__impl__jof9qr(this_0);
+  // Inline function 'kotlin.byteArrayOf' call
+  var tmp$ret$1 = new Int8Array([tmp$ret$0]);
+  return checksum($this, tmp$ret$1, publicKey.value);
+}
+function toAlgorithmPublicKey($this, decoded) {
+  var tmp = Companion_getInstance();
+  // Inline function 'kotlin.toUByte' call
+  var this_0 = decoded[0];
+  var tmp$ret$0 = _UByte___init__impl__g9hnc4(this_0);
+  var algorithm = tmp.j4l(tmp$ret$0);
+  var publicKey = new (AttoPublicKey())(sliceArray(decoded, until(1, 33)));
+  return to(algorithm, publicKey);
+}
+function toAlgorithmPublicKey_0($this, value) {
+  return toAlgorithmPublicKey($this, fromAddress(value));
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        var tmp = this;
+        // Inline function 'kotlin.text.toRegex' call
+        var this_0 = '^atto://[a-z2-7]{61}$';
+        tmp.k4l_1 = Regex().hh(this_0);
+        this.l4l_1 = 5;
+      }
+      isValid(value) {
+        if (!this.k4l_1.ih(value)) {
+          return false;
+        }
+        var decoded = fromAddress(value);
+        var _destruct__k2r9zo = toAlgorithmPublicKey(this, decoded);
+        var algorithm = _destruct__k2r9zo.ne();
+        var publicKey = _destruct__k2r9zo.oe();
+        var checksum = sliceArray(decoded, until(33, decoded.length));
+        return contentEquals(checksum, checksum_0(this, algorithm, publicKey));
+      }
+      isValidPath(path) {
+        var value = 'atto://' + path;
+        return this.isValid(value);
+      }
+      toAddressPath(algorithm, publicKey) {
+        // Inline function 'kotlin.UByte.toByte' call
+        var this_0 = algorithm.code;
+        var tmp$ret$0 = _UByte___get_data__impl__jof9qr(this_0);
+        // Inline function 'kotlin.byteArrayOf' call
+        var algorithm_0 = new Int8Array([tmp$ret$0]);
+        var publicKey_0 = publicKey.value;
+        var checksum_0 = checksum(this, algorithm_0, publicKey_0);
+        // Inline function 'kotlin.collections.plus' call
+        // Inline function 'kotlin.collections.plus' call
+        var this_1 = primitiveArrayConcat([algorithm_0, publicKey_0]);
+        var tmp$ret$3 = primitiveArrayConcat([this_1, checksum_0]);
+        return toAddressPath(tmp$ret$3);
+      }
+      parseSerialized(serialized) {
+        var tmp = Companion_getInstance();
+        // Inline function 'kotlin.toUByte' call
+        var this_0 = serialized[0];
+        var tmp$ret$0 = _UByte___init__impl__g9hnc4(this_0);
+        var algorithm = tmp.j4l(tmp$ret$0);
+        var publicKey = new (AttoPublicKey())(sliceArray(serialized, until(1, serialized.length)));
+        return new (AttoAddress())(algorithm, publicKey);
+      }
+      parse(value) {
+        var address = startsWith(value, 'atto://') ? value : 'atto://' + value;
+        // Inline function 'kotlin.require' call
+        if (!this.isValid(address)) {
+          var message = value + ' is invalid';
+          throw IllegalArgumentException().i1(toString(message));
+        }
+        var _destruct__k2r9zo = toAlgorithmPublicKey_0(this, address);
+        var algorithm = _destruct__k2r9zo.ne();
+        var publicKey = _destruct__k2r9zo.oe();
+        return new (AttoAddress())(algorithm, publicKey);
+      }
+      parsePath(path) {
+        return this.parse(path);
+      }
+      p3q() {
+        return AttoAddressAsStringSerializer_getInstance();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance_0() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+var AttoAddressClass;
+function AttoAddress() {
+  if (AttoAddressClass === VOID) {
+    class $ {
+      constructor(algorithm, publicKey) {
+        Companion_getInstance_0();
+        this.algorithm = algorithm;
+        this.publicKey = publicKey;
+        this.schema = 'atto://';
+        this.path = Companion_getInstance_0().toAddressPath(this.algorithm, this.publicKey);
+        this.value = this.schema + this.path;
+      }
+      w4j() {
+        return this.algorithm;
+      }
+      u4j() {
+        return this.publicKey;
+      }
+      m4l() {
+        return this.schema;
+      }
+      n4l() {
+        return this.path;
+      }
+      z1() {
+        return this.value;
+      }
+      o4l() {
+        // Inline function 'kotlin.apply' call
+        var this_0 = new (Buffer())();
+        writeUByte(this_0, this.algorithm.code);
+        this_0.b1m(this.publicKey.value, 0, this.publicKey.value.length);
+        return this_0;
+      }
+      toString() {
+        return this.value;
+      }
+      ne() {
+        return this.algorithm;
+      }
+      oe() {
+        return this.publicKey;
+      }
+      p4l(algorithm, publicKey) {
+        return new (AttoAddress())(algorithm, publicKey);
+      }
+      copy(algorithm, publicKey, $super) {
+        algorithm = algorithm === VOID ? this.algorithm : algorithm;
+        publicKey = publicKey === VOID ? this.publicKey : publicKey;
+        return $super === VOID ? this.p4l(algorithm, publicKey) : $super.p4l.call(this, algorithm, publicKey);
+      }
+      hashCode() {
+        var result = this.algorithm.hashCode();
+        result = imul(result, 31) + this.publicKey.hashCode() | 0;
+        return result;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AttoAddress()))
+          return false;
+        if (!this.algorithm.equals(other.algorithm))
+          return false;
+        if (!this.publicKey.equals(other.publicKey))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'AttoAddress', VOID, VOID, VOID, VOID, VOID, {0: AttoAddressAsStringSerializer_getInstance});
+    AttoAddressClass = $;
+  }
+  return AttoAddressClass;
+}
+function toAddress(_this__u8e3s4, algorithm) {
+  return new (AttoAddress())(algorithm, _this__u8e3s4);
+}
+var AttoAddressAsStringSerializerClass;
+function AttoAddressAsStringSerializer() {
+  if (AttoAddressAsStringSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoAddressAsStringSerializer_instance = this;
+        this.q4l_1 = PrimitiveSerialDescriptor('AttoAddressAsString', STRING_getInstance());
+      }
+      z1s() {
+        return this.q4l_1;
+      }
+      r4l(encoder, value) {
+        encoder.q1y(value.toString());
+      }
+      a1t(encoder, value) {
+        return this.r4l(encoder, value instanceof AttoAddress() ? value : THROW_CCE());
+      }
+      b1t(decoder) {
+        return Companion_getInstance_0().parse(decoder.h1x());
+      }
+    }
+    initMetadataForObject($, 'AttoAddressAsStringSerializer', VOID, VOID, [KSerializer()]);
+    AttoAddressAsStringSerializerClass = $;
+  }
+  return AttoAddressAsStringSerializerClass;
+}
+var AttoAddressAsStringSerializer_instance;
+function AttoAddressAsStringSerializer_getInstance() {
+  if (AttoAddressAsStringSerializer_instance === VOID)
+    new (AttoAddressAsStringSerializer())();
+  return AttoAddressAsStringSerializer_instance;
+}
+function fromAddress(_this__u8e3s4) {
+  var tmp = Base32_getInstance();
+  // Inline function 'kotlin.text.uppercase' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp$ret$1 = substring(_this__u8e3s4, 7).toUpperCase();
+  return tmp.u4l(tmp$ret$1 + '===');
+}
+function toAddressPath(_this__u8e3s4) {
+  // Inline function 'kotlin.require' call
+  if (!(_this__u8e3s4.length === 38)) {
+    var message = 'ByteArray should have 38 bytes';
+    throw IllegalArgumentException().i1(toString(message));
+  }
+  // Inline function 'kotlin.text.lowercase' call
+  // Inline function 'kotlin.js.asDynamic' call
+  return replace(Base32_getInstance().v4l(_this__u8e3s4), '=', '').toLowerCase();
+}
+//region block: exports
+export {
+  Companion as Companionbjcqn3f8pqzu,
+  AttoAddress as AttoAddressi1gjrmqbg81z,
+  toAddress as toAddress3631euu7evnij,
+  Companion_getInstance_0 as Companion_getInstance2vcugmik704gt,
+  AttoAddressAsStringSerializer_getInstance as AttoAddressAsStringSerializer_getInstance5j63k7wo5ww2,
+};
+//endregion
+
+//# sourceMappingURL=AttoAddress.mjs.map

package/commons-commons-core/cash/atto/commons/AttoAddress.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoAddress.kt","unsigned/src/kotlin/UByte.kt","js/builtins/Library.kt","src/kotlin/text/regex/RegexExtensions.kt","js/src/generated/_ArraysJs.kt","src/kotlin/util/Preconditions.kt","src/kotlin/util/Standard.kt","js/src/kotlin/text/stringJs.kt"],"sourcesContent":[null,null,null,null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["checksum","algorithm","publicKey","toAlgorithmPublicKey","decoded","value","isValid","isValidPath","path","toAddressPath","parse","serialized","address","message","parsePath","serializer","<get-algorithm>","<get-publicKey>","<get-schema>","<get-path>","<get-value>","toBuffer","toString","result","toAddress","<this>","<get-descriptor>","serialize","encoder","deserialize","decoder","fromAddress"],"mappings":"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"}

package/commons-commons-core/cash/atto/commons/AttoAlgorithm.export.d.mts

@@ -0,0 +1,36 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare abstract class AttoAlgorithm {
+    private constructor();
+    static get V1(): AttoAlgorithm & {
+        get name(): "V1";
+        get ordinal(): 0;
+    };
+    get name(): "V1";
+    get ordinal(): 0;
+    get code(): any/* UByte */;
+    get privateKeySize(): number;
+    get publicKeySize(): number;
+    get hashSize(): number;
+    static values(): Array<AttoAlgorithm>;
+    static valueOf(value: string): AttoAlgorithm;
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace AttoAlgorithm.$metadata$ {
+    const constructor: abstract new () => AttoAlgorithm;
+}
+export declare namespace AttoAlgorithm {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor /* implements SerializerFactory */ {
+            private constructor();
+        }
+    }
+}

package/commons-commons-core/cash/atto/commons/AttoAlgorithm.export.mjs

@@ -0,0 +1,26 @@
+import {
+  AttoAlgorithm18y667ds7g2yn as AttoAlgorithm,
+  valuestkl21n5yn994 as values,
+  valueOf1l4wbphcx59k2 as valueOf,
+  AttoAlgorithm_V1_getInstance3t14aeju2v8fs as AttoAlgorithm_V1_getInstance,
+  Companion32jhfeb4yz79l as Companion,
+  Companion_getInstance19ckbg90y6ov9 as Companion_getInstance,
+} from './AttoAlgorithm.mjs';
+import { defineProp3ur6h3slcvq4x as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoAlgorithm_0 = AttoAlgorithm();
+AttoAlgorithm_0.values = values;
+AttoAlgorithm_0.valueOf = valueOf;
+defineProp(AttoAlgorithm_0, 'V1', AttoAlgorithm_V1_getInstance, VOID, true);
+defineProp(AttoAlgorithm_0, 'Companion', Companion_getInstance, VOID, true);
+export {
+  AttoAlgorithm_0 as AttoAlgorithm,
+};
+//endregion
+
+//# sourceMappingURL=AttoAlgorithm.export.mjs.map

package/commons-commons-core/cash/atto/commons/AttoAlgorithm.export.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}

package/commons-commons-core/cash/atto/commons/AttoAlgorithm.mjs

@@ -0,0 +1,162 @@
+import { createSimpleEnumSerializer2guioz11kk1m0 as createSimpleEnumSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/Enums.mjs';
+import { collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/Iterables.mjs';
+import { mapCapacity1h45rc3eh9p2l as mapCapacity } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/collectionJs.mjs';
+import { coerceAtLeast2bkz8m9ik7hep as coerceAtLeast } from '../../../../kotlin-kotlin-stdlib/kotlin/ranges/_Ranges.mjs';
+import { LinkedHashMap1zhqxkxv3xnkl as LinkedHashMap } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/LinkedHashMap.mjs';
+import {
+  UBytep4j7r1t64gz1 as UByte,
+  _UByte___init__impl__g9hnc43ude1dscg1q30 as _UByte___init__impl__g9hnc4,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UByte.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { LazyThreadSafetyMode_PUBLICATION_getInstance3hlj875zwihx0 as LazyThreadSafetyMode_PUBLICATION_getInstance } from '../../../../kotlin-kotlin-stdlib/kotlin/Lazy.mjs';
+import { lazy1261dae0bgscp as lazy } from '../../../../kotlin-kotlin-stdlib/kotlin/kotlin.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { SerializerFactory1qv9hivitncuv as SerializerFactory } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/PluginHelperInterfaces.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { THROW_IAE23kobfj9wdoxr as THROW_IAE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { enumEntries20mr21zbe3az4 as enumEntries } from '../../../../kotlin-kotlin-stdlib/kotlin/enums/EnumEntries.mjs';
+import { Enum3alwj03lh1n41 as Enum } from '../../../../kotlin-kotlin-stdlib/kotlin/Enum.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function _get_$cachedSerializer__te6jhj($this) {
+  return $this.v4i_1.z1();
+}
+function AttoAlgorithm$Companion$_anonymous__z50osy() {
+  return createSimpleEnumSerializer('cash.atto.commons.AttoAlgorithm', values());
+}
+var AttoAlgorithm_V1_instance;
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        var tmp = this;
+        // Inline function 'kotlin.collections.associateBy' call
+        var this_0 = get_entries();
+        var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(this_0, 10)), 16);
+        // Inline function 'kotlin.collections.associateByTo' call
+        var destination = LinkedHashMap().qb(capacity);
+        var _iterator__ex2g4s = this_0.k1();
+        while (_iterator__ex2g4s.l1()) {
+          var element = _iterator__ex2g4s.m1();
+          var tmp$ret$0 = new (UByte())(element.code);
+          destination.m3(tmp$ret$0, element);
+        }
+        tmp.u4i_1 = destination;
+        var tmp_0 = this;
+        var tmp_1 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+        tmp_0.v4i_1 = lazy(tmp_1, AttoAlgorithm$Companion$_anonymous__z50osy);
+      }
+      j4l(code) {
+        var tmp0_elvis_lhs = this.u4i_1.j3(new (UByte())(code));
+        var tmp;
+        if (tmp0_elvis_lhs == null) {
+          throw IllegalArgumentException().i1('Unsupported algorithm ' + new (UByte())(code) + ' code');
+        } else {
+          tmp = tmp0_elvis_lhs;
+        }
+        return tmp;
+      }
+      p3q() {
+        return _get_$cachedSerializer__te6jhj(this);
+      }
+      b26(typeParamsSerializers) {
+        return this.p3q();
+      }
+    }
+    initMetadataForCompanion($, VOID, [SerializerFactory()]);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  AttoAlgorithm_initEntries();
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+function values() {
+  return [AttoAlgorithm_V1_getInstance()];
+}
+function valueOf(value) {
+  if (value === 'V1')
+    return AttoAlgorithm_V1_getInstance();
+  else {
+    AttoAlgorithm_initEntries();
+    THROW_IAE('No enum constant cash.atto.commons.AttoAlgorithm.' + value);
+  }
+}
+function get_entries() {
+  if ($ENTRIES == null)
+    $ENTRIES = enumEntries(values());
+  return $ENTRIES;
+}
+var AttoAlgorithm_entriesInitialized;
+function AttoAlgorithm_initEntries() {
+  if (AttoAlgorithm_entriesInitialized)
+    return Unit_instance;
+  AttoAlgorithm_entriesInitialized = true;
+  AttoAlgorithm_V1_instance = new (AttoAlgorithm())('V1', 0, _UByte___init__impl__g9hnc4(0), 32, 32, 32);
+  Companion_getInstance();
+}
+var $ENTRIES;
+var AttoAlgorithmClass;
+function AttoAlgorithm() {
+  if (AttoAlgorithmClass === VOID) {
+    class $ extends Enum() {
+      constructor(name, ordinal, code, privateKeySize, publicKeySize, hashSize) {
+        super(name, ordinal);
+        this.code = code;
+        this.privateKeySize = privateKeySize;
+        this.publicKeySize = publicKeySize;
+        this.hashSize = hashSize;
+      }
+      w4l() {
+        return this.code;
+      }
+      x4l() {
+        return this.privateKeySize;
+      }
+      y4l() {
+        return this.publicKeySize;
+      }
+      z4l() {
+        return this.hashSize;
+      }
+      get name() {
+        return this.w3();
+      }
+      get ordinal() {
+        return this.x3();
+      }
+    }
+    initMetadataForClass($, 'AttoAlgorithm', VOID, VOID, VOID, VOID, VOID, {0: Companion_getInstance});
+    AttoAlgorithmClass = $;
+  }
+  return AttoAlgorithmClass;
+}
+function AttoAlgorithm_V1_getInstance() {
+  AttoAlgorithm_initEntries();
+  return AttoAlgorithm_V1_instance;
+}
+//region block: exports
+export {
+  Companion as Companion32jhfeb4yz79l,
+  get_entries as get_entries129oc6f40ghxh,
+  valueOf as valueOf1l4wbphcx59k2,
+  values as valuestkl21n5yn994,
+  AttoAlgorithm as AttoAlgorithm18y667ds7g2yn,
+  AttoAlgorithm_V1_getInstance as AttoAlgorithm_V1_getInstance3t14aeju2v8fs,
+  Companion_getInstance as Companion_getInstance19ckbg90y6ov9,
+};
+//endregion
+
+//# sourceMappingURL=AttoAlgorithm.mjs.map

package/commons-commons-core/cash/atto/commons/AttoAlgorithm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoAlgorithm.kt","common/src/generated/_Collections.kt"],"sourcesContent":[null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-$cachedSerializer>","AttoAlgorithm$Companion$<anonymous>","capacity","element","from","code","serializer","values","valueOf","value","<get-entries>","privateKeySize","publicKeySize","hashSize","<get-code>","<get-privateKeySize>","<get-publicKeySize>","<get-hashSize>"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;uCAkBIA,CAAA,KAAAA,EAAA;A,EAAA,uB;AAMA,C;mDANAC,CAAAA,EAAA;A,EAAA,8E;AAMA,C;;;;;;;;kBAL4C,I;;qBAAR,a;YCoqCpCC,WAAwD,cAAzC,YAAY,gCAAwB,EAAxB,CAAZ,CAAyC,EAAc,EAAd,C;;0BACnC,mBAAoB,QAApB,C;YA2BL,oBA3BT,MA2BS,K;eAAA,sB,EAAM;A,cAAjBC,UAAW,sB;wCACgB,O,CDjsCwB,I;UCisCpD,WAAY,IAAI,SAAJ,EAA0B,OAA1B,C;QAChB,C;QDlsC4C,YCmsCrC,W;oBDpsCP,I;oBAAA,8C;QAAA,qE;;SAKIC,CAASC,IAATD,EAAuC;A,YAAA,6CAAI,IAAJ,E;;QAAA,2B;UAAa,oCAAgC,wBAAhC,iBAAuD,IAAvD,IAA2D,OAA3D,C;;gBAAb,c;;QAA+E,U;MAAD,C;SALzHE,CAAAA,EAAA;A,QAAA,2C;MAMA,C;SANAA,C,qBAAAA,EAAA;A,QAAA,iB;MAMA,C;;;;;;;;;;;;;;eAxBJC,CAAAA,E;;C;gBAAAC,CAOAC,KAPAD,E;;;;;;;C;oBAAAE,CAAAA,E;;;;C;;;;;;oDAAA,I,EAAA,C,EAeO,8B,EAAI,E,EAAI,E,EAAI,E;;;;;;;;iCALfL,I,EACAM,c,EACAC,a,EACAC,Q;;QAHA,gB;QACA,oC;QACA,kC;QACA,wB;;SAHAC,CAAAA,EAAA;A,QAAA,gB;MAAc,C;SACdC,CAAAA,EAAA;A,QAAA,0B;MAAsB,C;SACtBC,CAAAA,EAAA;A,QAAA,yB;MAAqB,C;SACrBC,CAAAA,EAAA;A,QAAA,oB;MAAgB,C;;;;;;;;;;;;;;;;;;;;;"}

package/commons-commons-core/cash/atto/commons/AttoAmount.export.d.mts

@@ -0,0 +1,56 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare abstract class AttoUnit {
+    private constructor();
+    static get ATTO(): AttoUnit & {
+        get name(): "ATTO";
+        get ordinal(): 0;
+    };
+    static get RAW(): AttoUnit & {
+        get name(): "RAW";
+        get ordinal(): 1;
+    };
+    get name(): "ATTO" | "RAW";
+    get ordinal(): 0 | 1;
+    get prefix(): string;
+    static values(): Array<AttoUnit>;
+    static valueOf(value: string): AttoUnit;
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace AttoUnit.$metadata$ {
+    const constructor: abstract new () => AttoUnit;
+}
+export declare class AttoAmount /* implements Comparable<AttoAmount> */ {
+    constructor(raw: bigint);
+    get raw(): bigint;
+    toFormattedString(unit: AttoUnit): string;
+    plus(amount: AttoAmount): AttoAmount;
+    minus(amount: AttoAmount): AttoAmount;
+    toString(): string;
+    copy(raw?: bigint): AttoAmount;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+    static from(unit: AttoUnit, string: string): AttoAmount;
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace AttoAmount.$metadata$ {
+    const constructor: abstract new () => AttoAmount;
+}
+export declare namespace AttoAmount {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
+        abstract class constructor {
+            get MAX(): AttoAmount;
+            get MIN(): AttoAmount;
+            private constructor();
+        }
+    }
+}
+export declare function toAttoAmount(_this_: string): AttoAmount;

package/commons-commons-core/cash/atto/commons/AttoAmount.export.mjs

@@ -0,0 +1,35 @@
+import {
+  AttoUnit3uf7k0bjq9xrg as AttoUnit,
+  values3ntpkxfaw56c5 as values,
+  valueOf2yt2l9kimc6n as valueOf,
+  AttoUnit_ATTO_getInstance1gwhthkel17m5 as AttoUnit_ATTO_getInstance,
+  AttoUnit_RAW_getInstance1qbk9zmheijip as AttoUnit_RAW_getInstance,
+  AttoAmount28z2ffm4ih7im as AttoAmount,
+  from1fjx23mt482ol as from,
+  Companion311shwy120dnf as Companion,
+  Companion_getInstancezafbg69jdanb as Companion_getInstance,
+  toAttoAmount2kbgjtdbld3yn as toAttoAmount,
+} from './AttoAmount.mjs';
+import { defineProp3ur6h3slcvq4x as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoUnit_0 = AttoUnit();
+AttoUnit_0.values = values;
+AttoUnit_0.valueOf = valueOf;
+defineProp(AttoUnit_0, 'ATTO', AttoUnit_ATTO_getInstance, VOID, true);
+defineProp(AttoUnit_0, 'RAW', AttoUnit_RAW_getInstance, VOID, true);
+var AttoAmount_0 = AttoAmount();
+AttoAmount_0.from = from;
+defineProp(AttoAmount_0, 'Companion', Companion_getInstance, VOID, true);
+export {
+  AttoUnit_0 as AttoUnit,
+  AttoAmount_0 as AttoAmount,
+  toAttoAmount as toAttoAmount,
+};
+//endregion
+
+//# sourceMappingURL=AttoAmount.export.mjs.map

package/commons-commons-core/cash/atto/commons/AttoAmount.export.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"ignoreList":[],"x_google_ignoreList":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}