@attocash/commons-js 5.0.0

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

@@ -0,0 +1,250 @@
+import {
+  fromHexToByteArrayplx5jrfi7guj as fromHexToByteArray,
+  checkLength3j1sz9qw7d9m6 as checkLength,
+  toHexcxaq2tti5e5x as toHex,
+  toULong2ecnriauv8ptn as toULong,
+} from './Extensions.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 { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  AttoOpenBlock12k0m6lgjqi4d as AttoOpenBlock,
+  PreviousSupport1um4ogj9ve97w as PreviousSupport,
+} from './AttoBlock.mjs';
+import {
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import {
+  contentEquals1cdp6c846cfdi as contentEquals,
+  contentHashCode25jw6rgkgywwr as contentHashCode,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_ArraysJs.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 { KSerializerzf77vz1967fq as KSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+import { LinkedHashMap1zhqxkxv3xnkl as LinkedHashMap } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/LinkedHashMap.mjs';
+import {
+  get_entries3gde2hky4su5g as get_entries,
+  Companion_getInstance2p3k72yokmh5j as Companion_getInstance,
+} from './AttoNetwork.mjs';
+import { System_instance3dr57gee6r420 as System_instance } from '../../../../Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/Clock.mjs';
+import {
+  Companion_getInstance3qu5ydsg8audm as Companion_getInstance_0,
+  toLocalDateTime3u4c8ydzr4ubp as toLocalDateTime,
+} from '../../../../Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/TimeZone.mjs';
+import {
+  doubleToULong2nujnatydtf7 as doubleToULong,
+  ulongDivide3e52ct8hxp5n7 as ulongDivide,
+  ulongCompare29yg6v52hxi4l as ulongCompare,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UnsignedJs.mjs';
+import {
+  _ULong___get_data__impl__fggpzb2qlkrfp9zs48z as _ULong___get_data__impl__fggpzb,
+  _ULong___init__impl__c78o9k1p6qzv0dh0bvg as _ULong___init__impl__c78o9k,
+  ULong3f9k7s38t3rfp as ULong,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/ULong.mjs';
+import { toMapcf6xfku344cz as toMap } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/Maps.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { AttoHasher_instance3904w4qpo055r as AttoHasher_instance } from './AttoHasher.js.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_thresholdCache() {
+  _init_properties_AttoWork_kt__ln1ynz();
+  return thresholdCache;
+}
+var thresholdCache;
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        this.SIZE = 8;
+      }
+      t32() {
+        return this.SIZE;
+      }
+      threshold(network, timestamp) {
+        return getThreshold(this, network, timestamp);
+      }
+      parse(value) {
+        return new (AttoWork())(fromHexToByteArray(value));
+      }
+      q2u() {
+        return AttoWorkSerializer_getInstance();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance_1() {
+  return Companion_instance;
+}
+var AttoWorkClass;
+function AttoWork() {
+  if (AttoWorkClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.value = value;
+        checkLength(this.value, 8);
+      }
+      s1() {
+        return this.value;
+      }
+      isValid(block) {
+        if (block instanceof AttoOpenBlock()) {
+          return isValid(Companion_instance, block.v2u_1, block.a2v_1, block.y2u_1.value, this.value);
+        }
+        if (!isInterface(block, PreviousSupport()))
+          THROW_CCE();
+        return isValid(Companion_instance, block.network, block.timestamp, block.previous.value, this.value);
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AttoWork()))
+          return false;
+        return contentEquals(this.value, other.value);
+      }
+      hashCode() {
+        return contentHashCode(this.value);
+      }
+      toString() {
+        return toHex(this.value);
+      }
+      gl() {
+        return this.value;
+      }
+      h31(value) {
+        return new (AttoWork())(value);
+      }
+      copy(value, $super) {
+        value = value === VOID ? this.value : value;
+        return $super === VOID ? this.h31(value) : $super.h31.call(this, value);
+      }
+    }
+    initMetadataForClass($, 'AttoWork', VOID, VOID, VOID, VOID, VOID, {0: AttoWorkSerializer_getInstance});
+    AttoWorkClass = $;
+  }
+  return AttoWorkClass;
+}
+var AttoWorkSerializerClass;
+function AttoWorkSerializer() {
+  if (AttoWorkSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoWorkSerializer_instance = this;
+        this.w34_1 = PrimitiveSerialDescriptor('AttoWork', STRING_getInstance());
+      }
+      xs() {
+        return this.w34_1;
+      }
+      x34(encoder, value) {
+        encoder.oy(value.toString());
+      }
+      ys(encoder, value) {
+        return this.x34(encoder, value instanceof AttoWork() ? value : THROW_CCE());
+      }
+      zs(decoder) {
+        return Companion_instance.parse(decoder.fx());
+      }
+    }
+    initMetadataForObject($, 'AttoWorkSerializer', VOID, VOID, [KSerializer()]);
+    AttoWorkSerializerClass = $;
+  }
+  return AttoWorkSerializerClass;
+}
+var AttoWorkSerializer_instance;
+function AttoWorkSerializer_getInstance() {
+  if (AttoWorkSerializer_instance === VOID)
+    new (AttoWorkSerializer())();
+  return AttoWorkSerializer_instance;
+}
+function initializeThresholdCache() {
+  _init_properties_AttoWork_kt__ln1ynz();
+  // Inline function 'kotlin.collections.mutableMapOf' call
+  var cache = LinkedHashMap().ub();
+  var _iterator__ex2g4s = get_entries().d1();
+  while (_iterator__ex2g4s.e1()) {
+    var network = _iterator__ex2g4s.f1();
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    var yearMap = LinkedHashMap().ub();
+    var inductionVariable = Companion_getInstance().INITIAL_DATE.z1g();
+    var last = toLocalDateTime(System_instance.i1e(), Companion_getInstance_0().d1w_1).z1g() + 10 | 0;
+    if (inductionVariable <= last)
+      do {
+        var year = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.math.pow' call
+        var x = (year - Companion_getInstance().INITIAL_DATE.z1g() | 0) / Companion_getInstance().DOUBLING_PERIOD;
+        // Inline function 'kotlin.toULong' call
+        var this_0 = Math.pow(2.0, x);
+        var decreaseFactor = doubleToULong(this_0);
+        var tmp0 = Companion_getInstance().INITIAL_LIVE_THRESHOLD;
+        // Inline function 'kotlin.ULong.times' call
+        var other = network.thresholdIncreaseFactor;
+        var initialThreshold = _ULong___init__impl__c78o9k(_ULong___get_data__impl__fggpzb(tmp0).r3(_ULong___get_data__impl__fggpzb(other)));
+        var tmp2 = year;
+        // Inline function 'kotlin.ULong.div' call
+        var tmp$ret$5 = ulongDivide(initialThreshold, decreaseFactor);
+        // Inline function 'kotlin.collections.set' call
+        var value = new (ULong())(tmp$ret$5);
+        yearMap.d3(tmp2, value);
+      }
+       while (!(year === last));
+    // Inline function 'kotlin.collections.set' call
+    var value_0 = toMap(yearMap);
+    cache.d3(network, value_0);
+  }
+  return toMap(cache);
+}
+function getThreshold(_this__u8e3s4, network, timestamp) {
+  _init_properties_AttoWork_kt__ln1ynz();
+  if (timestamp.r1w(Companion_getInstance().INITIAL_INSTANT) < 0) {
+    throw IllegalArgumentException().u('Timestamp(' + timestamp.toString() + ') lower than initialInstant(' + Companion_getInstance().INITIAL_INSTANT.toString() + ')');
+  }
+  return ensureNotNull(ensureNotNull(get_thresholdCache().w2(network)).w2(toLocalDateTime(timestamp, Companion_getInstance_0().d1w_1).z1g())).fs_1;
+}
+function isValid(_this__u8e3s4, network, timestamp, target, work) {
+  _init_properties_AttoWork_kt__ln1ynz();
+  if (timestamp.r1w(Companion_getInstance().INITIAL_INSTANT) < 0) {
+    return false;
+  }
+  return isValid_0(_this__u8e3s4, getThreshold(Companion_instance, network, timestamp), target, work);
+}
+function isValid_0(_this__u8e3s4, threshold, target, work) {
+  _init_properties_AttoWork_kt__ln1ynz();
+  var difficult = toULong(AttoHasher_instance.d2x(8, [work, target]));
+  // Inline function 'kotlin.ULong.compareTo' call
+  return ulongCompare(_ULong___get_data__impl__fggpzb(difficult), _ULong___get_data__impl__fggpzb(threshold)) <= 0;
+}
+var properties_initialized_AttoWork_kt_b4scvz;
+function _init_properties_AttoWork_kt__ln1ynz() {
+  if (!properties_initialized_AttoWork_kt_b4scvz) {
+    properties_initialized_AttoWork_kt_b4scvz = true;
+    thresholdCache = initializeThresholdCache();
+  }
+}
+//region block: init
+Companion_instance = new (Companion())();
+//endregion
+//region block: exports
+export {
+  Companion as Companion1lrb5n4gqkde2,
+  AttoWork as AttoWorkrxvyu0kmlxrx,
+  getThreshold as getThresholdcflwip0mgpox,
+  Companion_getInstance_1 as Companion_getInstance3hq710dmrbb22,
+  Companion_instance as Companion_instance34cvisfr2k5u0,
+  AttoWorkSerializer_getInstance as AttoWorkSerializer_getInstance2knpvs0pp68c1,
+};
+//endregion
+
+//# sourceMappingURL=AttoWork.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoWork.kt","src/kotlin/collections/Maps.kt","js/src/kotlin/math.kt","unsigned/src/kotlin/ULong.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-thresholdCache>","<get-SIZE>","threshold","network","timestamp","parse","value","serializer","<get-value>","isValid","block","equals","other","hashCode","toString","<get-descriptor>","serialize","encoder","deserialize","decoder","initializeThresholdCache","cache","yearMap","year","decreaseFactor","initialThreshold","getThreshold","<this>","target","work","difficult","<init properties AttoWork.kt>"],"mappings":"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"}

package/commons-commons-core/cash/atto/commons/Extensions.export.d.ts

@@ -0,0 +1,4 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare function toHex(_this_: Int8Array): string;
+export declare function fromHexToByteArray(_this_: string): Int8Array;

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

@@ -0,0 +1,16 @@
+import {
+  toHexcxaq2tti5e5x as toHex,
+  fromHexToByteArrayplx5jrfi7guj as fromHexToByteArray,
+} from './Extensions.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+export {
+  toHex as toHex,
+  fromHexToByteArray as fromHexToByteArray,
+};
+//endregion
+
+//# sourceMappingURL=Extensions.export.mjs.map

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

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

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

@@ -0,0 +1,99 @@
+import { Companion_getInstance2zux61tby3qbv as Companion_getInstance } from '../../../../kotlin-kotlin-stdlib/kotlin/text/HexFormat.mjs';
+import { toHexString5bhtjxqec7ow as toHexString } from '../../../../kotlin-kotlin-stdlib/kotlin/text/HexExtensions.mjs';
+import { chunked1r6ubl9km7ic5 as chunked } from '../../../../kotlin-kotlin-stdlib/kotlin/text/_Strings.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/Iterables.mjs';
+import { toInt5qdj874w69jh as toInt } from '../../../../kotlin-kotlin-stdlib/kotlin/text/numberConversions.mjs';
+import { toByte4i43936u611k as toByte } from '../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { toByteArray3caw0hip00os as toByteArray } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { Buffergs925ekssbch as Buffer } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs';
+import { writeInstant3u6p01dcjd90s as writeInstant } from './AttoBufferExtensions.mjs';
+import {
+  readByteArray1ri21h2rciakw as readByteArray,
+  readULongLe85hcoxmq2r21 as readULongLe,
+} from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Sources.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function toHex(_this__u8e3s4) {
+  return toHexString(_this__u8e3s4, Companion_getInstance().po_1);
+}
+function fromHexToByteArray(_this__u8e3s4) {
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = chunked(_this__u8e3s4, 2);
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList().c1(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.d1();
+  while (_iterator__ex2g4s.e1()) {
+    var item = _iterator__ex2g4s.f1();
+    var tmp$ret$0 = toByte(toInt(item, 16));
+    destination.m(tmp$ret$0);
+  }
+  return toByteArray(destination);
+}
+function toByteArray_0(_this__u8e3s4) {
+  var buffer = new (Buffer())();
+  writeInstant(buffer, _this__u8e3s4);
+  return readByteArray(buffer);
+}
+function checkLength(_this__u8e3s4, size) {
+  // Inline function 'kotlin.require' call
+  if (!(_this__u8e3s4.length === size)) {
+    var message = 'Byte array contains ' + _this__u8e3s4.length + ' characters but should contains ' + size;
+    throw IllegalArgumentException().u(toString(message));
+  }
+}
+function toULong(_this__u8e3s4) {
+  var buffer = new (Buffer())();
+  buffer.q2s(_this__u8e3s4);
+  return readULongLe(buffer);
+}
+function toUint8Array(_this__u8e3s4) {
+  var output = new Uint8Array(_this__u8e3s4.length);
+  // Inline function 'kotlin.repeat' call
+  var times = _this__u8e3s4.length;
+  var inductionVariable = 0;
+  if (inductionVariable < times)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'org.khronos.webgl.set' call
+      // Inline function 'kotlin.js.asDynamic' call
+      output[index] = _this__u8e3s4[index];
+    }
+     while (inductionVariable < times);
+  return output;
+}
+function toByteArray_1(_this__u8e3s4) {
+  var output = new Int8Array(_this__u8e3s4.length);
+  // Inline function 'kotlin.repeat' call
+  var times = _this__u8e3s4.length;
+  var inductionVariable = 0;
+  if (inductionVariable < times)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'org.khronos.webgl.get' call
+      // Inline function 'kotlin.js.asDynamic' call
+      output[index] = _this__u8e3s4[index];
+    }
+     while (inductionVariable < times);
+  return output;
+}
+//region block: exports
+export {
+  checkLength as checkLength3j1sz9qw7d9m6,
+  fromHexToByteArray as fromHexToByteArrayplx5jrfi7guj,
+  toByteArray_1 as toByteArray3f5i5urnfv0wu,
+  toByteArray_0 as toByteArraysomwepl209vv,
+  toHex as toHexcxaq2tti5e5x,
+  toULong as toULong2ecnriauv8ptn,
+  toUint8Array as toUint8Array1omfedyjm9v5o,
+};
+//endregion
+
+//# sourceMappingURL=Extensions.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/Extensions.kt","common/src/generated/_Collections.kt","src/kotlin/util/Preconditions.kt","../../../../../../../commons-core/src/jsMain/kotlin/cash/atto/commons/Extensions.kt","src/kotlin/util/Standard.kt","libraries/stdlib/js/src/org.w3c/org.khronos.webgl.kt"],"sourcesContent":[null,null,null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["toHex","<this>","fromHexToByteArray","item","toByteArray","buffer","checkLength","size","message","toULong","toUint8Array","output","index"],"mappings":";;;;;;;;;;;;;;;;;;;;;cAUAA,CAEIC,aAFJD,EAEgC;A,EAAqC,OAAhC,YAAL,aAAK,0BAAsB,IAAtB,C;AAA+B,C;2BAQpEE,CAEID,aAFJC,EAGI;A;eAAA,uBAAQ,CAAR,C;;oBCmgDa,eAAa,gCAAwB,EAAxB,CAAb,C;MAuEA,oBAvEN,MAuEM,K;SAAA,sB,EACT;A,QADCC,OAAQ,sB;oBDzkDW,OAAV,MC0kDgB,ID1kDhB,EAAM,EAAN,CAAU,C;IC0kDpB,WAAY,GAAI,SAAJ,C;EAAmB,C;EDzkDjB,OAAb,YC0kDE,WD1kDF,C;AAAY,C;sBAMrBC,CAAIH,aAAJG,EAAqC;A,MACjCC,yB;EACO,aAAP,MAAO,EAAa,aAAb,C;EACP,OAAc,cAAP,MAAO,C;AAClB,C;oBARAC,CAAIL,a,EAAsBM,IAA1BD,EAAqC;A;EEQ7B,MFPI,cAAK,MAAL,KAAa,IEOjB,E,CAAQ;A,QACRE,UFR0B,sBAAD,GAAuB,aAAvB,CAA4B,MAA5B,GAAiC,kCAAjC,GAAkE,I;IES3F,mCAAuC,SAAR,OAAQ,CAAvC,C;EACJ,C;AFTJ,C;gBAQAC,CAAIR,aAAJQ,EAA+B;A,MAC3BJ,yB;EACA,MAAO,KAAM,aAAN,C;EACP,OAAc,YAAP,MAAO,C;AAClB,C;qBGvBAK,CAAIT,aAAJS,EAAyC;A,MACrCC,SAAa,eAAW,aAAX,CAAW,MAAX,C;;cACN,a,CAAA,M;MCuIO,qB;EAAd,wBAAsB,KAAtB,C;OAAA;A,UAAKC,QAAS,iB;MAAA,6C;;;MDtIV,MEk8B6D,CD3zBtD,KC2zBsD,IFl8B7C,cCuIT,KDvIS,C;;ICsIpB,4BAAsB,KAAtB,C;EDpIA,OAAO,M;AACX,C;sBAdAR,CAAIH,aAAJG,EAAwC;A,MACpCO,SAAa,cAAU,aAAV,CAAU,MAAV,C;;cACN,a,CAAA,M;MC+IO,qB;EAAd,wBAAsB,KAAtB,C;OAAA;A,UAAKC,QAAS,iB;MAAA,6C;;;MD9IV,OC+IO,KD/IP,IAAgB,aEs8BsC,CDvzB/C,KCuzB+C,C;;IDxzB1D,4BAAsB,KAAtB,C;ED5IA,OAAO,M;AACX,C;;;;;"}

package/commons-commons-core/cash/atto/commons/serialiazer/AttoAddressAsByteArraySerializer.mjs

@@ -0,0 +1,55 @@
+import { BYTE_getInstance1ja41txt3fdgs as BYTE_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 { ByteArraySerializersn06x87bo7h0 as ByteArraySerializer } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/builtins/BuiltinSerializers.mjs';
+import { readByteArray1ri21h2rciakw as readByteArray } from '../../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Sources.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import {
+  AttoAddressi1gjrmqbg81z as AttoAddress,
+  Companion_getInstance2vcugmik704gt as Companion_getInstance,
+} from '../AttoAddress.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+import { initMetadataForObject1cxne3s9w65el as initMetadataForObject } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var AttoAddressAsByteArraySerializerClass;
+function AttoAddressAsByteArraySerializer() {
+  if (AttoAddressAsByteArraySerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoAddressAsByteArraySerializer_instance = this;
+        this.y34_1 = PrimitiveSerialDescriptor('AttoAddress', BYTE_getInstance());
+      }
+      xs() {
+        return this.y34_1;
+      }
+      z34(encoder, value) {
+        encoder.cz(ByteArraySerializer(), readByteArray(value.toBuffer()));
+      }
+      ys(encoder, value) {
+        return this.z34(encoder, value instanceof AttoAddress() ? value : THROW_CCE());
+      }
+      zs(decoder) {
+        return Companion_getInstance().parseSerialized(decoder.jx(ByteArraySerializer()));
+      }
+    }
+    initMetadataForObject($, 'AttoAddressAsByteArraySerializer', VOID, VOID, [KSerializer()]);
+    AttoAddressAsByteArraySerializerClass = $;
+  }
+  return AttoAddressAsByteArraySerializerClass;
+}
+var AttoAddressAsByteArraySerializer_instance;
+function AttoAddressAsByteArraySerializer_getInstance() {
+  if (AttoAddressAsByteArraySerializer_instance === VOID)
+    new (AttoAddressAsByteArraySerializer())();
+  return AttoAddressAsByteArraySerializer_instance;
+}
+//region block: exports
+export {
+  AttoAddressAsByteArraySerializer_getInstance as AttoAddressAsByteArraySerializer_getInstance5b6d6uuo8kst,
+};
+//endregion
+
+//# sourceMappingURL=AttoAddressAsByteArraySerializer.mjs.map

package/commons-commons-core/cash/atto/commons/serialiazer/AttoAddressAsByteArraySerializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/serialiazer/AttoAddressAsByteArraySerializer.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-descriptor>","serialize","encoder","value","deserialize","decoder"],"mappings":";;;;;;;;;;;;;;;;;;;;;;QAY8B,uCAA0B,aAA1B,qB;;QAA1BA,CAAAA,EAAA;A,QAAA,iB;MAAsB,C;SAEtBC,CACIC,O,EACAC,KAFJF,EAGE;A,QACE,OAAQ,IAAwB,qBAAxB,EAAgE,cAAjB,KAAM,WAAW,CAAhE,C;MACZ,C;SAImzLC,O,EAAkBC,K;;;QAFr0LC,CAAyBC,OAAzBD,EAA0D;A,QAAyE,OAA7D,wCAAM,OAAQ,IAAwB,qBAAxB,CAAd,C;MAA4D,C;;;;;;;;;;;;;;;;;"}

package/commons-commons-core/cash/atto/commons/serialiazer/InstantMillisSerializer.mjs

@@ -0,0 +1,54 @@
+import { LONG_getInstance3408a5feo2kfb as LONG_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 {
+  Instant3cn81rq2kpflk as Instant,
+  Companion_getInstance3vjikuur3h0k4 as Companion_getInstance,
+} from '../../../../../Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/Instant.mjs';
+import { KSerializerzf77vz1967fq as KSerializer } from '../../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
+import { initMetadataForObject1cxne3s9w65el as initMetadataForObject } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var InstantMillisSerializerClass;
+function InstantMillisSerializer() {
+  if (InstantMillisSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        InstantMillisSerializer_instance = this;
+        this.a35_1 = PrimitiveSerialDescriptor('InstantMillis', LONG_getInstance());
+      }
+      xs() {
+        return this.a35_1;
+      }
+      i1v(encoder, value) {
+        encoder.ky(value.o1w());
+      }
+      ys(encoder, value) {
+        return this.i1v(encoder, value instanceof Instant() ? value : THROW_CCE());
+      }
+      zs(decoder) {
+        var millis = decoder.bx();
+        return Companion_getInstance().k1w(millis);
+      }
+    }
+    initMetadataForObject($, 'InstantMillisSerializer', VOID, VOID, [KSerializer()]);
+    InstantMillisSerializerClass = $;
+  }
+  return InstantMillisSerializerClass;
+}
+var InstantMillisSerializer_instance;
+function InstantMillisSerializer_getInstance() {
+  if (InstantMillisSerializer_instance === VOID)
+    new (InstantMillisSerializer())();
+  return InstantMillisSerializer_instance;
+}
+//region block: exports
+export {
+  InstantMillisSerializer_getInstance as InstantMillisSerializer_getInstance119d7idybowz2,
+};
+//endregion
+
+//# sourceMappingURL=InstantMillisSerializer.mjs.map

package/commons-commons-core/cash/atto/commons/serialiazer/InstantMillisSerializer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/serialiazer/InstantMillisSerializer.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-descriptor>","serialize","encoder","value","deserialize","decoder","millis"],"mappings":";;;;;;;;;;;;;;;;;;;;QAU8B,uCAA0B,eAA1B,qB;;QAA1BA,CAAAA,EAAA;A,QAAA,iB;MAAsB,C;SAEtBC,CACIC,O,EACAC,KAFJF,EAGE;A,QACE,OAAQ,IAAW,KAAM,MAAjB,C;MACZ,C;SAOm7LC,O,EAAkBC,K;;;QALr8LC,CAAyBC,OAAzBD,EAAoD;A,YAChDE,SAAa,OAAQ,K;QACrB,OAAe,4BAAsB,MAAtB,C;MACnB,C;;;;;;;;;;;;;;;;;"}

package/commons-commons-core/cash/atto/commons/utils/Base32.mjs

@@ -0,0 +1,156 @@
+import {
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  charSequenceGet1vxk1y5n17t1z as charSequenceGet,
+  charCodeAt1yspne1d8erbm as charCodeAt,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/charSequenceJs.mjs';
+import {
+  Char__toInt_impl_vasixd1agw9q2fuvclj as Char__toInt_impl_vasixd,
+  _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx,
+  toString3o7ifthqydp6e as toString,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { StringBuildermazzzhj6kkai as StringBuilder } from '../../../../../kotlin-kotlin-stdlib/kotlin/text/StringBuilderJs.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { toString1pkumu07cwy4m as toString_0 } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { toByte4i43936u611k as toByte } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import { initMetadataForObject1cxne3s9w65el as initMetadataForObject } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+//endregion
+var Base32Class;
+function Base32() {
+  if (Base32Class === VOID) {
+    class $ {
+      constructor() {
+        Base32_instance = this;
+        this.l2x_1 = 'abcdefghijklmnopqrstuvwxyz234567';
+        var tmp = this;
+        var tmp_0 = 0;
+        var tmp_1 = new Int32Array(128);
+        while (tmp_0 < 128) {
+          tmp_1[tmp_0] = -1;
+          tmp_0 = tmp_0 + 1 | 0;
+        }
+        // Inline function 'kotlin.apply' call
+        // Inline function 'kotlin.text.forEachIndexed' call
+        var index = 0;
+        var indexedObject = Base32_getInstance().l2x_1;
+        var inductionVariable = 0;
+        while (inductionVariable < charSequenceLength(indexedObject)) {
+          var item = charSequenceGet(indexedObject, inductionVariable);
+          inductionVariable = inductionVariable + 1 | 0;
+          var _unary__edvuaz = index;
+          index = _unary__edvuaz + 1 | 0;
+          // Inline function 'kotlin.code' call
+          tmp_1[Char__toInt_impl_vasixd(item)] = _unary__edvuaz;
+        }
+        // Inline function 'kotlin.text.uppercase' call
+        // Inline function 'kotlin.js.asDynamic' call
+        // Inline function 'kotlin.text.forEachIndexed' call
+        var index_0 = 0;
+        var indexedObject_0 = Base32_getInstance().l2x_1.toUpperCase();
+        var inductionVariable_0 = 0;
+        while (inductionVariable_0 < charSequenceLength(indexedObject_0)) {
+          var item_0 = charSequenceGet(indexedObject_0, inductionVariable_0);
+          inductionVariable_0 = inductionVariable_0 + 1 | 0;
+          var _unary__edvuaz_0 = index_0;
+          index_0 = _unary__edvuaz_0 + 1 | 0;
+          // Inline function 'kotlin.code' call
+          tmp_1[Char__toInt_impl_vasixd(item_0)] = _unary__edvuaz_0;
+        }
+        tmp.m2x_1 = tmp_1;
+      }
+      o2x(data) {
+        var result = StringBuilder().a1();
+        var buffer = 0;
+        var bitsLeft = 0;
+        // Inline function 'kotlin.collections.forEach' call
+        var inductionVariable = 0;
+        var last = data.length;
+        while (inductionVariable < last) {
+          var element = data[inductionVariable];
+          inductionVariable = inductionVariable + 1 | 0;
+          buffer = buffer << 8 | element & 255;
+          bitsLeft = bitsLeft + 8 | 0;
+          while (bitsLeft >= 5) {
+            result.kb(charCodeAt(Base32_getInstance().l2x_1, buffer >> (bitsLeft - 5 | 0) & 31));
+            bitsLeft = bitsLeft - 5 | 0;
+          }
+        }
+        if (bitsLeft > 0) {
+          result.kb(charCodeAt(this.l2x_1, buffer << (5 - bitsLeft | 0) & 31));
+        }
+        while (!((result.a() % 8 | 0) === 0)) {
+          result.jb('=');
+        }
+        return result.toString();
+      }
+      n2x(base32) {
+        // Inline function 'kotlin.text.filter' call
+        // Inline function 'kotlin.text.filterTo' call
+        var destination = StringBuilder().a1();
+        var inductionVariable = 0;
+        var last = charSequenceLength(base32);
+        if (inductionVariable < last)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var element = charSequenceGet(base32, index);
+            if (!(element === _Char___init__impl__6a9atx(61))) {
+              destination.kb(element);
+            }
+          }
+           while (inductionVariable < last);
+        // Inline function 'kotlin.text.lowercase' call
+        // Inline function 'kotlin.js.asDynamic' call
+        var data = destination.toString().toLowerCase();
+        var output = new Int8Array(imul(data.length, 5) / 8 | 0);
+        var buffer = 0;
+        var bitsLeft = 0;
+        var index_0 = 0;
+        // Inline function 'kotlin.text.forEach' call
+        var inductionVariable_0 = 0;
+        while (inductionVariable_0 < charSequenceLength(data)) {
+          var element_0 = charSequenceGet(data, inductionVariable_0);
+          inductionVariable_0 = inductionVariable_0 + 1 | 0;
+          var tmp = Base32_getInstance().m2x_1;
+          // Inline function 'kotlin.code' call
+          var value = tmp[Char__toInt_impl_vasixd(element_0)];
+          // Inline function 'kotlin.require' call
+          if (!!(value === -1)) {
+            var message = 'Invalid Base32 character: ' + toString(element_0);
+            throw IllegalArgumentException().u(toString_0(message));
+          }
+          buffer = buffer << 5 | value;
+          bitsLeft = bitsLeft + 5 | 0;
+          if (bitsLeft >= 8) {
+            var _unary__edvuaz = index_0;
+            index_0 = _unary__edvuaz + 1 | 0;
+            output[_unary__edvuaz] = toByte(buffer >> (bitsLeft - 8 | 0));
+            bitsLeft = bitsLeft - 8 | 0;
+          }
+        }
+        return output;
+      }
+    }
+    initMetadataForObject($, 'Base32');
+    Base32Class = $;
+  }
+  return Base32Class;
+}
+var Base32_instance;
+function Base32_getInstance() {
+  if (Base32_instance === VOID)
+    new (Base32())();
+  return Base32_instance;
+}
+//region block: exports
+export {
+  Base32_getInstance as Base32_getInstance1zhax53mffzee,
+};
+//endregion
+
+//# sourceMappingURL=Base32.mjs.map