@attocash/commons-js 5.0.0

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

@@ -0,0 +1,135 @@
+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 $ {
+      constructor() {
+        this.SIZE = 64;
+      }
+      t32() {
+        return this.SIZE;
+      }
+      parse(value) {
+        return new (AttoSignature())(fromHexToByteArray(value));
+      }
+      q2u() {
+        return AttoSignatureSerializer_getInstance();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+var AttoSignatureClass;
+function AttoSignature() {
+  if (AttoSignatureClass === VOID) {
+    class $ {
+      constructor(value) {
+        this.value = value;
+        checkLength(this.value, 64);
+      }
+      s1() {
+        return this.value;
+      }
+      equals(other) {
+        if (this === other)
+          return true;
+        if (!(other instanceof AttoSignature()))
+          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 (AttoSignature())(value);
+      }
+      copy(value, $super) {
+        value = value === VOID ? this.value : value;
+        return $super === VOID ? this.h31(value) : $super.h31.call(this, value);
+      }
+    }
+    initMetadataForClass($, 'AttoSignature', VOID, VOID, VOID, VOID, VOID, {0: AttoSignatureSerializer_getInstance});
+    AttoSignatureClass = $;
+  }
+  return AttoSignatureClass;
+}
+var AttoSignatureSerializerClass;
+function AttoSignatureSerializer() {
+  if (AttoSignatureSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoSignatureSerializer_instance = this;
+        this.u32_1 = PrimitiveSerialDescriptor('AttoSignature', STRING_getInstance());
+      }
+      xs() {
+        return this.u32_1;
+      }
+      v32(encoder, value) {
+        encoder.oy(value.toString());
+      }
+      ys(encoder, value) {
+        return this.v32(encoder, value instanceof AttoSignature() ? value : THROW_CCE());
+      }
+      zs(decoder) {
+        return Companion_instance.parse(decoder.fx());
+      }
+    }
+    initMetadataForObject($, 'AttoSignatureSerializer', VOID, VOID, [KSerializer()]);
+    AttoSignatureSerializerClass = $;
+  }
+  return AttoSignatureSerializerClass;
+}
+var AttoSignatureSerializer_instance;
+function AttoSignatureSerializer_getInstance() {
+  if (AttoSignatureSerializer_instance === VOID)
+    new (AttoSignatureSerializer())();
+  return AttoSignatureSerializer_instance;
+}
+//region block: init
+Companion_instance = new (Companion())();
+//endregion
+//region block: exports
+export {
+  Companion as Companion293znhsoi7mqw,
+  AttoSignature as AttoSignaturef1rb35b89r5k,
+  Companion_getInstance as Companion_getInstance28m2lma37e0j2,
+  AttoSignatureSerializer_getInstance as AttoSignatureSerializer_getInstance3bpzi0enncrk0,
+};
+//endregion
+
+//# sourceMappingURL=AttoSignature.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoSignature.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["<get-SIZE>","parse","value","serializer","<get-value>","equals","other","hashCode","toString","<get-descriptor>","serialize","encoder","deserialize","decoder"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAkByB,c;;SAAjBA,CAAAA,EAAA;A,QAAA,gB;MAAa,C;WAEbC,CAAUC,KAAVD,EAAwC;A,QACpC,6BAA2B,mBAAN,KAAM,CAA3B,C;MACJ,C;SALJE,CAAAA,EAAA;A,QAAA,4C;MAMA,C;;;;;;;;;;;;;;;kBARAD,K;QAAA,kB;QAWU,YAAN,IAAM,CAAN,KAAM,EAAY,EAAZ,C;;QAXVE,CAAAA,EAAA;A,QAAA,iB;MAAmB,C;YAcnBC,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;WAtClD;A,QAAA,iB;MAAA,C;iBAAA;A,QAAA,mC;MAAA,C;;iCAAA,I,CAAA,K;;;;;;;;;;;;;;;QAuD8B,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;SAIk6JC,O,EAAkBT,K;;;QAFp7JU,CAAyBC,OAAzBD,EAA4D;A,QAA2C,OAA7B,yBAAM,OAAQ,KAAd,C;MAA4B,C;;;;;;;;;;;;;;;;;;;;"}

package/commons-commons-core/cash/atto/commons/AttoSigner.js.export.d.ts

@@ -0,0 +1,14 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare interface AttoSignerJs {
+    readonly publicKey: AttoPublicKey;
+    signHash(hash: AttoHash): Promise<AttoSignature>;
+    signBlock(block: AttoBlock): Promise<AttoSignature>;
+    signVote(vote: AttoVote): Promise<AttoSignature>;
+    signChallenge(challenge: AttoChallenge, timestamp: string): Promise<AttoSignature>;
+    checkPublicKey(publicKey: AttoPublicKey): Promise<void>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AttoSignerJs": unique symbol;
+    };
+}
+export declare function toSignerJs(_this_: AttoPrivateKey): AttoSignerJs;

package/commons-commons-core/cash/atto/commons/AttoSigner.js.export.mjs

@@ -0,0 +1,12 @@
+import { toSignerJsp358scga3843 as toSignerJs } from './AttoSigner.js.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+export {
+  toSignerJs as toSignerJs,
+};
+//endregion
+
+//# sourceMappingURL=AttoSigner.js.export.mjs.map

package/commons-commons-core/cash/atto/commons/AttoSigner.js.export.mjs.map

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

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

@@ -0,0 +1,478 @@
+import {
+  generateKeyPairFromSeed as generateKeyPairFromSeed,
+  sign as sign,
+} from '@stablelib/ed25519';
+import {
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import {
+  toSignerroyf4kwojbn as toSigner,
+  sign2skh7ycyjivdv as sign_0,
+  sign2zvjl71mlgauz as sign_1,
+  sign1j9jdjlbce3by as sign_2,
+  checkPublicKey2vb3w1hlxewo6 as checkPublicKey,
+  AttoSigner1s0b1owma3lqw as AttoSigner,
+} from './AttoSigner.mjs';
+import { CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/CoroutineImpl.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 {
+  CoroutineScopefcb5f5dwqcas as CoroutineScope,
+  GlobalScope_instance1sfulufhd2ijt as GlobalScope_instance,
+} from '../../../../kotlinx-coroutines-core/kotlinx/coroutines/CoroutineScope.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Companion_getInstance3vjikuur3h0k4 as Companion_getInstance } from '../../../../Kotlin-DateTime-library-kotlinx-datetime/kotlinx/datetime/Instant.mjs';
+import { promise1ky6tawqaxbt4 as promise } from '../../../../kotlinx-coroutines-core/kotlinx/coroutines/Promise.mjs';
+import { toPublicKey1cur233ok82jt as toPublicKey } from './AttoPublicKey.js.mjs';
+import {
+  toUint8Array1omfedyjm9v5o as toUint8Array,
+  toByteArray3f5i5urnfv0wu as toByteArray,
+} from './Extensions.mjs';
+import { AttoSignaturef1rb35b89r5k as AttoSignature } from './AttoSignature.mjs';
+import { protoOf180f3jzyo7rfj as protoOf } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var AttoSignerJsClass;
+function AttoSignerJs() {
+  if (AttoSignerJsClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'AttoSignerJs');
+    AttoSignerJsClass = $;
+  }
+  return AttoSignerJsClass;
+}
+function toSignerJs(_this__u8e3s4) {
+  var signer = toSigner(_this__u8e3s4);
+  return new (AttoSignerJsImpl())(signer);
+}
+var AttoSignerJsImpl$signHash$slambdaClass;
+function AttoSignerJsImpl$signHash$slambda() {
+  if (AttoSignerJsImpl$signHash$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(this$0, $hash, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.l35_1 = this$0;
+        $box.m35_1 = $hash;
+        super(resultContinuation, $box);
+      }
+      o35($this$promise, $completion) {
+        var tmp = this.p35($this$promise, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.o35((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                suspendResult = this.l35_1.q35_1.h33(this.m35_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return suspendResult;
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      p35($this$promise, completion) {
+        var i = new (AttoSignerJsImpl$signHash$slambda())(this.l35_1, this.m35_1, completion);
+        i.n35_1 = $this$promise;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoSignerJsImpl$signHash$slambdaClass = $;
+  }
+  return AttoSignerJsImpl$signHash$slambdaClass;
+}
+function AttoSignerJsImpl$signHash$slambda_0(this$0, $hash, resultContinuation) {
+  var i = new (AttoSignerJsImpl$signHash$slambda())(this$0, $hash, resultContinuation);
+  var l = function ($this$promise, $completion) {
+    return i.o35($this$promise, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var AttoSignerJsImpl$signBlock$slambdaClass;
+function AttoSignerJsImpl$signBlock$slambda() {
+  if (AttoSignerJsImpl$signBlock$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(this$0, $block, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.a36_1 = this$0;
+        $box.b36_1 = $block;
+        super(resultContinuation, $box);
+      }
+      o35($this$promise, $completion) {
+        var tmp = this.p35($this$promise, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.o35((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                suspendResult = this.a36_1.q35_1.t33(this.b36_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return suspendResult;
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      p35($this$promise, completion) {
+        var i = new (AttoSignerJsImpl$signBlock$slambda())(this.a36_1, this.b36_1, completion);
+        i.c36_1 = $this$promise;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoSignerJsImpl$signBlock$slambdaClass = $;
+  }
+  return AttoSignerJsImpl$signBlock$slambdaClass;
+}
+function AttoSignerJsImpl$signBlock$slambda_0(this$0, $block, resultContinuation) {
+  var i = new (AttoSignerJsImpl$signBlock$slambda())(this$0, $block, resultContinuation);
+  var l = function ($this$promise, $completion) {
+    return i.o35($this$promise, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var AttoSignerJsImpl$signVote$slambdaClass;
+function AttoSignerJsImpl$signVote$slambda() {
+  if (AttoSignerJsImpl$signVote$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(this$0, $vote, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.l36_1 = this$0;
+        $box.m36_1 = $vote;
+        super(resultContinuation, $box);
+      }
+      o35($this$promise, $completion) {
+        var tmp = this.p35($this$promise, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.o35((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                suspendResult = this.l36_1.q35_1.u33(this.m36_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return suspendResult;
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      p35($this$promise, completion) {
+        var i = new (AttoSignerJsImpl$signVote$slambda())(this.l36_1, this.m36_1, completion);
+        i.n36_1 = $this$promise;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoSignerJsImpl$signVote$slambdaClass = $;
+  }
+  return AttoSignerJsImpl$signVote$slambdaClass;
+}
+function AttoSignerJsImpl$signVote$slambda_0(this$0, $vote, resultContinuation) {
+  var i = new (AttoSignerJsImpl$signVote$slambda())(this$0, $vote, resultContinuation);
+  var l = function ($this$promise, $completion) {
+    return i.o35($this$promise, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var AttoSignerJsImpl$signChallenge$slambdaClass;
+function AttoSignerJsImpl$signChallenge$slambda() {
+  if (AttoSignerJsImpl$signChallenge$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(this$0, $challenge, $timestamp, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.w36_1 = this$0;
+        $box.x36_1 = $challenge;
+        $box.y36_1 = $timestamp;
+        super(resultContinuation, $box);
+      }
+      o35($this$promise, $completion) {
+        var tmp = this.p35($this$promise, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.o35((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                suspendResult = this.w36_1.q35_1.v33(this.x36_1, Companion_getInstance().h1v(this.y36_1), this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return suspendResult;
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      p35($this$promise, completion) {
+        var i = new (AttoSignerJsImpl$signChallenge$slambda())(this.w36_1, this.x36_1, this.y36_1, completion);
+        i.z36_1 = $this$promise;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoSignerJsImpl$signChallenge$slambdaClass = $;
+  }
+  return AttoSignerJsImpl$signChallenge$slambdaClass;
+}
+function AttoSignerJsImpl$signChallenge$slambda_0(this$0, $challenge, $timestamp, resultContinuation) {
+  var i = new (AttoSignerJsImpl$signChallenge$slambda())(this$0, $challenge, $timestamp, resultContinuation);
+  var l = function ($this$promise, $completion) {
+    return i.o35($this$promise, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var AttoSignerJsImpl$checkPublicKey$slambdaClass;
+function AttoSignerJsImpl$checkPublicKey$slambda() {
+  if (AttoSignerJsImpl$checkPublicKey$slambdaClass === VOID) {
+    class $ extends CoroutineImpl() {
+      constructor(this$0, $publicKey, resultContinuation, $box) {
+        if ($box === VOID)
+          $box = {};
+        $box.i37_1 = this$0;
+        $box.j37_1 = $publicKey;
+        super(resultContinuation, $box);
+      }
+      l37($this$promise, $completion) {
+        var tmp = this.p35($this$promise, $completion);
+        tmp.cc_1 = Unit_instance;
+        tmp.dc_1 = null;
+        return tmp.ic();
+      }
+      kd(p1, $completion) {
+        return this.l37((!(p1 == null) ? isInterface(p1, CoroutineScope()) : false) ? p1 : THROW_CCE(), $completion);
+      }
+      ic() {
+        var suspendResult = this.cc_1;
+        $sm: do
+          try {
+            var tmp = this.ac_1;
+            switch (tmp) {
+              case 0:
+                this.bc_1 = 2;
+                this.ac_1 = 1;
+                suspendResult = this.i37_1.q35_1.g33(this.j37_1, this);
+                if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                  return suspendResult;
+                }
+
+                continue $sm;
+              case 1:
+                return Unit_instance;
+              case 2:
+                throw this.dc_1;
+            }
+          } catch ($p) {
+            var e = $p;
+            if (this.bc_1 === 2) {
+              throw e;
+            } else {
+              this.ac_1 = this.bc_1;
+              this.dc_1 = e;
+            }
+          }
+         while (true);
+      }
+      p35($this$promise, completion) {
+        var i = new (AttoSignerJsImpl$checkPublicKey$slambda())(this.i37_1, this.j37_1, completion);
+        i.k37_1 = $this$promise;
+        return i;
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    AttoSignerJsImpl$checkPublicKey$slambdaClass = $;
+  }
+  return AttoSignerJsImpl$checkPublicKey$slambdaClass;
+}
+function AttoSignerJsImpl$checkPublicKey$slambda_0(this$0, $publicKey, resultContinuation) {
+  var i = new (AttoSignerJsImpl$checkPublicKey$slambda())(this$0, $publicKey, resultContinuation);
+  var l = function ($this$promise, $completion) {
+    return i.l37($this$promise, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+var AttoSignerJsImplClass;
+function AttoSignerJsImpl() {
+  if (AttoSignerJsImplClass === VOID) {
+    class $ {
+      constructor(signer) {
+        this.q35_1 = signer;
+        this.r35_1 = this.q35_1.q2v();
+      }
+      q2v() {
+        return this.r35_1;
+      }
+      signHash(hash) {
+        var tmp = GlobalScope_instance;
+        return promise(tmp, VOID, VOID, AttoSignerJsImpl$signHash$slambda_0(this, hash, null));
+      }
+      signBlock(block) {
+        var tmp = GlobalScope_instance;
+        return promise(tmp, VOID, VOID, AttoSignerJsImpl$signBlock$slambda_0(this, block, null));
+      }
+      signVote(vote) {
+        var tmp = GlobalScope_instance;
+        return promise(tmp, VOID, VOID, AttoSignerJsImpl$signVote$slambda_0(this, vote, null));
+      }
+      signChallenge(challenge, timestamp) {
+        var tmp = GlobalScope_instance;
+        return promise(tmp, VOID, VOID, AttoSignerJsImpl$signChallenge$slambda_0(this, challenge, timestamp, null));
+      }
+      checkPublicKey(publicKey) {
+        var tmp = GlobalScope_instance;
+        return promise(tmp, VOID, VOID, AttoSignerJsImpl$checkPublicKey$slambda_0(this, publicKey, null));
+      }
+      get publicKey() {
+        return this.q2v();
+      }
+    }
+    initMetadataForClass($, 'AttoSignerJsImpl', VOID, VOID, [AttoSignerJs()]);
+    AttoSignerJsImplClass = $;
+  }
+  return AttoSignerJsImplClass;
+}
+var InMemorySignerClass;
+function InMemorySigner() {
+  if (InMemorySignerClass === VOID) {
+    class $ {
+      constructor(privateKey) {
+        this.m37_1 = privateKey;
+        this.n37_1 = toPublicKey(this.m37_1);
+        this.o37_1 = generateKeyPairFromSeed(toUint8Array(this.m37_1.value));
+      }
+      q2v() {
+        return this.n37_1;
+      }
+      h33(hash, $completion) {
+        var signature = sign(this.o37_1.secretKey, toUint8Array(hash.value));
+        return new (AttoSignature())(toByteArray(signature));
+      }
+    }
+    protoOf($).t33 = sign_0;
+    protoOf($).u33 = sign_1;
+    protoOf($).v33 = sign_2;
+    protoOf($).g33 = checkPublicKey;
+    initMetadataForClass($, 'InMemorySigner', VOID, VOID, [AttoSigner()], [1, 2]);
+    InMemorySignerClass = $;
+  }
+  return InMemorySignerClass;
+}
+//region block: exports
+export {
+  InMemorySigner as InMemorySigner32umwc197yryh,
+  toSignerJs as toSignerJsp358scga3843,
+};
+//endregion
+
+//# sourceMappingURL=AttoSigner.js.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../commons-core/src/jsMain/kotlin/cash/atto/commons/AttoSigner.js.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["toSignerJs","<this>","signer","$hash","invoke","$completion","doResume","AttoSignerJsImpl$signHash$slambda","AttoSignerJsImpl$signHash$slambda$lambda","$block","AttoSignerJsImpl$signBlock$slambda","AttoSignerJsImpl$signBlock$slambda$lambda","$vote","AttoSignerJsImpl$signVote$slambda","AttoSignerJsImpl$signVote$slambda$lambda","$challenge","$timestamp","AttoSignerJsImpl$signChallenge$slambda","AttoSignerJsImpl$signChallenge$slambda$lambda","$publicKey","AttoSignerJsImpl$checkPublicKey$slambda","AttoSignerJsImpl$checkPublicKey$slambda$lambda","<get-publicKey>","signHash","hash","signBlock","block","signVote","vote","signChallenge","challenge","timestamp","checkPublicKey","publicKey","privateKey","sign","signature"],"mappings":"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"}