@attocash/commons-js 5.0.0

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

@@ -0,0 +1,19 @@
+import {
+  AttoPrivateKey1a153ds4lgph7 as AttoPrivateKey,
+  Companion1cqh6ycnha9e9 as Companion,
+  Companion_getInstance18roh4hqviqwb as Companion_getInstance,
+} from './AttoPrivateKey.mjs';
+import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoPrivateKey_0 = AttoPrivateKey();
+defineProp(AttoPrivateKey_0, 'Companion', Companion_getInstance);
+export {
+  AttoPrivateKey_0 as AttoPrivateKey,
+};
+//endregion
+
+//# sourceMappingURL=AttoPrivateKey.export.mjs.map

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

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

package/commons-commons-core/cash/atto/commons/AttoPrivateKey.js.mjs

@@ -0,0 +1,65 @@
+import { SHA512 as SHA512 } from '@stablelib/sha512';
+import { HMAC as HMAC } from '@stablelib/hmac';
+import {
+  toTypedArray3sl1vhn8ifta0 as toTypedArray,
+  copyOfRange3alro60z4hhf8 as copyOfRange,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_ArraysJs.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 { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var HmacSha512Class;
+function HmacSha512() {
+  if (HmacSha512Class === VOID) {
+    class $ {
+      constructor(secretKey) {
+        this.d32_1 = new HMAC(SHA512, new Uint8Array(toTypedArray(secretKey)));
+      }
+      l32(data, offset, len) {
+        var chunk = copyOfRange(data, offset, offset + len | 0);
+        this.d32_1.update(new Uint8Array(toTypedArray(chunk)));
+      }
+      e32(data, offset, len, $super) {
+        offset = offset === VOID ? 0 : offset;
+        len = len === VOID ? data.length : len;
+        var tmp;
+        if ($super === VOID) {
+          this.l32(data, offset, len);
+          tmp = Unit_instance;
+        } else {
+          tmp = $super.l32.call(this, data, offset, len);
+        }
+        return tmp;
+      }
+      f32(output, offset) {
+        var digest = this.d32_1.digest();
+        // Inline function 'kotlin.repeat' call
+        var times = digest.length;
+        var inductionVariable = 0;
+        if (inductionVariable < times)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var tmp = offset + index | 0;
+            // Inline function 'org.khronos.webgl.get' call
+            // Inline function 'kotlin.js.asDynamic' call
+            output[tmp] = digest[index];
+          }
+           while (inductionVariable < times);
+      }
+    }
+    initMetadataForClass($, 'HmacSha512');
+    HmacSha512Class = $;
+  }
+  return HmacSha512Class;
+}
+//region block: exports
+export {
+  HmacSha512 as HmacSha5121eatetr6r60fb,
+};
+//endregion
+
+//# sourceMappingURL=AttoPrivateKey.js.mjs.map

package/commons-commons-core/cash/atto/commons/AttoPrivateKey.js.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/jsMain/kotlin/cash/atto/commons/AttoPrivateKey.js.kt","src/kotlin/util/Standard.kt","libraries/stdlib/js/src/org.w3c/org.khronos.webgl.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["secretKey","update","data","offset","len","chunk","update$default","doFinal","output","digest","index"],"mappings":";;;;;;;;;;;;;;;;;kBAUIA,S;QAEmB,sBAAK,MAAL,EAAsB,eAAqB,aAAV,SAAU,CAArB,CAAtB,C;;SAEnBC,CACIC,I,EACAC,M,EACAC,GAHJH,EAIE;A,YACEI,QAAiB,YAAL,IAAK,EAAY,MAAZ,EAAoB,SAAS,GAA7B,K;QACjB,IAAK,CAAL,KAAK,QAAO,eAAiB,aAAN,KAAM,CAAjB,CAAP,C;MACT,C;SAPAC,CACIJ,I,EACAC,M,EACAC,G,QAHJE,E;mCAoB6kC,C;6BAAsB,I,CAAK,M;;;;;;;;;O;SAXxmCC,CACIC,M,EACAL,MAFJI,EAGE;A,YACEE,SAAa,IAAK,CAAL,KAAK,S;;oBAEX,M,CAAO,M;YC8HJ,qB;QAAd,wBAAsB,KAAtB,C;aAAA;A,gBAAKC,QAAS,iB;YAAA,6C;sBD7HC,SC8HJ,K;;;YD9HH,cAAyB,MEq7ByB,CDvzB/C,KCuzB+C,C;;UDxzB1D,4BAAsB,KAAtB,C;MD3HA,C;;;;;;;;;;;"}

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

@@ -0,0 +1,189 @@
+import {
+  fromHexToByteArrayplx5jrfi7guj as fromHexToByteArray,
+  checkLength3j1sz9qw7d9m6 as checkLength,
+} from './Extensions.mjs';
+import { SecureRandom_instance3d03x1xookdam as SecureRandom_instance } from './utils/SecureRandom.js.mjs';
+import {
+  _UInt___init__impl__l7qpdltd1eeof8nsuj as _UInt___init__impl__l7qpdl,
+  UInt1hthisrv6cndi as UInt,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UInt.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 {
+  createThis2j2avj17cvnv2 as createThis,
+  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 { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { isCharSequence1ju9jr1w86plq as isCharSequence } from '../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import {
+  trim11nh7r46at6sx as trim,
+  split2bvyvnrlcifjv as split,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/text/Strings.mjs';
+import {
+  equals2v6cggk171b6e as equals,
+  replace3le3ie7l9k8aq as replace,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/text/stringsCode.mjs';
+import { toInt2q8uldh7sc951 as toInt } from '../../../../kotlin-kotlin-stdlib/kotlin/text/numberConversions.mjs';
+import { encodeToByteArray1onwao0uakjfh as encodeToByteArray } from '../../../../kotlin-kotlin-stdlib/kotlin/text/stringJs.mjs';
+import { HmacSha5121eatetr6r60fb as HmacSha512 } from './AttoPrivateKey.js.mjs';
+import { asSequence2phdjljfh9jhx as asSequence } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import {
+  mapsbvh18eqox7a as map,
+  filter184huxd00uyfg as filter,
+  toListx6x8nvfmvvht as toList,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/sequences/_Sequences.mjs';
+import { copyOfRange3alro60z4hhf8 as copyOfRange } from '../../../../kotlin-kotlin-stdlib/kotlin/collections/_ArraysJs.mjs';
+import { Buffergs925ekssbch as Buffer } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs';
+import { readByteArray1ri21h2rciakw as readByteArray } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Sources.mjs';
+import { toByte4i43936u611k as toByte } from '../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        this.z31_1 = 1869902945;
+      }
+      parse(value) {
+        return AttoPrivateKey().a32(fromHexToByteArray(value));
+      }
+      generate() {
+        var value = SecureRandom_instance.b32(_UInt___init__impl__l7qpdl(32));
+        return AttoPrivateKey().a32(value);
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+var AttoPrivateKeyClass;
+function AttoPrivateKey() {
+  if (AttoPrivateKeyClass === VOID) {
+    class $ {
+      constructor(value) {
+        return new.target.a32(value);
+      }
+      static a32(value) {
+        var $this = createThis(this);
+        $this.value = value;
+        checkLength($this.value, 32);
+        return $this;
+      }
+      s1() {
+        return this.value;
+      }
+      static fromSeed(seed, index) {
+        return this.a32(ed25519BIP44(seed, "m/44'/" + Companion_instance.z31_1 + "'/" + new (UInt())(index) + "'"));
+      }
+      toString() {
+        return '' + this.value.length + ' bytes';
+      }
+    }
+    initMetadataForClass($, 'AttoPrivateKey');
+    AttoPrivateKeyClass = $;
+  }
+  return AttoPrivateKeyClass;
+}
+function ed25519BIP44(seed, path) {
+  return Companion_instance_0.c32(seed, path);
+}
+function BIP44$Companion$ed25519$lambda(it) {
+  // Inline function 'kotlin.text.trim' call
+  return toString(trim(isCharSequence(it) ? it : THROW_CCE()));
+}
+function BIP44$Companion$ed25519$lambda_0(it) {
+  return !equals('M', it, true);
+}
+function BIP44$Companion$ed25519$lambda_1(it) {
+  return toInt(replace(it, "'", ''));
+}
+var CompanionClass_0;
+function Companion_0() {
+  if (CompanionClass_0 === VOID) {
+    class $ {
+      c32(seed, path) {
+        var hmacHelper = new (HmacSha512())(encodeToByteArray('ed25519 seed'));
+        hmacHelper.e32(seed.value);
+        var tmp = asSequence(split(path, ['/']));
+        var tmp_0 = map(tmp, BIP44$Companion$ed25519$lambda);
+        var tmp_1 = filter(tmp_0, BIP44$Companion$ed25519$lambda_0);
+        var values = toList(map(tmp_1, BIP44$Companion$ed25519$lambda_1));
+        // Inline function 'kotlin.also' call
+        var this_0 = new Int8Array(64);
+        hmacHelper.f32(this_0, 0);
+        var bip44 = BIP44().i32(this_0);
+        var _iterator__ex2g4s = values.d1();
+        while (_iterator__ex2g4s.e1()) {
+          var v = _iterator__ex2g4s.f1();
+          bip44 = bip44.j32(v);
+        }
+        return bip44.g32_1;
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass_0 = $;
+  }
+  return CompanionClass_0;
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  return Companion_instance_0;
+}
+var BIP44Class;
+function BIP44() {
+  if (BIP44Class === VOID) {
+    class $ {
+      static k32(key, hmacHelper) {
+        var $this = createThis(this);
+        $this.g32_1 = key;
+        $this.h32_1 = hmacHelper;
+        return $this;
+      }
+      static i32(derived) {
+        return this.k32(copyOfRange(derived, 0, 32), new (HmacSha512())(copyOfRange(derived, 32, 64)));
+      }
+      j32(value) {
+        // Inline function 'kotlin.byteArrayOf' call
+        var tmp$ret$0 = new Int8Array([0]);
+        this.h32_1.e32(tmp$ret$0);
+        this.h32_1.l32(this.g32_1, 0, 32);
+        var buffer = new (Buffer())();
+        buffer.b2t(value);
+        var indexBytes = readByteArray(buffer);
+        indexBytes[0] = toByte(indexBytes[0] | -128);
+        this.h32_1.l32(indexBytes, 0, indexBytes.length);
+        var derived = new Int8Array(64);
+        this.h32_1.f32(derived, 0);
+        return BIP44().i32(derived);
+      }
+    }
+    initMetadataForClass($, 'BIP44');
+    BIP44Class = $;
+  }
+  return BIP44Class;
+}
+//region block: init
+Companion_instance = new (Companion())();
+Companion_instance_0 = new (Companion_0())();
+//endregion
+//region block: exports
+export {
+  Companion as Companion1cqh6ycnha9e9,
+  AttoPrivateKey as AttoPrivateKey1a153ds4lgph7,
+  Companion_getInstance as Companion_getInstance18roh4hqviqwb,
+};
+//endregion
+
+//# sourceMappingURL=AttoPrivateKey.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoPrivateKey.kt","src/kotlin/text/Strings.kt","src/kotlin/util/Standard.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["parse","value","generate","<init>","<get-value>","seed","index","toString","ed25519BIP44","path","BIP44$Companion$ed25519$lambda","ed25519","hmacHelper","values","bip44","v","key","derived","derive","buffer","indexBytes"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsB+B,uB;;WAEvBA,CAAUC,KAAVD,EAAyC;A,QACrC,4BAA4B,mBAAN,KAAM,CAA5B,C;MACJ,C;cAEAE,CAAAA,EAA+B;A,YAC3BD,QAAyB,0BAAgB,8BAAhB,C;QACzB,4BAAsB,KAAtB,C;MACJ,C;;;;;;;;;;;;;;;iBApBYE,CAChBF,KADgBE,EAAA;A;MAAA,C;iBAChBF,K;;QAAA,mB;QAGU,YAAN,KAAM,CAAN,KAAM,EAAY,EAAZ,C;;;QAHVG,CAAAA,EAAA;A,QAAA,iB;MAAmB,C;sBAOPC,I,EAAgBC,K;wBAAoB,aAAa,IAAb,EAAoB,QAApB,sBAA2B,KAA3B,GAAmC,IAAnC,gBAAsC,KAAtC,IAA2C,GAA3C,C;;cAehDC,CAAAA,EAAgC;A,QAC5B,YAAU,IAAV,CAAU,KAAV,CAAgB,MAAhB,GAAqB,Q;MACzB,C;;;;;;;qBAmGJC,CACIH,I,EACAI,IAFJD,EAGe;A,EAAyB,OAAnB,yBAAQ,IAAR,EAAc,IAAd,C;AAAkB,C;uCAlBdE,CAAA,EAAAA,EAAA;A;EAAW,OC4DoC,SAAP,oBD5DtC,EC4DsC,ID5DtC,EC4DsC,eAAO,C;AD5DnC,C;yCACTA,CAAA,EAAAA,EAAA;A,EAAoC,OAAlC,CAAK,OAAJ,GAAI,EAAO,EAAP,EAAwB,IAAxB,C;AAA8B,C;yCACxCA,CAAA,EAAAA,EAAA;A,EAA6B,OAAP,MAAjB,QAAH,EAAG,EAAQ,GAAR,EAAa,EAAb,CAAiB,C;AAAQ,C;;;;;SAb/CC,CACIN,I,EACAI,IAFJE,EAGa;A,YACTC,gCAA2C,kBAAf,cAAe,CAA3CA,C;QACA,UAAW,KAAO,IAAP,CAAY,KAAZ,C;kBAKF,WADA,MADL,IACK,EAAM,KAAN,CACA,C;oBACA,SAAI,8BAAJ,C;oBACA,cAAO,gCAAP,C;YALTC,SAOS,OADA,WAAI,gCAAJ,CACA,C;;qBAES,cAAU,EAAV,C;QAAqB,UAAW,KE5BpD,MF4BoD,EAAY,CAAZ,C;YAAlDC,oBE3BD,MF2BCA,C;YACU,+B;eAAA,sB,EAAQ;A,cAAbC,IAAK,sB;UACN,QAAQ,KAAM,KAAO,CAAP,C;QAClB,C;QAEA,OAAO,KAAP,CAAa,K;MACjB,C;;;;;;;;;;;;;;;iBAhDJC,G,EACAJ,U;;QADA,iB;QACA,wB;;;iBAEoBK,O;wBACR,YAAR,OAAQ,EAAY,CAAZ,EAAe,EAAf,C,qBACW,YAAR,OAAQ,EAAY,EAAZ,EAAgB,EAAhB,C;;SAGvBC,CAAWjB,KAAXiB,EAA8B;A;wBACI,kB;QAA9B,IAAW,CAAX,KAAW,KAAO,SAAP,C;QACX,IAAW,CAAX,KAAW,KAAO,IAAP,CAAO,KAAP,EAAY,CAAZ,EAAe,EAAf,C;YAEXC,yB;QACA,MAAO,KAAS,KAAT,C;YACPC,aAAwB,cAAP,MAAO,C;QACxB,WAAW,CAAX,IAAgE,OAA/C,WAAW,CAAX,IAAsC,IAAS,C;QAEhE,IAAW,CAAX,KAAW,KAAO,UAAP,EAAmB,CAAnB,EAAsB,UAAtB,CAAiC,MAAjC,C;YAEXH,UAAc,cAAU,EAAV,C;QACd,IAAW,CAAX,KAAW,KAAQ,OAAR,EAAiB,CAAjB,C;QAEX,mBAAa,OAAb,C;MACJ,C;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,26 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare class AttoPublicKey {
+    constructor(value: Int8Array);
+    get value(): Int8Array;
+    equals(other: Nullable<any>): boolean;
+    hashCode(): number;
+    toString(): string;
+    copy(value?: Int8Array): AttoPublicKey;
+}
+/** @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 AttoPublicKey.$metadata$ {
+    const constructor: abstract new () => AttoPublicKey;
+}
+export declare namespace AttoPublicKey {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        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 constructor {
+            parse(value: string): AttoPublicKey;
+            private constructor();
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import {
+  AttoPublicKey2ecx82jmcdweu as AttoPublicKey,
+  Companion3kdwb8wz8q7e6 as Companion,
+  Companion_getInstance3sfyy70tej2vc as Companion_getInstance,
+} from './AttoPublicKey.mjs';
+import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoPublicKey_0 = AttoPublicKey();
+defineProp(AttoPublicKey_0, 'Companion', Companion_getInstance);
+export {
+  AttoPublicKey_0 as AttoPublicKey,
+};
+//endregion
+
+//# sourceMappingURL=AttoPublicKey.export.mjs.map

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

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

package/commons-commons-core/cash/atto/commons/AttoPublicKey.js.mjs

@@ -0,0 +1,21 @@
+import { generateKeyPairFromSeed as generateKeyPairFromSeed } from '@stablelib/ed25519';
+import {
+  toUint8Array1omfedyjm9v5o as toUint8Array,
+  toByteArray3f5i5urnfv0wu as toByteArray,
+} from './Extensions.mjs';
+import { AttoPublicKey2ecx82jmcdweu as AttoPublicKey } from './AttoPublicKey.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function toPublicKey(_this__u8e3s4) {
+  var pair = generateKeyPairFromSeed(toUint8Array(_this__u8e3s4.value));
+  return new (AttoPublicKey())(toByteArray(pair.publicKey));
+}
+//region block: exports
+export {
+  toPublicKey as toPublicKey1cur233ok82jt,
+};
+//endregion
+
+//# sourceMappingURL=AttoPublicKey.js.mjs.map

package/commons-commons-core/cash/atto/commons/AttoPublicKey.js.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/jsMain/kotlin/cash/atto/commons/AttoPublicKey.js.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["toPublicKey","<this>","pair"],"mappings":";;;;;;;;;;oBAIAA,CAAWC,aAAXD,EAAuD;A,MACnDE,OAAW,wBAAmC,aAAX,aAAW,CAAN,KAAM,CAAnC,C;EAEX,6BAAoC,YAAf,IAAe,CAAV,SAAU,CAApC,C;AACJ,C;;;;;"}

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

@@ -0,0 +1,129 @@
+import {
+  fromHexToByteArrayplx5jrfi7guj as fromHexToByteArray,
+  checkLength3j1sz9qw7d9m6 as checkLength,
+  toHexcxaq2tti5e5x as toHex,
+} 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 {
+  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 { 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';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      parse(value) {
+        return new (AttoPublicKey())(fromHexToByteArray(value));
+      }
+      q2u() {
+        return AttoPublicKeySerializer_getInstance();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+var AttoPublicKeyClass;
+function AttoPublicKey() {
+  if (AttoPublicKeyClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.value = value;
+        checkLength(this.value, 32);
+      }
+      s1() {
+        return this.value;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AttoPublicKey()))
+          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 (AttoPublicKey())(value);
+      }
+      copy(value, $super) {
+        value = value === VOID ? this.value : value;
+        return $super === VOID ? this.h31(value) : $super.h31.call(this, value);
+      }
+    }
+    initMetadataForClass($, 'AttoPublicKey', VOID, VOID, VOID, VOID, VOID, {0: AttoPublicKeySerializer_getInstance});
+    AttoPublicKeyClass = $;
+  }
+  return AttoPublicKeyClass;
+}
+var AttoPublicKeySerializerClass;
+function AttoPublicKeySerializer() {
+  if (AttoPublicKeySerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoPublicKeySerializer_instance = this;
+        this.m32_1 = PrimitiveSerialDescriptor('AttoPublicKey', STRING_getInstance());
+      }
+      xs() {
+        return this.m32_1;
+      }
+      n32(encoder, value) {
+        encoder.oy(value.toString());
+      }
+      ys(encoder, value) {
+        return this.n32(encoder, value instanceof AttoPublicKey() ? value : THROW_CCE());
+      }
+      zs(decoder) {
+        return Companion_instance.parse(decoder.fx());
+      }
+    }
+    initMetadataForObject($, 'AttoPublicKeySerializer', VOID, VOID, [KSerializer()]);
+    AttoPublicKeySerializerClass = $;
+  }
+  return AttoPublicKeySerializerClass;
+}
+var AttoPublicKeySerializer_instance;
+function AttoPublicKeySerializer_getInstance() {
+  if (AttoPublicKeySerializer_instance === VOID)
+    new (AttoPublicKeySerializer())();
+  return AttoPublicKeySerializer_instance;
+}
+//region block: init
+Companion_instance = new (Companion())();
+//endregion
+//region block: exports
+export {
+  Companion as Companion3kdwb8wz8q7e6,
+  AttoPublicKey as AttoPublicKey2ecx82jmcdweu,
+  Companion_getInstance as Companion_getInstance3sfyy70tej2vc,
+  AttoPublicKeySerializer_getInstance as AttoPublicKeySerializer_getInstance148kpa77zxk91,
+};
+//endregion
+
+//# sourceMappingURL=AttoPublicKey.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoPublicKey.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["parse","value","serializer","<get-value>","equals","other","hashCode","toString","<get-descriptor>","serialize","encoder","deserialize","decoder"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;WAsBQA,CAAUC,KAAVD,EAAwC;A,QACpC,6BAA2B,mBAAN,KAAM,CAA3B,C;MACJ,C;SAHJE,CAAAA,EAAA;A,QAAA,4C;MAIA,C;;;;;;;;;;;;;;;kBAVAD,K;QAAA,kB;QAGU,YAAN,IAAM,CAAN,KAAM,EAAY,EAAZ,C;;QAHVE,CAAAA,EAAA;A,QAAA,iB;MAAmB,C;YAYnBC,CAAoBC,KAApBD,EAA0C;A,QAClC,aAAS,KAAT,C;UAAgB,OAAO,I;QACvB,wC;UAAyB,OAAO,K;QAEpC,OAAa,cAAN,IAAM,CAAN,KAAM,EAAc,KAAd,CAAoB,KAApB,C;MACjB,C;cAEAE,CAAAA,EAA+B;A,QAAuB,OAAjB,gBAAN,IAAM,CAAN,KAAM,C;MAAgB,C;cAErDC,CAAAA,EAAkC;A,QAAa,OAAP,MAAN,IAAM,CAAN,KAAM,C;MAAM,C;WApClD;A,QAAA,iB;MAAA,C;iBAAA;A,QAAA,mC;MAAA,C;;iCAAA,I,CAAA,K;;;;;;;;;;;;;;;QA0C8B,uCAA0B,eAA1B,uB;;QAA1BC,CAAAA,EAAA;A,QAAA,iB;MAAsB,C;SAEtBC,CACIC,O,EACAT,KAFJQ,EAGE;A,QACE,OAAQ,IAAa,KAAM,WAAnB,C;MACZ,C;SAI4rKC,O,EAAkBT,K;;;QAF9sKU,CAAyBC,OAAzBD,EAA4D;A,QAA2C,OAA7B,yBAAM,OAAQ,KAAd,C;MAA4B,C;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,34 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare class AttoReceivable {
+    constructor(hash: AttoHash, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, timestamp: any/* Instant */, receiverAlgorithm: AttoAlgorithm, receiverPublicKey: AttoPublicKey, amount: AttoAmount);
+    get hash(): AttoHash;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get timestamp(): any/* Instant */;
+    get receiverAlgorithm(): AttoAlgorithm;
+    get receiverPublicKey(): AttoPublicKey;
+    get amount(): AttoAmount;
+    get address(): AttoAddress;
+    get receiverAddress(): AttoAddress;
+    copy(hash?: AttoHash, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, timestamp?: any/* Instant */, receiverAlgorithm?: AttoAlgorithm, receiverPublicKey?: AttoPublicKey, amount?: AttoAmount): AttoReceivable;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): boolean;
+}
+/** @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 AttoReceivable.$metadata$ {
+    const constructor: abstract new () => AttoReceivable;
+}
+export declare namespace AttoReceivable {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        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 constructor {
+            private constructor();
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import {
+  AttoReceivable1xbn2f5t545d2 as AttoReceivable,
+  Companion1xrfjcv3rl5ey as Companion,
+  Companion_getInstance2plbqgbkdixit as Companion_getInstance,
+} from './AttoReceivable.mjs';
+import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoReceivable_0 = AttoReceivable();
+defineProp(AttoReceivable_0, 'Companion', Companion_getInstance);
+export {
+  AttoReceivable_0 as AttoReceivable,
+};
+//endregion
+
+//# sourceMappingURL=AttoReceivable.export.mjs.map

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

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