@attocash/commons-test 6.2.0 → 6.3.0

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

@@ -0,0 +1,28 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare interface AttoSigner {
+    readonly algorithm: AttoAlgorithm;
+    readonly publicKey: AttoPublicKey;
+    readonly address: AttoAddress;
+    signHash(hash: AttoHash): Promise<AttoSignature>;
+    signBlock(block: AttoBlock): Promise<AttoSignature>;
+    signVote(vote: AttoVote): Promise<AttoSignature>;
+    signChallenge(challenge: AttoChallenge, timestamp: AttoInstant): Promise<AttoSignature>;
+    checkPublicKey(publicKey: AttoPublicKey): Promise<void>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AttoSigner": unique symbol;
+    };
+}
+export declare namespace AttoSigner {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    namespace Companion {
+        /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+        namespace $metadata$ {
+            abstract class constructor {
+                private constructor();
+            }
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+import {
+  Companion1l27yp7mvqvwr as Companion,
+  Companion_getInstance1yz9pclaxooeb as Companion_getInstance,
+} from './AttoSigner.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 AttoSigner = {};
+defineProp(AttoSigner, 'Companion', Companion_getInstance, VOID, true);
+export {
+  AttoSigner as AttoSigner,
+};
+//endregion
+
+//# sourceMappingURL=AttoSigner.export.mjs.map

package/commons-commons-core/cash/atto/commons/AttoSigner.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

@@ -2,6 +2,13 @@ import {
   generateKeyPairFromSeed as generateKeyPairFromSeed,
   sign as sign,
 } from '@stablelib/ed25519';
+import {
+  await1tchdi81j7msa as await_0,
+  promisify1z0ncraq1ipzh as promisify,
+  suspendOrReturn49pspzlx5djv as suspendOrReturn,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { protoOf180f3jzyo7rfj as protoOf } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
 import { AttoAlgorithm_V1_getInstance3vq7zolusxoxz as AttoAlgorithm_V1_getInstance } from './AttoAlgorithm.mjs';
 import { toPublicKey1cur233ok82jt as toPublicKey } from './AttoPublicKey.js.mjs';
 import { toAddress3631euu7evnij as toAddress } from './AttoAddress.mjs';
@@ -9,33 +16,89 @@ import {
   toUint8Array1omfedyjm9v5o as toUint8Array,
   toByteArray3f5i5urnfv0wu as toByteArray,
 } from './Extensions.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
 import { AttoSignaturef1rb35b89r5k as AttoSignature } from './AttoSignature.mjs';
+import {
+  sign2v0z7umkpvgvl as sign_0,
+  sign1uej56tki34gj as sign_1,
+  sign389wfge3kn7yi as sign_2,
+  checkPublicKey3mr0m5k4v724a as checkPublicKey,
+  AttoSigner1s0b1owma3lqw as AttoSigner,
+} from './AttoSigner.mjs';
 import { initMetadataForClassbxx6q50dy2s7 as initMetadataForClass } 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
+function *_generator_sign$suspendBridge__35yghi($this, hash, $completion) {
+  var tmp;
+  if ($this.signHash === protoOf(InMemorySigner()).signHash) {
+    var tmp_0 = $this.b4t(hash, $completion);
+    if (tmp_0 === get_COROUTINE_SUSPENDED())
+      tmp_0 = yield tmp_0;
+    tmp = tmp_0;
+  } else {
+    var tmp_1 = await_0($this.signHash(hash), $completion);
+    if (tmp_1 === get_COROUTINE_SUSPENDED())
+      tmp_1 = yield tmp_1;
+    tmp = tmp_1;
+  }
+  return tmp;
+}
 var InMemorySignerClass;
 function InMemorySigner() {
   if (InMemorySignerClass === VOID) {
     class $ {
       constructor(privateKey) {
-        this.h4u_1 = privateKey;
-        this.i4u_1 = AttoAlgorithm_V1_getInstance();
-        this.j4u_1 = toPublicKey(this.h4u_1);
-        this.k4u_1 = toAddress(this.j4u_1, AttoAlgorithm_V1_getInstance());
-        this.l4u_1 = generateKeyPairFromSeed(toUint8Array(this.h4u_1.value));
+        this.n4u_1 = privateKey;
+        this.o4u_1 = AttoAlgorithm_V1_getInstance();
+        this.p4u_1 = toPublicKey(this.n4u_1);
+        this.q4u_1 = toAddress(this.p4u_1, AttoAlgorithm_V1_getInstance());
+        this.r4u_1 = generateKeyPairFromSeed(toUint8Array(this.n4u_1.value));
+      }
+      i4k() {
+        return this.o4u_1;
+      }
+      g4k() {
+        return this.p4u_1;
       }
-      y4k() {
-        return this.k4u_1;
+      p4k() {
+        return this.q4u_1;
       }
-      m4u(hash, $completion) {
-        var signature = sign(this.l4u_1.secretKey, toUint8Array(hash.value));
+      signHash(hash) {
+        return promisify(($completion) => this.s4u(hash, $completion));
+      }
+      s4u(hash, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_sign$suspendBridge__35yghi.bind(VOID, this, hash), $completion);
+      }
+      b4t(hash, $completion) {
+        var signature = sign(this.r4u_1.secretKey, toUint8Array(hash.value));
         return new (AttoSignature())(toByteArray(signature));
       }
+      d4t(block, $completion) {
+        return this.d4t(block, $completion);
+      }
+      e4t(vote, $completion) {
+        return this.e4t(vote, $completion);
+      }
+      f4t(challenge, timestamp, $completion) {
+        return this.f4t(challenge, timestamp, $completion);
+      }
+      get algorithm() {
+        return this.i4k();
+      }
+      get publicKey() {
+        return this.g4k();
+      }
+      get address() {
+        return this.p4k();
+      }
     }
-    initMetadataForClass($, 'InMemorySigner', VOID, VOID, VOID, [1, 2]);
+    protoOf($).d4t = sign_0;
+    protoOf($).e4t = sign_1;
+    protoOf($).f4t = sign_2;
+    protoOf($).a4t = checkPublicKey;
+    initMetadataForClass($, 'InMemorySigner', VOID, VOID, [AttoSigner()], [1, 2]);
     InMemorySignerClass = $;
   }
   return InMemorySignerClass;

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../commons-core/src/jsMain/kotlin/cash/atto/commons/AttoSigner.js.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["privateKey","<get-address>","sign","hash","$completion","signature"],"mappings":";;;;;;;;;;;;;;;;;;;;;;kBAOoBA,U;QAAhB,uB;QAE6D,2C;QACH,yBAAX,IAAW,CAAX,KAAW,C;QACL,uBAAV,IAAU,CAAV,KAAU,EAAwB,8BAAxB,C;QAE/B,qCAAyC,aAAjB,IAAiB,CAAjB,KAAiB,CAAN,KAAM,CAAzC,C;;SAFNC,CAAAA,EAAA;A,QAAA,iB;MAAuB,C;SAIfC,CAASC,I,EAATC,WAAAF,EAAwC;A,YAC5DG,YAC4B,KACR,IADQ,CACR,KADQ,CACA,SADA,EAEC,aAAX,IAAW,CAAN,KAAM,CAFD,C;QAK5B,6BAA+B,YAAV,SAAU,CAA/B,C;MACJ,C;;;;;;;;;;;"}
+{"version":3,"sources":["../../../../../commons-core/src/jsMain/kotlin/cash/atto/commons/AttoSigner.js.kt"],"sourcesContent":["package cash.atto.commons\n\nimport cash.atto.commons.utils.generateKeyPairFromSeed\n\ninternal object InMemorySignerHolder\n\nactual class InMemorySigner actual constructor(\n    internal actual val privateKey: AttoPrivateKey,\n) : AttoSigner {\n    actual override val algorithm: AttoAlgorithm = AttoAlgorithm.V1\n    actual override val publicKey: AttoPublicKey = privateKey.toPublicKey()\n    actual override val address: AttoAddress = publicKey.toAddress(AttoAlgorithm.V1)\n\n    private val keyPair = generateKeyPairFromSeed(privateKey.value.toUint8Array())\n\n    actual override suspend fun sign(hash: AttoHash): AttoSignature {\n        val signature =\n            cash.atto.commons.utils.sign(\n                secretKey = keyPair.secretKey,\n                message = hash.value.toUint8Array(),\n            )\n\n        return AttoSignature(signature.toByteArray())\n    }\n}\n"],"ignoreList":[],"x_google_ignoreList":[],"names":["privateKey","<get-algorithm>","<get-publicKey>","<get-address>","hash","sign","$completion","signature","block","vote","challenge","timestamp"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gDAe4B,K,EAAS,I;;;;;;;;;;;;;;;;;;;kBARjBA,U;QAAhB,uB;QAE6D,2C;QACH,yBAAX,IAAW,CAAX,KAAW,C;QACL,uBAAV,IAAU,CAAV,KAAU,EAAwB,8BAAxB,C;QAE/B,qCAAyC,aAAjB,IAAiB,CAAjB,KAAiB,CAAN,KAAM,CAAzC,C;;SAJNC,CAAAA,EAAA;A,QAAA,iB;MAA2B,C;SAC3BC,CAAAA,EAAA;A,QAAA,iB;MAA2B,C;SAC3BC,CAAAA,EAAA;A,QAAA,iB;MAAuB,C;eAINC,I;;;UAAA,I;;;SAATC,CAASD,I,EAATE,WAAAD,EAAwC;A,YAC5DE,YAC4B,KACR,IADQ,CACR,KADQ,CACA,SADA,EAEC,aAAX,IAAW,CAAN,KAAM,CAFD,C;QAK5B,6BAA+B,YAAV,SAAU,CAA/B,C;MACJ,C;UAbqEC,K,EAATF,W;;;UAGMG,I,EAATH,W;;;UAK1CI,S,EACbC,S,EADLL,W;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -1,14 +1,90 @@
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { suspendOrReturn49pspzlx5djv as suspendOrReturn } from '../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { Companion_instance2gqbffdfes1sc as Companion_instance } from './AttoHash.mjs';
+import { toByteArray18blahk7gwuv4 as toByteArray } from './Extensions.mjs';
+import { IllegalArgumentException2asla15b5jaob as IllegalArgumentException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
 import { InMemorySigner32umwc197yryh as InMemorySigner } from './AttoSigner.js.mjs';
 //region block: imports
 //endregion
 //region block: pre-declaration
 //endregion
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {}
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance_0;
+function Companion_getInstance() {
+  return Companion_instance_0;
+}
+function *_generator_sign__qhulg5($this, block, $completion) {
+  var tmp = $this.a4t(block.publicKey, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0 = $this.b4t(block.hash, $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return tmp_0;
+}
+function *_generator_sign__qhulg5_0($this, vote, $completion) {
+  var tmp = $this.a4t(vote.publicKey, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0 = $this.b4t(vote.hash, $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return tmp_0;
+}
+function sign(block, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_sign__qhulg5.bind(VOID, this, block), $completion);
+}
+function sign_0(vote, $completion) {
+  return suspendOrReturn(/*#__NOINLINE__*/_generator_sign__qhulg5_0.bind(VOID, this, vote), $completion);
+}
+function sign_1(challenge, timestamp, $completion) {
+  return this.b4t(Companion_instance.hash(64, [this.publicKey.value, challenge.value, toByteArray(timestamp)]), $completion);
+}
+function checkPublicKey(publicKey, $completion) {
+  if (!this.publicKey.equals(publicKey)) {
+    throw IllegalArgumentException().s2('Different public key ' + this.publicKey.toString());
+  }
+  return Unit_instance;
+}
+var AttoSignerClass;
+function AttoSigner() {
+  if (AttoSignerClass === VOID) {
+    class $ {}
+    initMetadataForInterface($, 'AttoSigner', VOID, VOID, VOID, [1, 2]);
+    AttoSignerClass = $;
+  }
+  return AttoSignerClass;
+}
 function toSigner(_this__u8e3s4) {
   return new (InMemorySigner())(_this__u8e3s4);
 }
+//region block: init
+Companion_instance_0 = new (Companion())();
+//endregion
 //region block: exports
 export {
+  Companion as Companion1l27yp7mvqvwr,
+  AttoSigner as AttoSigner1s0b1owma3lqw,
   toSigner as toSignerroyf4kwojbn,
+  checkPublicKey as checkPublicKey3mr0m5k4v724a,
+  sign as sign2v0z7umkpvgvl,
+  sign_0 as sign1uej56tki34gj,
+  sign_1 as sign389wfge3kn7yi,
+  Companion_getInstance as Companion_getInstance1yz9pclaxooeb,
 };
 //endregion
 

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoSigner.kt"],"sourcesContent":[null],"ignoreList":[],"x_google_ignoreList":[],"names":["toSigner","<this>"],"mappings":";;;;;iBA6CAA,CAAIC,aAAJD,EAA4C;A,EAAoB,8BAAL,aAAK,C;AAAD,C;;;;;"}
+{"version":3,"sources":["../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoSigner.kt"],"sourcesContent":["package cash.atto.commons\n\nimport cash.atto.commons.utils.JsExportForJs\nimport kotlin.js.JsName\n\n@JsExportForJs\ninterface AttoSigner {\n    companion object {}\n\n    val algorithm: AttoAlgorithm\n    val publicKey: AttoPublicKey\n    val address: AttoAddress\n\n    @JsName(\"signHash\")\n    suspend fun sign(hash: AttoHash): AttoSignature\n\n    @JsName(\"signBlock\")\n    suspend fun sign(block: AttoBlock): AttoSignature {\n        checkPublicKey(block.publicKey)\n        return sign(block.hash)\n    }\n\n    @JsName(\"signVote\")\n    suspend fun sign(vote: AttoVote): AttoSignature {\n        checkPublicKey(vote.publicKey)\n        return sign(vote.hash)\n    }\n\n    @JsName(\"signChallenge\")\n    suspend fun sign(\n        challenge: AttoChallenge,\n        timestamp: AttoInstant,\n    ): AttoSignature = sign(AttoHash.hash(64, publicKey.value, challenge.value, timestamp.toByteArray()))\n\n    suspend fun checkPublicKey(publicKey: AttoPublicKey) {\n        if (this.publicKey != publicKey) {\n            throw IllegalArgumentException(\"Different public key ${this.publicKey}\")\n        }\n    }\n}\n\nexpect class InMemorySigner(\n    privateKey: AttoPrivateKey,\n) : AttoSigner {\n    override val algorithm: AttoAlgorithm\n    override val publicKey: AttoPublicKey\n    override val address: AttoAddress\n\n    internal val privateKey: AttoPrivateKey\n\n    override suspend fun sign(hash: AttoHash): AttoSignature\n}\n\nfun AttoPrivateKey.toSigner(): AttoSigner = InMemorySigner(this)\n\nfun AttoSeed.toSigner(index: AttoKeyIndex): AttoSigner = toPrivateKey(index).toSigner()\n\nfun AttoSeed.toSigner(index: UInt): AttoSigner = toPrivateKey(index).toSigner()\n\nfun AttoSeed.toSigner(index: Int): AttoSigner = toPrivateKey(index).toSigner()\n\nsuspend fun AttoPrivateKey.sign(hash: AttoHash): AttoSignature = this.toSigner().sign(hash)\n"],"ignoreList":[],"x_google_ignoreList":[],"names":["<generator-sign>","block","$completion","vote","sign","challenge","timestamp","checkPublicKey","publicKey","toSigner","<this>"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAiBYA,CAAA,K,EAASC,K,EAATC,WAAAF,EAA0C;A,MAC9C,gBAAe,KAAf,CAAqB,SAArB,c;;;MACO,kBAAK,KAAL,CAAW,IAAX,c;;;EAAP,Y;AACJ,C;mCAGQA,CAAA,K,EAASG,I,EAATD,WAAAF,EAAwC;A,MAC5C,gBAAe,IAAf,CAAoB,SAApB,c;;;MACO,kBAAK,IAAL,CAAU,IAAV,c;;;EAAP,Y;AACJ,C;aATQI,CAASH,K,EAATC,WAAAE,E;;C;eAMAA,CAASD,I,EAATD,WAAAE,E;;C;eAMAA,CACJC,S,EACAC,S,EAFIJ,WAAAE,EAGW;A,EAAiF,OAAjF,SAAc,wBAAK,EAAL,EAAmB,CAAV,IAAU,CAAV,SAAU,QAAO,SAAP,CAAiB,KAAjB,EAAkC,YAAV,SAAU,CAAlC,CAAnB,CAAd,c;AAAiF,C;uBAE5FG,CAAmBC,S,EAAnBN,WAAAK,EAA6C;A,EAC7C,UAAK,SAAL,QAAkB,SAAlB,E,CAA6B;A,IAC7B,oCAAgC,uBAAhC,GAAuD,IAAvD,CAA4D,SAA5D,Y;EACJ,C;EACJ,oB;AAAA,C;;;;;;;;;;iBAeJE,CAAIC,aAAJD,EAA4C;A,EAAoB,8BAAL,aAAK,C;AAAD,C;;;;;;;;"}

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

@@ -1,6 +1,6 @@
 type Nullable<T> = T | null | undefined
 declare function KtSingleton<T>(): T & (abstract new() => any);
-export declare class AttoTransaction implements HeightSupport, AddressSupport/*, AttoSerializable */ {
+export declare class AttoTransaction implements HeightSupport, AddressSupport, AttoSerializable {
     constructor(block: AttoBlock, signature: AttoSignature, work: AttoWork);
     get block(): AttoBlock;
     get signature(): AttoSignature;
@@ -8,14 +8,15 @@ export declare class AttoTransaction implements HeightSupport, AddressSupport/*,
     get hash(): AttoHash;
     get height(): AttoHeight;
     get address(): AttoAddress;
-    validate(): any/* AttoValidation */;
+    validate(): AttoValidation;
     isValid(): boolean;
     getTotalSize(): number;
     toString(): string;
     copy(block?: AttoBlock, signature?: AttoSignature, work?: AttoWork): AttoTransaction;
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
-    readonly __doNotUseOrImplementIt: HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"];
+    toByteArray(): Int8Array;
+    readonly __doNotUseOrImplementIt: HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"] & AttoSerializable["__doNotUseOrImplementIt"];
 }
 export declare namespace AttoTransaction {
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
@@ -30,7 +31,6 @@ export declare namespace AttoTransaction {
         namespace $metadata$ {
             abstract class constructor {
                 get SIZE(): number;
-                fromBuffer(buffer: any/* Buffer */): Nullable<AttoTransaction>;
                 private constructor();
             }
         }

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

@@ -50,13 +50,17 @@ import { Unit_instance28fytmsmm6r23 as Unit_instance } from '../../../../kotlin-
 import { isValid38ww8lpvtnklo as isValid } from './AttoSignature.js.mjs';
 import { Buffergs925ekssbch as Buffer } from '../../../../kotlinx-io-kotlinx-io-core/kotlinx/io/Buffer.mjs';
 import { throwMissingFieldException2cmke0v3ynf14 as throwMissingFieldException } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/internal/PluginExceptions.mjs';
+import {
+  toByteArrayholgcuj5zgpi as toByteArray,
+  AttoSerializable291xn050uxg51 as AttoSerializable,
+} from './AttoSerializable.mjs';
 //region block: imports
 var imul = Math.imul;
 //endregion
 //region block: pre-declaration
 //endregion
 function AttoTransaction$Companion$$childSerializers$_anonymous__8sfh5y() {
-  return Companion_instance.i1h();
+  return Companion_instance.b1h();
 }
 var CompanionClass;
 function Companion() {
@@ -69,17 +73,17 @@ function Companion() {
         // Inline function 'kotlin.arrayOf' call
         // Inline function 'kotlin.js.unsafeCast' call
         // Inline function 'kotlin.js.asDynamic' call
-        tmp.y4s_1 = [lazy(tmp_0, AttoTransaction$Companion$$childSerializers$_anonymous__8sfh5y), null, null];
+        tmp.g4t_1 = [lazy(tmp_0, AttoTransaction$Companion$$childSerializers$_anonymous__8sfh5y), null, null];
         this.SIZE = 72;
       }
-      s4s() {
+      x4s() {
         return this.SIZE;
       }
-      fromBuffer(buffer) {
+      n4n(buffer) {
         if (72n > buffer.u2()) {
           return null;
         }
-        var tmp0_elvis_lhs = Companion_instance.fromBuffer(buffer);
+        var tmp0_elvis_lhs = Companion_instance.n4n(buffer);
         var tmp;
         if (tmp0_elvis_lhs == null) {
           return null;
@@ -93,7 +97,7 @@ function Companion() {
         }
         return transaction;
       }
-      i1h() {
+      b1h() {
         return $serializer_getInstance();
       }
     }
@@ -115,77 +119,77 @@ function $serializer() {
       constructor() {
         $serializer_instance = this;
         var tmp0_serialDesc = new (PluginGeneratedSerialDescriptor())('cash.atto.commons.AttoTransaction', this, 3);
-        tmp0_serialDesc.h15('block', false);
-        tmp0_serialDesc.h15('signature', false);
-        tmp0_serialDesc.h15('work', false);
-        this.z4s_1 = tmp0_serialDesc;
-      }
-      a4t(encoder, value) {
-        var tmp0_desc = this.z4s_1;
-        var tmp1_output = encoder.tx(tmp0_desc);
-        var tmp2_cached = Companion_getInstance().y4s_1;
-        tmp1_output.kz(tmp0_desc, 0, tmp2_cached[0].g3(), value.block);
-        tmp1_output.kz(tmp0_desc, 1, AttoSignatureAsStringSerializer_getInstance(), value.signature);
-        tmp1_output.kz(tmp0_desc, 2, AttoWorkAsStringSerializer_getInstance(), value.work);
-        tmp1_output.ux(tmp0_desc);
-      }
-      ft(encoder, value) {
-        return this.a4t(encoder, value instanceof AttoTransaction() ? value : THROW_CCE());
-      }
-      gt(decoder) {
-        var tmp0_desc = this.z4s_1;
+        tmp0_serialDesc.c15('block', false);
+        tmp0_serialDesc.c15('signature', false);
+        tmp0_serialDesc.c15('work', false);
+        this.h4t_1 = tmp0_serialDesc;
+      }
+      i4t(encoder, value) {
+        var tmp0_desc = this.h4t_1;
+        var tmp1_output = encoder.ox(tmp0_desc);
+        var tmp2_cached = Companion_getInstance().g4t_1;
+        tmp1_output.fz(tmp0_desc, 0, tmp2_cached[0].g3(), value.block);
+        tmp1_output.fz(tmp0_desc, 1, AttoSignatureAsStringSerializer_getInstance(), value.signature);
+        tmp1_output.fz(tmp0_desc, 2, AttoWorkAsStringSerializer_getInstance(), value.work);
+        tmp1_output.px(tmp0_desc);
+      }
+      at(encoder, value) {
+        return this.i4t(encoder, value instanceof AttoTransaction() ? value : THROW_CCE());
+      }
+      bt(decoder) {
+        var tmp0_desc = this.h4t_1;
         var tmp1_flag = true;
         var tmp2_index = 0;
         var tmp3_bitMask0 = 0;
         var tmp4_local0 = null;
         var tmp5_local1 = null;
         var tmp6_local2 = null;
-        var tmp8_input = decoder.tx(tmp0_desc);
-        var tmp9_cached = Companion_getInstance().y4s_1;
-        if (tmp8_input.iy()) {
-          tmp4_local0 = tmp8_input.fy(tmp0_desc, 0, tmp9_cached[0].g3(), tmp4_local0);
+        var tmp8_input = decoder.ox(tmp0_desc);
+        var tmp9_cached = Companion_getInstance().g4t_1;
+        if (tmp8_input.dy()) {
+          tmp4_local0 = tmp8_input.ay(tmp0_desc, 0, tmp9_cached[0].g3(), tmp4_local0);
           tmp3_bitMask0 = tmp3_bitMask0 | 1;
-          tmp5_local1 = tmp8_input.fy(tmp0_desc, 1, AttoSignatureAsStringSerializer_getInstance(), tmp5_local1);
+          tmp5_local1 = tmp8_input.ay(tmp0_desc, 1, AttoSignatureAsStringSerializer_getInstance(), tmp5_local1);
           tmp3_bitMask0 = tmp3_bitMask0 | 2;
-          tmp6_local2 = tmp8_input.fy(tmp0_desc, 2, AttoWorkAsStringSerializer_getInstance(), tmp6_local2);
+          tmp6_local2 = tmp8_input.ay(tmp0_desc, 2, AttoWorkAsStringSerializer_getInstance(), tmp6_local2);
           tmp3_bitMask0 = tmp3_bitMask0 | 4;
         } else
           while (tmp1_flag) {
-            tmp2_index = tmp8_input.jy(tmp0_desc);
+            tmp2_index = tmp8_input.ey(tmp0_desc);
             switch (tmp2_index) {
               case -1:
                 tmp1_flag = false;
                 break;
               case 0:
-                tmp4_local0 = tmp8_input.fy(tmp0_desc, 0, tmp9_cached[0].g3(), tmp4_local0);
+                tmp4_local0 = tmp8_input.ay(tmp0_desc, 0, tmp9_cached[0].g3(), tmp4_local0);
                 tmp3_bitMask0 = tmp3_bitMask0 | 1;
                 break;
               case 1:
-                tmp5_local1 = tmp8_input.fy(tmp0_desc, 1, AttoSignatureAsStringSerializer_getInstance(), tmp5_local1);
+                tmp5_local1 = tmp8_input.ay(tmp0_desc, 1, AttoSignatureAsStringSerializer_getInstance(), tmp5_local1);
                 tmp3_bitMask0 = tmp3_bitMask0 | 2;
                 break;
               case 2:
-                tmp6_local2 = tmp8_input.fy(tmp0_desc, 2, AttoWorkAsStringSerializer_getInstance(), tmp6_local2);
+                tmp6_local2 = tmp8_input.ay(tmp0_desc, 2, AttoWorkAsStringSerializer_getInstance(), tmp6_local2);
                 tmp3_bitMask0 = tmp3_bitMask0 | 4;
                 break;
               default:
-                throw UnknownFieldException().av(tmp2_index);
+                throw UnknownFieldException().vu(tmp2_index);
             }
           }
-        tmp8_input.ux(tmp0_desc);
-        return AttoTransaction().c4t(tmp3_bitMask0, tmp4_local0, tmp5_local1, tmp6_local2, null);
+        tmp8_input.px(tmp0_desc);
+        return AttoTransaction().k4t(tmp3_bitMask0, tmp4_local0, tmp5_local1, tmp6_local2, null);
       }
-      et() {
-        return this.z4s_1;
+      zs() {
+        return this.h4t_1;
       }
-      w15() {
+      r15() {
         // Inline function 'kotlin.arrayOf' call
         // Inline function 'kotlin.js.unsafeCast' call
         // Inline function 'kotlin.js.asDynamic' call
-        return [Companion_getInstance().y4s_1[0].g3(), AttoSignatureAsStringSerializer_getInstance(), AttoWorkAsStringSerializer_getInstance()];
+        return [Companion_getInstance().g4t_1[0].g3(), AttoSignatureAsStringSerializer_getInstance(), AttoWorkAsStringSerializer_getInstance()];
       }
     }
-    protoOf($).x15 = typeParametersSerializers;
+    protoOf($).s15 = typeParametersSerializers;
     initMetadataForObject($, '$serializer', VOID, VOID, [GeneratedSerializer()]);
     $serializerClass = $;
   }
@@ -216,28 +220,28 @@ function AttoTransaction() {
         this.signature = signature;
         this.work = work;
         var tmp = this;
-        tmp.b4t_1 = lazy_0(AttoTransaction$hash$delegate$lambda(this));
+        tmp.j4t_1 = lazy_0(AttoTransaction$hash$delegate$lambda(this));
       }
-      d4t() {
+      l4t() {
         return this.block;
       }
-      e4t() {
+      m4t() {
         return this.signature;
       }
-      f4t() {
+      n4t() {
         return this.work;
       }
-      w4l() {
-        var tmp0 = this.b4t_1;
+      n4l() {
+        var tmp0 = this.j4t_1;
         var tmp = KProperty1();
         // Inline function 'kotlin.getValue' call
         getPropertyCallableRef('hash', 1, tmp, AttoTransaction$_get_hash_$ref_ha8bds(), null);
         return tmp0.g3();
       }
-      s4k() {
+      j4k() {
         return this.block.height;
       }
-      y4k() {
+      p4k() {
         return this.block.address;
       }
       validate() {
@@ -258,16 +262,16 @@ function AttoTransaction() {
         return Ok_instance;
       }
       isValid() {
-        return this.validate().z4n();
+        return this.validate().isValid;
       }
       getTotalSize() {
-        return 72 + this.block.type.size | 0;
+        return 72 + this.block.type.l4n_1 | 0;
       }
-      m4m() {
-        var serializedBlock = this.block.m4m();
+      d4m() {
+        var serializedBlock = this.block.d4m();
         // Inline function 'kotlin.apply' call
         var this_0 = new (Buffer())();
-        this_0.d2j(serializedBlock, serializedBlock.u2());
+        this_0.u2i(serializedBlock, serializedBlock.u2());
         writeAttoSignature(this_0, this.signature);
         writeAttoWork(this_0, this.work);
         return this_0;
@@ -275,23 +279,23 @@ function AttoTransaction() {
       toString() {
         return 'AttoTransaction(hash=' + this.hash.toString() + ', block=' + toString(this.block) + ', signature=' + this.signature.toString() + ', work=' + this.work.toString() + ', hash=' + this.hash.toString() + ')';
       }
-      cf() {
+      bf() {
         return this.block;
       }
-      df() {
+      cf() {
         return this.signature;
       }
-      h4l() {
+      y4k() {
         return this.work;
       }
-      g4t(block, signature, work) {
+      o4t(block, signature, work) {
         return new (AttoTransaction())(block, signature, work);
       }
       copy(block, signature, work, $super) {
         block = block === VOID ? this.block : block;
         signature = signature === VOID ? this.signature : signature;
         work = work === VOID ? this.work : work;
-        return $super === VOID ? this.g4t(block, signature, work) : $super.g4t.call(this, block, signature, work);
+        return $super === VOID ? this.o4t(block, signature, work) : $super.o4t.call(this, block, signature, work);
       }
       hashCode() {
         var result = hashCode(this.block);
@@ -312,30 +316,31 @@ function AttoTransaction() {
           return false;
         return true;
       }
-      static c4t(seen0, block, signature, work, serializationConstructorMarker) {
+      static k4t(seen0, block, signature, work, serializationConstructorMarker) {
         Companion_getInstance();
         if (!(7 === (7 & seen0))) {
-          throwMissingFieldException(seen0, 7, $serializer_getInstance().z4s_1);
+          throwMissingFieldException(seen0, 7, $serializer_getInstance().h4t_1);
         }
         var $this = createThis(this);
         $this.block = block;
         $this.signature = signature;
         $this.work = work;
         var tmp = $this;
-        tmp.b4t_1 = lazy_0(AttoTransaction$_init_$lambda_46wg3f($this));
+        tmp.j4t_1 = lazy_0(AttoTransaction$_init_$lambda_46wg3f($this));
         return $this;
       }
       get hash() {
-        return this.w4l();
+        return this.n4l();
       }
       get height() {
-        return this.s4k();
+        return this.j4k();
       }
       get address() {
-        return this.y4k();
+        return this.p4k();
       }
     }
-    initMetadataForClass($, 'AttoTransaction', VOID, VOID, [HeightSupport(), AddressSupport()], VOID, VOID, {0: $serializer_getInstance});
+    protoOf($).toByteArray = toByteArray;
+    initMetadataForClass($, 'AttoTransaction', VOID, VOID, [HeightSupport(), AddressSupport(), AttoSerializable()], VOID, VOID, {0: $serializer_getInstance});
     AttoTransactionClass = $;
   }
   return AttoTransactionClass;

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoTransaction.kt","../../../../../commons-test/build/compileSync/js/main/productionLibrary/kotlin/commons-commons-core/cash/atto/commons/src/kotlin/util/Lazy.kt","../../../../../commons-test/build/compileSync/js/main/productionLibrary/kotlin/commons-commons-core/cash/atto/commons/src/kotlin/util/Standard.kt"],"sourcesContent":[null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["AttoTransaction$Companion$$childSerializers$<anonymous>","<get-SIZE>","fromBuffer","buffer","block","transaction","serializer","serialize","encoder","value","deserialize","childSerializers","AttoTransaction$hash$delegate$lambda","AttoTransaction$hash$delegate$lambda$lambda","AttoTransaction$<init>$lambda","AttoTransaction$<init>$lambda$lambda","signature","work","<get-block>","<get-signature>","<get-work>","<get-hash>","<get-height>","<get-address>","validate","blockValidation","isValid","getTotalSize","toBuffer","serializedBlock","toString","result"],"mappings":"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"}
+{"version":3,"sources":["../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoTransaction.kt","../../../../../commons-test/build/compileSync/js/main/productionLibrary/kotlin/commons-commons-core/cash/atto/commons/src/kotlin/util/Lazy.kt","../../../../../commons-test/build/compileSync/js/main/productionLibrary/kotlin/commons-commons-core/cash/atto/commons/src/kotlin/util/Standard.kt"],"sourcesContent":["@file:OptIn(ExperimentalJsExport::class)\n\npackage cash.atto.commons\n\nimport cash.atto.commons.utils.JsExportForJs\nimport kotlinx.io.Buffer\nimport kotlinx.io.readByteArray\nimport kotlinx.serialization.KSerializer\nimport kotlinx.serialization.Serializable\nimport kotlinx.serialization.builtins.ByteArraySerializer\nimport kotlinx.serialization.descriptors.PrimitiveKind\nimport kotlinx.serialization.descriptors.PrimitiveSerialDescriptor\nimport kotlinx.serialization.encoding.Decoder\nimport kotlinx.serialization.encoding.Encoder\nimport kotlin.js.ExperimentalJsExport\nimport kotlin.js.JsExport\n\n@JsExportForJs\n@Serializable\ndata class AttoTransaction(\n    val block: AttoBlock,\n    val signature: AttoSignature,\n    val work: AttoWork,\n) : HeightSupport,\n    AddressSupport,\n    AttoSerializable {\n    val hash by lazy { block.hash }\n\n    override val height: AttoHeight\n        get() = block.height\n\n    override val address: AttoAddress\n        get() = block.address\n\n    companion object {\n        const val SIZE = 72\n\n        @JsExport.Ignore\n        fun fromBuffer(buffer: Buffer): AttoTransaction? {\n            if (SIZE > buffer.size) {\n                return null\n            }\n\n            val block = AttoBlock.fromBuffer(buffer) ?: return null\n\n            val transaction =\n                AttoTransaction(\n                    block = block,\n                    signature = buffer.readAttoSignature(),\n                    work = buffer.readAttoWork(),\n                )\n\n            if (!transaction.isValid()) {\n                return null\n            }\n\n            return transaction\n        }\n    }\n\n    fun validate(): AttoValidation {\n        when (val blockValidation = block.validate()) {\n            is AttoValidation.Ok -> Unit\n            is AttoValidation.Error -> return blockValidation\n        }\n\n        if (!work.isValid(block)) {\n            return AttoValidation.Error(\n                \"Work is invalid\",\n            )\n        }\n\n        if (!signature.isValid(block.publicKey, block.hash)) {\n            return AttoValidation.Error(\n                \"Signature is invalid: publicKey=${block.publicKey}, hash=${block.hash}\",\n            )\n        }\n\n        return AttoValidation.Ok\n    }\n\n    /**\n     * Minimal block validation. This method doesn't check this transaction against the ledger so further validations are required.\n     */\n    fun isValid(): Boolean = validate().isValid\n\n    /**\n     * Return the transaction and block size\n     */\n    fun getTotalSize(): Int = SIZE + block.type.size\n\n    @JsExport.Ignore\n    override fun toBuffer(): Buffer {\n        val serializedBlock = block.toBuffer()\n        return Buffer().apply {\n            this.write(serializedBlock, serializedBlock.size)\n            this.writeAttoSignature(signature)\n            this.writeAttoWork(work)\n        }\n    }\n\n    override fun toString(): String = \"AttoTransaction(hash=$hash, block=$block, signature=$signature, work=$work, hash=$hash)\"\n}\n\nobject AttoTransactionAsByteArraySerializer : KSerializer<AttoTransaction> {\n    override val descriptor = PrimitiveSerialDescriptor(\"AttoTransactionAsByteArray\", PrimitiveKind.BYTE)\n\n    override fun serialize(\n        encoder: Encoder,\n        value: AttoTransaction,\n    ) {\n        encoder.encodeSerializableValue(ByteArraySerializer(), value.toBuffer().readByteArray())\n    }\n\n    override fun deserialize(decoder: Decoder): AttoTransaction =\n        AttoTransaction.fromBuffer(decoder.decodeSerializableValue(ByteArraySerializer()).toBuffer())!!\n}\n",null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["AttoTransaction$Companion$$childSerializers$<anonymous>","<get-SIZE>","fromBuffer","buffer","block","transaction","serializer","serialize","encoder","value","deserialize","childSerializers","AttoTransaction$hash$delegate$lambda","AttoTransaction$hash$delegate$lambda$lambda","AttoTransaction$<init>$lambda","AttoTransaction$<init>$lambda$lambda","signature","work","<get-block>","<get-signature>","<get-work>","<get-hash>","<get-height>","<get-address>","validate","blockValidation","isValid","getTotalSize","toBuffer","serializedBlock","toString","result"],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare interface AttoValidation {
+    readonly isValid: boolean;
+    getError(): Nullable<string>;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AttoValidation": unique symbol;
+    };
+}

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

@@ -0,0 +1,4 @@
+//region block: pre-declaration
+//endregion
+
+//# sourceMappingURL=AttoValidation.export.mjs.map