@attocash/commons-js 5.3.0 → 6.0.0

package/commons-commons-core/cash/atto/commons/{AttoAddress.export.d.ts → AttoAddress.export.d.mts}

@@ -7,7 +7,6 @@ export declare class AttoAddress {
     get schema(): string;
     get path(): string;
     get value(): string;
-    toBuffer(): any/* Buffer */;
     toString(): string;
     copy(algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey): AttoAddress;
     hashCode(): number;
@@ -18,19 +17,25 @@ export declare namespace AttoAddress.$metadata$ {
     const constructor: abstract new () => AttoAddress;
 }
 export declare namespace AttoAddress {
-    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+    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 {
             isValid(value: string): boolean;
             isValidPath(path: string): boolean;
-            toAddress(algorithm: AttoAlgorithm, publicKey: AttoPublicKey): string;
+            toAddressPath(algorithm: AttoAlgorithm, publicKey: AttoPublicKey): string;
             parseSerialized(serialized: Int8Array): AttoAddress;
             parse(value: string): AttoAddress;
+            /** @deprecated Use parse instead */
             parsePath(path: string): AttoAddress;
             private constructor();
         }
     }
-}
+}
+export declare function toAddress(_this_: AttoPublicKey, algorithm: AttoAlgorithm): AttoAddress;

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

@@ -2,17 +2,20 @@ import {
   AttoAddressi1gjrmqbg81z as AttoAddress,
   Companionbjcqn3f8pqzu as Companion,
   Companion_getInstance2vcugmik704gt as Companion_getInstance,
+  toAddress3631euu7evnij as toAddress,
 } from './AttoAddress.mjs';
-import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.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 AttoAddress_0 = AttoAddress();
-defineProp(AttoAddress_0, 'Companion', Companion_getInstance);
+defineProp(AttoAddress_0, 'Companion', Companion_getInstance, VOID, true);
 export {
   AttoAddress_0 as AttoAddress,
+  toAddress as toAddress,
 };
 //endregion
 

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

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

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

@@ -11,28 +11,34 @@ import { to2cs3ny02qtbcb as to } from '../../../../kotlin-kotlin-stdlib/kotlin/T
 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 { AttoAddressAsByteArraySerializer_getInstance5b6d6uuo8kst as AttoAddressAsByteArraySerializer_getInstance } from './serialiazer/AttoAddressAsByteArraySerializer.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';
-import { replace3le3ie7l9k8aq as replace } from '../../../../kotlin-kotlin-stdlib/kotlin/text/stringsCode.mjs';
 //region block: imports
 var imul = Math.imul;
 //endregion
 //region block: pre-declaration
 //endregion
 function checksum($this, algorithm, publicKey) {
-  return AttoHasher_instance.r2x(5, [algorithm, publicKey]);
+  return AttoHasher_instance.w2v(5, [algorithm, publicKey]);
 }
 function checksum_0($this, algorithm, publicKey) {
   // Inline function 'kotlin.UByte.toByte' call
@@ -47,7 +53,7 @@ function toAlgorithmPublicKey($this, decoded) {
   // Inline function 'kotlin.toUByte' call
   var this_0 = decoded[0];
   var tmp$ret$0 = _UByte___init__impl__g9hnc4(this_0);
-  var algorithm = tmp.from(tmp$ret$0);
+  var algorithm = tmp.z2v(tmp$ret$0);
   var publicKey = new (AttoPublicKey())(sliceArray(decoded, until(1, 33)));
   return to(algorithm, publicKey);
 }
@@ -63,17 +69,17 @@ function Companion() {
         var tmp = this;
         // Inline function 'kotlin.text.toRegex' call
         var this_0 = '^atto://[a-z2-7]{61}$';
-        tmp.u2x_1 = Regex().qi(this_0);
-        this.v2x_1 = 5;
+        tmp.a2w_1 = Regex().nh(this_0);
+        this.b2w_1 = 5;
       }
       isValid(value) {
-        if (!this.u2x_1.ri(value)) {
+        if (!this.a2w_1.oh(value)) {
           return false;
         }
         var decoded = fromAddress(value);
         var _destruct__k2r9zo = toAlgorithmPublicKey(this, decoded);
-        var algorithm = _destruct__k2r9zo.gl();
-        var publicKey = _destruct__k2r9zo.hl();
+        var algorithm = _destruct__k2r9zo.te();
+        var publicKey = _destruct__k2r9zo.ue();
         var checksum = sliceArray(decoded, until(33, decoded.length));
         return contentEquals(checksum, checksum_0(this, algorithm, publicKey));
       }
@@ -81,7 +87,7 @@ function Companion() {
         var value = 'atto://' + path;
         return this.isValid(value);
       }
-      toAddress(algorithm, publicKey) {
+      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);
@@ -93,34 +99,34 @@ function Companion() {
         // Inline function 'kotlin.collections.plus' call
         var this_1 = primitiveArrayConcat([algorithm_0, publicKey_0]);
         var tmp$ret$3 = primitiveArrayConcat([this_1, checksum_0]);
-        return toAddress(tmp$ret$3);
+        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.from(tmp$ret$0);
+        var algorithm = tmp.z2v(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(value)) {
+        if (!this.isValid(address)) {
           var message = value + ' is invalid';
-          throw IllegalArgumentException().u(toString(message));
+          throw IllegalArgumentException().j1(toString(message));
         }
-        var _destruct__k2r9zo = toAlgorithmPublicKey_0(this, value);
-        var algorithm = _destruct__k2r9zo.gl();
-        var publicKey = _destruct__k2r9zo.hl();
+        var _destruct__k2r9zo = toAlgorithmPublicKey_0(this, address);
+        var algorithm = _destruct__k2r9zo.te();
+        var publicKey = _destruct__k2r9zo.ue();
         return new (AttoAddress())(algorithm, publicKey);
       }
       parsePath(path) {
-        var value = 'atto://' + path;
-        return this.parse(value);
+        return this.parse(path);
       }
-      e2v() {
-        return AttoAddressAsByteArraySerializer_getInstance();
+      k2t() {
+        return AttoAddressAsStringSerializer_getInstance();
       }
     }
     initMetadataForCompanion($);
@@ -143,47 +149,47 @@ function AttoAddress() {
         this.algorithm = algorithm;
         this.publicKey = publicKey;
         this.schema = 'atto://';
-        this.path = Companion_getInstance_0().toAddress(this.algorithm, this.publicKey);
+        this.path = Companion_getInstance_0().toAddressPath(this.algorithm, this.publicKey);
         this.value = this.schema + this.path;
       }
-      h2w() {
+      m2u() {
         return this.algorithm;
       }
-      e2w() {
+      j2u() {
         return this.publicKey;
       }
-      w2x() {
+      c2w() {
         return this.schema;
       }
-      x2x() {
+      d2w() {
         return this.path;
       }
-      s1() {
+      z1() {
         return this.value;
       }
-      toBuffer() {
+      e2w() {
         // Inline function 'kotlin.apply' call
         var this_0 = new (Buffer())();
         writeUByte(this_0, this.algorithm.code);
-        this_0.b2t(this.publicKey.value, 0, this.publicKey.value.length);
+        this_0.o28(this.publicKey.value, 0, this.publicKey.value.length);
         return this_0;
       }
       toString() {
         return this.value;
       }
-      gl() {
+      te() {
         return this.algorithm;
       }
-      hl() {
+      ue() {
         return this.publicKey;
       }
-      y2x(algorithm, publicKey) {
+      f2w(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.y2x(algorithm, publicKey) : $super.y2x.call(this, algorithm, publicKey);
+        return $super === VOID ? this.f2w(algorithm, publicKey) : $super.f2w.call(this, algorithm, publicKey);
       }
       hashCode() {
         var result = this.algorithm.hashCode();
@@ -195,41 +201,77 @@ function AttoAddress() {
           return true;
         if (!(other instanceof AttoAddress()))
           return false;
-        var tmp0_other_with_cast = other instanceof AttoAddress() ? other : THROW_CCE();
-        if (!this.algorithm.equals(tmp0_other_with_cast.algorithm))
+        if (!this.algorithm.equals(other.algorithm))
           return false;
-        if (!this.publicKey.equals(tmp0_other_with_cast.publicKey))
+        if (!this.publicKey.equals(other.publicKey))
           return false;
         return true;
       }
     }
-    initMetadataForClass($, 'AttoAddress', VOID, VOID, VOID, VOID, VOID, {0: AttoAddressAsByteArraySerializer_getInstance});
+    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.g2w_1 = PrimitiveSerialDescriptor('AttoAddressAsString', STRING_getInstance());
+      }
+      u1k() {
+        return this.g2w_1;
+      }
+      h2w(encoder, value) {
+        encoder.l1q(value.toString());
+      }
+      v1k(encoder, value) {
+        return this.h2w(encoder, value instanceof AttoAddress() ? value : THROW_CCE());
+      }
+      w1k(decoder) {
+        return Companion_getInstance_0().parse(decoder.c1p());
+      }
+    }
+    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.b2y(tmp$ret$1 + '===');
+  return tmp.k2w(tmp$ret$1 + '===');
 }
-function toAddress(_this__u8e3s4) {
+function toAddressPath(_this__u8e3s4) {
   // Inline function 'kotlin.require' call
   if (!(_this__u8e3s4.length === 38)) {
     var message = 'ByteArray should have 38 bytes';
-    throw IllegalArgumentException().u(toString(message));
+    throw IllegalArgumentException().j1(toString(message));
   }
   // Inline function 'kotlin.text.lowercase' call
   // Inline function 'kotlin.js.asDynamic' call
-  return replace(Base32_getInstance().c2y(_this__u8e3s4), '=', '').toLowerCase();
+  return replace(Base32_getInstance().l2w(_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
 

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoAddress.kt","unsigned/src/kotlin/UByte.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],"ignoreList":[],"x_google_ignoreList":[],"names":["checksum","algorithm","publicKey","toAlgorithmPublicKey","decoded","value","isValid","isValidPath","path","toAddress","parse","serialized","message","parsePath","serializer","<get-algorithm>","<get-publicKey>","<get-schema>","<get-path>","<get-value>","toBuffer","toString","result","fromAddress","<this>"],"mappings":"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"}
+{"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.ts → AttoAlgorithm.export.d.mts}

@@ -20,13 +20,16 @@ export declare namespace AttoAlgorithm.$metadata$ {
     const constructor: abstract new () => AttoAlgorithm;
 }
 export declare namespace AttoAlgorithm {
-    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+    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 */ {
-            from(code: any/* UByte */): AttoAlgorithm;
             private constructor();
         }
     }

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

@@ -6,7 +6,8 @@ import {
   Companion32jhfeb4yz79l as Companion,
   Companion_getInstance19ckbg90y6ov9 as Companion_getInstance,
 } from './AttoAlgorithm.mjs';
-import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.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
@@ -15,8 +16,8 @@ import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin
 var AttoAlgorithm_0 = AttoAlgorithm();
 AttoAlgorithm_0.values = values;
 AttoAlgorithm_0.valueOf = valueOf;
-defineProp(AttoAlgorithm_0, 'V1', AttoAlgorithm_V1_getInstance);
-defineProp(AttoAlgorithm_0, 'Companion', Companion_getInstance);
+defineProp(AttoAlgorithm_0, 'V1', AttoAlgorithm_V1_getInstance, VOID, true);
+defineProp(AttoAlgorithm_0, 'Companion', Companion_getInstance, VOID, true);
 export {
   AttoAlgorithm_0 as AttoAlgorithm,
 };

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

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

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

@@ -25,7 +25,7 @@ import { Enum3alwj03lh1n41 as Enum } from '../../../../kotlin-kotlin-stdlib/kotl
 //region block: pre-declaration
 //endregion
 function _get_$cachedSerializer__te6jhj($this) {
-  return $this.d2v_1.s1();
+  return $this.j2t_1.z1();
 }
 function AttoAlgorithm$Companion$_anonymous__z50osy() {
   return createSimpleEnumSerializer('cash.atto.commons.AttoAlgorithm', values());
@@ -42,33 +42,33 @@ function Companion() {
         var this_0 = get_entries();
         var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(this_0, 10)), 16);
         // Inline function 'kotlin.collections.associateByTo' call
-        var destination = LinkedHashMap().vb(capacity);
-        var _iterator__ex2g4s = this_0.d1();
-        while (_iterator__ex2g4s.e1()) {
-          var element = _iterator__ex2g4s.f1();
+        var destination = LinkedHashMap().wb(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.d3(tmp$ret$0, element);
+          destination.h3(tmp$ret$0, element);
         }
-        tmp.c2v_1 = destination;
+        tmp.i2t_1 = destination;
         var tmp_0 = this;
         var tmp_1 = LazyThreadSafetyMode_PUBLICATION_getInstance();
-        tmp_0.d2v_1 = lazy(tmp_1, AttoAlgorithm$Companion$_anonymous__z50osy);
+        tmp_0.j2t_1 = lazy(tmp_1, AttoAlgorithm$Companion$_anonymous__z50osy);
       }
-      from(code) {
-        var tmp0_elvis_lhs = this.c2v_1.w2(new (UByte())(code));
+      z2v(code) {
+        var tmp0_elvis_lhs = this.i2t_1.p3(new (UByte())(code));
         var tmp;
         if (tmp0_elvis_lhs == null) {
-          throw IllegalArgumentException().u('Unsupported algorithm ' + new (UByte())(code) + ' code');
+          throw IllegalArgumentException().j1('Unsupported algorithm ' + new (UByte())(code) + ' code');
         } else {
           tmp = tmp0_elvis_lhs;
         }
         return tmp;
       }
-      e2v() {
+      k2t() {
         return _get_$cachedSerializer__te6jhj(this);
       }
-      x15(typeParamsSerializers) {
-        return this.e2v();
+      w1x(typeParamsSerializers) {
+        return this.k2t();
       }
     }
     initMetadataForCompanion($, VOID, [SerializerFactory()]);
@@ -91,7 +91,7 @@ function valueOf(value) {
     return AttoAlgorithm_V1_getInstance();
   else {
     AttoAlgorithm_initEntries();
-    THROW_IAE('No enum constant value.');
+    THROW_IAE('No enum constant cash.atto.commons.AttoAlgorithm.' + value);
   }
 }
 function get_entries() {
@@ -119,23 +119,23 @@ function AttoAlgorithm() {
         this.publicKeySize = publicKeySize;
         this.hashSize = hashSize;
       }
-      d2y() {
+      m2w() {
         return this.code;
       }
-      e2y() {
+      n2w() {
         return this.privateKeySize;
       }
-      f2y() {
+      o2w() {
         return this.publicKeySize;
       }
-      g2y() {
+      p2w() {
         return this.hashSize;
       }
       get name() {
-        return this.i3();
+        return this.x3();
       }
       get ordinal() {
-        return this.j3();
+        return this.y3();
       }
     }
     initMetadataForClass($, 'AttoAlgorithm', VOID, VOID, VOID, VOID, VOID, {0: Companion_getInstance});

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

@@ -1 +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":";;;;;;;;;;;;;;;;;;;;;;;;;;uCAgBIA,CAAA,KAAAA,EAAA;A,EAAA,uB;AAIA,C;mDAJAC,CAAAA,EAAA;A,EAAA,8E;AAIA,C;;;;;;;;kBAH4C,I;;qBAAR,a;YCsqCpCC,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,CDnsCwB,I;UCmsCpD,WAAY,IAAI,SAAJ,EAA0B,OAA1B,C;QAChB,C;QDpsC4C,YCqsCrC,W;oBDtsCP,I;oBAAA,8C;QAAA,qE;;UAGIC,CAASC,IAATD,EAAuC;A,YAAA,6CAAI,IAAJ,E;;QAAA,2B;UAAa,mCAAgC,wBAAhC,iBAAuD,IAAvD,IAA2D,OAA3D,C;;gBAAb,c;;QAA+E,U;MAAD,C;SAHzHE,CAAAA,EAAA;A,QAAA,2C;MAIA,C;SAJAA,C,qBAAAA,EAAA;A,QAAA,iB;MAIA,C;;;;;;;;;;;;;;eApBJC,CAAAA,E;;C;gBAAAC,CAKAC,KALAD,E;;;;;;;C;oBAAAE,CAAAA,E;;;;C;;;;;;oDAAA,I,EAAA,C,EAaO,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;;;;;;;;;;;;;;;;;;;;;"}
+{"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.ts → AttoAmount.export.d.mts}

@@ -21,31 +21,36 @@ export declare namespace AttoUnit.$metadata$ {
     const constructor: abstract new () => AttoUnit;
 }
 export declare class AttoAmount /* implements Comparable<AttoAmount> */ {
-    constructor(raw: any/* ULong */);
-    get raw(): any/* ULong */;
+    constructor(raw: bigint);
+    get raw(): bigint;
     toFormattedString(unit: AttoUnit): string;
     plus(amount: AttoAmount): AttoAmount;
     minus(amount: AttoAmount): AttoAmount;
     toString(): string;
-    copy(raw?: any/* ULong */): AttoAmount;
+    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 extends KtSingleton<Companion.$metadata$.constructor>() {
+    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;
-            from(unit: AttoUnit, string: string): AttoAmount;
             private constructor();
         }
     }
-}
+}
+export declare function toAttoAmount(_this_: string): AttoAmount;

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

@@ -5,10 +5,13 @@ import {
   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 { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.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
@@ -17,13 +20,15 @@ import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin
 var AttoUnit_0 = AttoUnit();
 AttoUnit_0.values = values;
 AttoUnit_0.valueOf = valueOf;
-defineProp(AttoUnit_0, 'ATTO', AttoUnit_ATTO_getInstance);
-defineProp(AttoUnit_0, 'RAW', AttoUnit_RAW_getInstance);
+defineProp(AttoUnit_0, 'ATTO', AttoUnit_ATTO_getInstance, VOID, true);
+defineProp(AttoUnit_0, 'RAW', AttoUnit_RAW_getInstance, VOID, true);
 var AttoAmount_0 = AttoAmount();
-defineProp(AttoAmount_0, 'Companion', Companion_getInstance);
+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
 

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

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