@attocash/commons-js 5.4.1 → 6.1.0

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

@@ -14,7 +14,6 @@ import {
   initMetadataForObject1cxne3s9w65el as initMetadataForObject,
 } from '../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
 import { VOID3gxj6tk5isa35 as VOID } from '../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
-import { Long2qws0ah9gnpki as Long } from '../../../../kotlin-kotlin-stdlib/kotlin/Primitives.mjs';
 import {
   _ULong___init__impl__c78o9k1p6qzv0dh0bvg as _ULong___init__impl__c78o9k,
   _ULong___get_data__impl__fggpzb2qlkrfp9zs48z as _ULong___get_data__impl__fggpzb,
@@ -23,6 +22,11 @@ import {
   ULong__hashCode_impl_6hv2lb37naj4fr4k4il as ULong__hashCode_impl_6hv2lb,
   Companion_getInstance1puqqwzccfvrg as Companion_getInstance,
 } from '../../../../kotlin-kotlin-stdlib/kotlin/ULong.mjs';
+import {
+  multiply2k9eolhnz1bjv as multiply,
+  add2suhfggl4zvkk as add,
+  subtract2orl8z9upxd9l as subtract,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/js/internal/longAsBigInt/longAsBigInt.mjs';
 import { _Char___init__impl__6a9atx2js6krycynjoo as _Char___init__impl__6a9atx } from '../../../../kotlin-kotlin-stdlib/kotlin/Char.mjs';
 import { charArrayOf27f4r3dozbrk1 as charArrayOf } from '../../../../kotlin-kotlin-stdlib/kotlin/js/arrays.mjs';
 import {
@@ -38,7 +42,6 @@ import {
   ulongRemainder2rz3omb7z07fg as ulongRemainder,
 } from '../../../../kotlin-kotlin-stdlib/kotlin/UnsignedJs.mjs';
 import { IllegalStateExceptionkoljg5n0nrlr as IllegalStateException } from '../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
-import { equals2au1ep9vhcato as equals } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
 import { Comparable198qfk8pnblz0 as Comparable } from '../../../../kotlin-kotlin-stdlib/kotlin/Comparable.mjs';
 import { serializer2lw83vwvpnyms as serializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/builtins/BuiltinSerializers.mjs';
 import { KSerializerzf77vz1967fq as KSerializer } from '../../../../kotlinx-serialization-kotlinx-serialization-core/kotlinx/serialization/KSerializer.mjs';
@@ -59,7 +62,7 @@ function valueOf(value) {
       return AttoUnit_RAW_getInstance();
     default:
       AttoUnit_initEntries();
-      THROW_IAE('No enum constant value.');
+      THROW_IAE('No enum constant cash.atto.commons.AttoUnit.' + value);
       break;
   }
 }
@@ -78,19 +81,19 @@ function AttoUnit() {
       constructor(name, ordinal, prefix, scale) {
         super(name, ordinal);
         this.prefix = prefix;
-        this.j2y_1 = scale;
+        this.s2w_1 = scale;
       }
-      k2y() {
+      t2w() {
         return this.prefix;
       }
-      l2y() {
-        return this.j2y_1;
+      u2w() {
+        return this.s2w_1;
       }
       get name() {
-        return this.i3();
+        return this.x3();
       }
       get ordinal() {
-        return this.j3();
+        return this.y3();
       }
     }
     initMetadataForClass($, 'AttoUnit');
@@ -99,7 +102,7 @@ function AttoUnit() {
   return AttoUnitClass;
 }
 function pow($this, _this__u8e3s4, exponent) {
-  var result = _ULong___init__impl__c78o9k(new (Long())(1, 0));
+  var result = _ULong___init__impl__c78o9k(1n);
   // Inline function 'kotlin.repeat' call
   var inductionVariable = 0;
   if (inductionVariable < exponent)
@@ -108,13 +111,13 @@ function pow($this, _this__u8e3s4, exponent) {
       inductionVariable = inductionVariable + 1 | 0;
       // Inline function 'kotlin.ULong.times' call
       var this_0 = result;
-      result = _ULong___init__impl__c78o9k(_ULong___get_data__impl__fggpzb(this_0).r3(_ULong___get_data__impl__fggpzb(_this__u8e3s4)));
+      result = _ULong___init__impl__c78o9k(multiply(_ULong___get_data__impl__fggpzb(this_0), _ULong___get_data__impl__fggpzb(_this__u8e3s4)));
     }
      while (inductionVariable < exponent);
   return result;
 }
 function scaleFactor($this, scale) {
-  var tmp = _ULong___init__impl__c78o9k(new (Long())(10, 0));
+  var tmp = _ULong___init__impl__c78o9k(10n);
   // Inline function 'kotlin.UByte.toInt' call
   var tmp$ret$0 = _UByte___get_data__impl__jof9qr(scale) & 255;
   return pow($this, tmp, tmp$ret$0);
@@ -125,41 +128,41 @@ function Companion() {
     class $ {
       constructor() {
         Companion_instance = this;
-        this.m2y_1 = _ULong___init__impl__c78o9k(new (Long())(-989331456, -104015711));
-        this.MAX = new (AttoAmount())(this.m2y_1);
-        this.n2y_1 = _ULong___init__impl__c78o9k(new (Long())(0, 0));
-        this.MIN = new (AttoAmount())(this.n2y_1);
+        this.v2w_1 = _ULong___init__impl__c78o9k(-446744073709551616n);
+        this.MAX = new (AttoAmount())(this.v2w_1);
+        this.w2w_1 = _ULong___init__impl__c78o9k(0n);
+        this.MIN = new (AttoAmount())(this.w2w_1);
       }
-      o2y() {
+      x2w() {
         return this.MAX;
       }
-      p2y() {
+      y2w() {
         return this.MIN;
       }
-      from(unit, string) {
+      z2w(unit, string) {
         var parts = split(string, charArrayOf([_Char___init__impl__6a9atx(46)]));
-        var wholePart = toULong(parts.j1(0));
-        var factor = scaleFactor(this, unit.j2y_1);
+        var wholePart = toULong(parts.o1(0));
+        var factor = scaleFactor(this, unit.s2w_1);
         // Inline function 'kotlin.ULong.times' call
-        var scaledValue = _ULong___init__impl__c78o9k(_ULong___get_data__impl__fggpzb(wholePart).r3(_ULong___get_data__impl__fggpzb(factor)));
-        if (parts.i1() > 1) {
-          var fractionalPart = toULong(parts.j1(1));
+        var scaledValue = _ULong___init__impl__c78o9k(multiply(_ULong___get_data__impl__fggpzb(wholePart), _ULong___get_data__impl__fggpzb(factor)));
+        if (parts.n1() > 1) {
+          var fractionalPart = toULong(parts.o1(1));
           var tmp0 = scaledValue;
           // Inline function 'kotlin.ULong.times' call
-          var tmp0_0 = _ULong___init__impl__c78o9k(_ULong___get_data__impl__fggpzb(fractionalPart).r3(_ULong___get_data__impl__fggpzb(factor)));
+          var tmp0_0 = _ULong___init__impl__c78o9k(multiply(_ULong___get_data__impl__fggpzb(fractionalPart), _ULong___get_data__impl__fggpzb(factor)));
           // Inline function 'kotlin.toUByte' call
-          var this_0 = parts.j1(1).length;
+          var this_0 = parts.o1(1).length;
           var tmp$ret$2 = _UByte___init__impl__g9hnc4(toByte(this_0));
           // Inline function 'kotlin.ULong.div' call
           var other = scaleFactor(this, tmp$ret$2);
           // Inline function 'kotlin.ULong.plus' call
           var other_0 = ulongDivide(tmp0_0, other);
-          scaledValue = _ULong___init__impl__c78o9k(_ULong___get_data__impl__fggpzb(tmp0).p3(_ULong___get_data__impl__fggpzb(other_0)));
+          scaledValue = _ULong___init__impl__c78o9k(add(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other_0)));
         }
         return new (AttoAmount())(scaledValue);
       }
-      e2v() {
-        return AttoAmountSerializer_getInstance();
+      k2t() {
+        return AttoAmountAsULongSerializer_getInstance();
       }
     }
     initMetadataForCompanion($);
@@ -173,6 +176,9 @@ function Companion_getInstance_0() {
     new (Companion())();
   return Companion_instance;
 }
+function from(unit, string) {
+  return Companion_getInstance_0().z2w(unit, string);
+}
 var AttoAmountClass;
 function AttoAmount() {
   if (AttoAmountClass === VOID) {
@@ -182,16 +188,16 @@ function AttoAmount() {
         this.raw = raw;
         var tmp0 = this.raw;
         // Inline function 'kotlin.ULong.compareTo' call
-        var other = Companion_getInstance_0().m2y_1;
+        var other = Companion_getInstance_0().v2w_1;
         if (ulongCompare(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other)) > 0) {
-          throw IllegalStateException().o4('' + new (ULong())(this.raw) + ' exceeds the max amount of ' + new (ULong())(Companion_getInstance_0().m2y_1));
+          throw IllegalStateException().x4('' + new (ULong())(this.raw) + ' exceeds the max amount of ' + new (ULong())(Companion_getInstance_0().v2w_1));
         }
       }
-      q2y() {
+      a2x() {
         return this.raw;
       }
       toFormattedString(unit) {
-        var factor = scaleFactor(Companion_getInstance_0(), unit.j2y_1);
+        var factor = scaleFactor(Companion_getInstance_0(), unit.s2w_1);
         // Inline function 'kotlin.ULong.div' call
         var this_0 = this.raw;
         var wholePart = ulongDivide(this_0, factor);
@@ -199,12 +205,12 @@ function AttoAmount() {
         var this_1 = this.raw;
         var fractionalPart = ulongRemainder(this_1, factor);
         var tmp;
-        if (equals(fractionalPart, _ULong___init__impl__c78o9k(new (Long())(0, 0)))) {
+        if (fractionalPart === _ULong___init__impl__c78o9k(0n)) {
           tmp = ULong__toString_impl_f9au7k(wholePart);
         } else {
           var tmp_0 = ULong__toString_impl_f9au7k(fractionalPart);
           // Inline function 'kotlin.UByte.toInt' call
-          var this_2 = unit.j2y_1;
+          var this_2 = unit.s2w_1;
           var tmp$ret$2 = _UByte___get_data__impl__jof9qr(this_2) & 255;
           var fractionalStr = trimEnd(padStart(tmp_0, tmp$ret$2, _Char___init__impl__6a9atx(48)), charArrayOf([_Char___init__impl__6a9atx(48)]));
           tmp = '' + new (ULong())(wholePart) + '.' + fractionalStr;
@@ -215,7 +221,7 @@ function AttoAmount() {
         var tmp0 = this.raw;
         // Inline function 'kotlin.ULong.plus' call
         var other = amount.raw;
-        var total = _ULong___init__impl__c78o9k(_ULong___get_data__impl__fggpzb(tmp0).p3(_ULong___get_data__impl__fggpzb(other)));
+        var total = _ULong___init__impl__c78o9k(add(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other)));
         var tmp;
         // Inline function 'kotlin.ULong.compareTo' call
         var other_0 = this.raw;
@@ -227,7 +233,7 @@ function AttoAmount() {
           tmp = ulongCompare(_ULong___get_data__impl__fggpzb(total), _ULong___get_data__impl__fggpzb(other_1)) < 0;
         }
         if (tmp) {
-          throw IllegalStateException().o4('ULong overflow');
+          throw IllegalStateException().x4('ULong overflow');
         }
         return new (AttoAmount())(total);
       }
@@ -235,35 +241,35 @@ function AttoAmount() {
         var tmp0 = this.raw;
         // Inline function 'kotlin.ULong.minus' call
         var other = amount.raw;
-        var total = _ULong___init__impl__c78o9k(_ULong___get_data__impl__fggpzb(tmp0).q3(_ULong___get_data__impl__fggpzb(other)));
+        var total = _ULong___init__impl__c78o9k(subtract(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other)));
         // Inline function 'kotlin.ULong.compareTo' call
         var other_0 = this.raw;
         if (ulongCompare(_ULong___get_data__impl__fggpzb(total), _ULong___get_data__impl__fggpzb(other_0)) > 0) {
-          throw IllegalStateException().o4('ULong underflow');
+          throw IllegalStateException().x4('ULong underflow');
         }
         return new (AttoAmount())(total);
       }
-      r2y(other) {
+      b2x(other) {
         var tmp0 = this.raw;
         // Inline function 'kotlin.ULong.compareTo' call
         var other_0 = other.raw;
         return ulongCompare(_ULong___get_data__impl__fggpzb(tmp0), _ULong___get_data__impl__fggpzb(other_0));
       }
       d(other) {
-        return this.r2y(other instanceof AttoAmount() ? other : THROW_CCE());
+        return this.b2x(other instanceof AttoAmount() ? other : THROW_CCE());
       }
       toString() {
         return '' + new (ULong())(this.raw);
       }
-      s2y() {
+      c2x() {
         return this.raw;
       }
-      t2y(raw) {
+      d2x(raw) {
         return new (AttoAmount())(raw);
       }
       copy(raw, $super) {
         raw = raw === VOID ? this.raw : raw;
-        return $super === VOID ? this.t2y(raw) : $super.t2y.call(this, new (ULong())(raw));
+        return $super === VOID ? this.d2x(raw) : $super.d2x.call(this, new (ULong())(raw));
       }
       hashCode() {
         return ULong__hashCode_impl_6hv2lb(this.raw);
@@ -273,48 +279,53 @@ function AttoAmount() {
           return true;
         if (!(other instanceof AttoAmount()))
           return false;
-        var tmp0_other_with_cast = other instanceof AttoAmount() ? other : THROW_CCE();
-        if (!equals(this.raw, tmp0_other_with_cast.raw))
+        if (!(this.raw === other.raw))
           return false;
         return true;
       }
     }
-    initMetadataForClass($, 'AttoAmount', VOID, VOID, [Comparable()], VOID, VOID, {0: AttoAmountSerializer_getInstance});
+    initMetadataForClass($, 'AttoAmount', VOID, VOID, [Comparable()], VOID, VOID, {0: AttoAmountAsULongSerializer_getInstance});
     AttoAmountClass = $;
   }
   return AttoAmountClass;
 }
-var AttoAmountSerializerClass;
-function AttoAmountSerializer() {
-  if (AttoAmountSerializerClass === VOID) {
+function toAttoAmount(_this__u8e3s4) {
+  return new (AttoAmount())(toULong(_this__u8e3s4));
+}
+function toAttoAmount_0(_this__u8e3s4) {
+  return new (AttoAmount())(_this__u8e3s4);
+}
+var AttoAmountAsULongSerializerClass;
+function AttoAmountAsULongSerializer() {
+  if (AttoAmountAsULongSerializerClass === VOID) {
     class $ {
       constructor() {
-        AttoAmountSerializer_instance = this;
-        this.u2y_1 = serializer(Companion_getInstance()).xs();
+        AttoAmountAsULongSerializer_instance = this;
+        this.e2x_1 = serializer(Companion_getInstance()).u1k();
       }
-      xs() {
-        return this.u2y_1;
+      u1k() {
+        return this.e2x_1;
       }
-      v2y(encoder, value) {
-        serializer(Companion_getInstance()).ys(encoder, new (ULong())(value.raw));
+      f2x(encoder, value) {
+        serializer(Companion_getInstance()).v1k(encoder, new (ULong())(value.raw));
       }
-      ys(encoder, value) {
-        return this.v2y(encoder, value instanceof AttoAmount() ? value : THROW_CCE());
+      v1k(encoder, value) {
+        return this.f2x(encoder, value instanceof AttoAmount() ? value : THROW_CCE());
       }
-      zs(decoder) {
-        return new (AttoAmount())(serializer(Companion_getInstance()).zs(decoder).fs_1);
+      w1k(decoder) {
+        return new (AttoAmount())(serializer(Companion_getInstance()).w1k(decoder).as_1);
       }
     }
-    initMetadataForObject($, 'AttoAmountSerializer', VOID, VOID, [KSerializer()]);
-    AttoAmountSerializerClass = $;
+    initMetadataForObject($, 'AttoAmountAsULongSerializer', VOID, VOID, [KSerializer()]);
+    AttoAmountAsULongSerializerClass = $;
   }
-  return AttoAmountSerializerClass;
+  return AttoAmountAsULongSerializerClass;
 }
-var AttoAmountSerializer_instance;
-function AttoAmountSerializer_getInstance() {
-  if (AttoAmountSerializer_instance === VOID)
-    new (AttoAmountSerializer())();
-  return AttoAmountSerializer_instance;
+var AttoAmountAsULongSerializer_instance;
+function AttoAmountAsULongSerializer_getInstance() {
+  if (AttoAmountAsULongSerializer_instance === VOID)
+    new (AttoAmountAsULongSerializer())();
+  return AttoAmountAsULongSerializer_instance;
 }
 function AttoUnit_ATTO_getInstance() {
   AttoUnit_initEntries();
@@ -331,10 +342,13 @@ export {
   valueOf as valueOf2yt2l9kimc6n,
   values as values3ntpkxfaw56c5,
   AttoUnit as AttoUnit3uf7k0bjq9xrg,
+  toAttoAmount_0 as toAttoAmountkv09taydvu7m,
+  toAttoAmount as toAttoAmount2kbgjtdbld3yn,
+  from as from1fjx23mt482ol,
   AttoUnit_ATTO_getInstance as AttoUnit_ATTO_getInstance1gwhthkel17m5,
   AttoUnit_RAW_getInstance as AttoUnit_RAW_getInstance1qbk9zmheijip,
   Companion_getInstance_0 as Companion_getInstancezafbg69jdanb,
-  AttoAmountSerializer_getInstance as AttoAmountSerializer_getInstance2dl5qvcd2xkk5,
+  AttoAmountAsULongSerializer_getInstance as AttoAmountAsULongSerializer_getInstanceh2609yxm2twf,
 };
 //endregion
 

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoAmount.kt","src/kotlin/util/Standard.kt","unsigned/src/kotlin/ULong.kt","unsigned/src/kotlin/UByte.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["values","valueOf","value","prefix","scale","<get-prefix>","<get-scale>","pow","<this>","exponent","result","index","scaleFactor","<get-MAX>","<get-MIN>","from","unit","string","parts","wholePart","factor","scaledValue","fractionalPart","serializer","raw","<get-raw>","toString","fractionalStr","plus","amount","total","minus","compareTo","other","<get-descriptor>","serialize","encoder","deserialize","decoder"],"mappings":"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"}
+{"version":3,"sources":["../../../../../../../commons-core/src/commonMain/kotlin/cash/atto/commons/AttoAmount.kt","src/kotlin/util/Standard.kt","unsigned/src/kotlin/ULong.kt","unsigned/src/kotlin/UByte.kt"],"sourcesContent":[null,null,null,null],"ignoreList":[],"x_google_ignoreList":[],"names":["values","valueOf","value","prefix","scale","<get-prefix>","<get-scale>","pow","<this>","exponent","result","index","scaleFactor","<get-MAX>","<get-MIN>","from","unit","string","parts","wholePart","factor","scaledValue","fractionalPart","serializer","raw","<get-raw>","toString","fractionalStr","plus","amount","total","minus","compareTo","other","toAttoAmount","<get-descriptor>","serialize","encoder","deserialize","decoder"],"mappings":"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"}

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

@@ -34,11 +34,15 @@ export declare namespace AttoBlockType.$metadata$ {
     const constructor: abstract new () => AttoBlockType;
 }
 export declare namespace AttoBlockType {
-    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
         private constructor();
     }
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
         abstract class constructor {
             from(code: any/* UByte */): AttoBlockType;
             private constructor();
@@ -51,7 +55,13 @@ export declare interface HeightSupport {
         readonly "cash.atto.commons.HeightSupport": unique symbol;
     };
 }
-export declare interface AttoBlock extends HeightSupport, AttoHashable/*, AttoSerializable */ {
+export declare interface AddressSupport {
+    readonly address: AttoAddress;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AddressSupport": unique symbol;
+    };
+}
+export declare interface AttoBlock extends HeightSupport, AddressSupport, AttoHashable/*, AttoSerializable */ {
     readonly hash: AttoHash;
     readonly type: AttoBlockType;
     readonly network: AttoNetwork;
@@ -60,17 +70,22 @@ export declare interface AttoBlock extends HeightSupport, AttoHashable/*, AttoSe
     readonly publicKey: AttoPublicKey;
     readonly height: AttoHeight;
     readonly balance: AttoAmount;
-    readonly timestamp: any/* Instant */;
+    readonly timestamp: AttoInstant;
+    validate(): any/* AttoValidation */;
     isValid(): boolean;
     readonly __doNotUseOrImplementIt: {
         readonly "cash.atto.commons.AttoBlock": unique symbol;
-    } & HeightSupport["__doNotUseOrImplementIt"] & AttoHashable["__doNotUseOrImplementIt"];
+    } & HeightSupport["__doNotUseOrImplementIt"] & AddressSupport["__doNotUseOrImplementIt"] & AttoHashable["__doNotUseOrImplementIt"];
 }
-export declare abstract class AttoBlock extends KtSingleton<AttoBlock.$metadata$.constructor>() {
+export declare abstract class AttoBlock {
+    static readonly getInstance: () => typeof AttoBlock.$metadata$.type;
     private constructor();
 }
 /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
 export declare namespace AttoBlock.$metadata$ {
+    abstract class type extends KtSingleton<constructor>() {
+        private constructor();
+    }
     abstract class constructor /* implements SerializerFactory */ {
         fromBuffer(serializedBlock: any/* Buffer */): Nullable<AttoBlock>;
         private constructor();
@@ -98,14 +113,14 @@ export declare interface RepresentativeSupport {
     };
 }
 export declare class AttoSendBlock implements AttoBlock, PreviousSupport {
-    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, height: AttoHeight, balance: AttoAmount, timestamp: any/* Instant */, previous: AttoHash, receiverAlgorithm: AttoAlgorithm, receiverPublicKey: AttoPublicKey, amount: AttoAmount);
+    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, height: AttoHeight, balance: AttoAmount, timestamp: AttoInstant, previous: AttoHash, receiverAlgorithm: AttoAlgorithm, receiverPublicKey: AttoPublicKey, amount: AttoAmount);
     get network(): AttoNetwork;
     get version(): AttoVersion;
     get algorithm(): AttoAlgorithm;
     get publicKey(): AttoPublicKey;
     get height(): AttoHeight;
     get balance(): AttoAmount;
-    get timestamp(): any/* Instant */;
+    get timestamp(): AttoInstant;
     get previous(): AttoHash;
     get receiverAlgorithm(): AttoAlgorithm;
     get receiverPublicKey(): AttoPublicKey;
@@ -114,11 +129,12 @@ export declare class AttoSendBlock implements AttoBlock, PreviousSupport {
     get hash(): AttoHash;
     get address(): AttoAddress;
     get receiverAddress(): AttoAddress;
-    isValid(): boolean;
-    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, height?: AttoHeight, balance?: AttoAmount, timestamp?: any/* Instant */, previous?: AttoHash, receiverAlgorithm?: AttoAlgorithm, receiverPublicKey?: AttoPublicKey, amount?: AttoAmount): AttoSendBlock;
+    validate(): any/* AttoValidation */;
+    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, height?: AttoHeight, balance?: AttoAmount, timestamp?: AttoInstant, previous?: AttoHash, receiverAlgorithm?: AttoAlgorithm, receiverPublicKey?: AttoPublicKey, amount?: AttoAmount): AttoSendBlock;
     toString(): string;
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
+    isValid(): boolean;
     readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"];
 }
 /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
@@ -126,36 +142,41 @@ export declare namespace AttoSendBlock.$metadata$ {
     const constructor: abstract new () => AttoSendBlock;
 }
 export declare namespace AttoSendBlock {
-    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
         private constructor();
     }
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
         abstract class constructor {
             private constructor();
         }
     }
 }
 export declare class AttoReceiveBlock implements AttoBlock, PreviousSupport, ReceiveSupport {
-    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, height: AttoHeight, balance: AttoAmount, timestamp: any/* Instant */, previous: AttoHash, sendHashAlgorithm: AttoAlgorithm, sendHash: AttoHash);
+    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, height: AttoHeight, balance: AttoAmount, timestamp: AttoInstant, previous: AttoHash, sendHashAlgorithm: AttoAlgorithm, sendHash: AttoHash);
     get network(): AttoNetwork;
     get version(): AttoVersion;
     get algorithm(): AttoAlgorithm;
     get publicKey(): AttoPublicKey;
     get height(): AttoHeight;
     get balance(): AttoAmount;
-    get timestamp(): any/* Instant */;
+    get timestamp(): AttoInstant;
     get previous(): AttoHash;
     get sendHashAlgorithm(): AttoAlgorithm;
     get sendHash(): AttoHash;
     get type(): AttoBlockType;
     get hash(): AttoHash;
     get address(): AttoAddress;
-    isValid(): boolean;
-    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, height?: AttoHeight, balance?: AttoAmount, timestamp?: any/* Instant */, previous?: AttoHash, sendHashAlgorithm?: AttoAlgorithm, sendHash?: AttoHash): AttoReceiveBlock;
+    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, height?: AttoHeight, balance?: AttoAmount, timestamp?: AttoInstant, previous?: AttoHash, sendHashAlgorithm?: AttoAlgorithm, sendHash?: AttoHash): AttoReceiveBlock;
     toString(): string;
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
+    validate(): any/* AttoValidation */;
+    isValid(): boolean;
     readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & ReceiveSupport["__doNotUseOrImplementIt"];
 }
 /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
@@ -163,24 +184,28 @@ export declare namespace AttoReceiveBlock.$metadata$ {
     const constructor: abstract new () => AttoReceiveBlock;
 }
 export declare namespace AttoReceiveBlock {
-    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
         private constructor();
     }
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
         abstract class constructor {
             private constructor();
         }
     }
 }
 export declare class AttoOpenBlock implements AttoBlock, ReceiveSupport, RepresentativeSupport {
-    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, balance: AttoAmount, timestamp: any/* Instant */, sendHashAlgorithm: AttoAlgorithm, sendHash: AttoHash, representativeAlgorithm: AttoAlgorithm, representativePublicKey: AttoPublicKey);
+    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, balance: AttoAmount, timestamp: AttoInstant, sendHashAlgorithm: AttoAlgorithm, sendHash: AttoHash, representativeAlgorithm: AttoAlgorithm, representativePublicKey: AttoPublicKey);
     get network(): AttoNetwork;
     get version(): AttoVersion;
     get algorithm(): AttoAlgorithm;
     get publicKey(): AttoPublicKey;
     get balance(): AttoAmount;
-    get timestamp(): any/* Instant */;
+    get timestamp(): AttoInstant;
     get sendHashAlgorithm(): AttoAlgorithm;
     get sendHash(): AttoHash;
     get representativeAlgorithm(): AttoAlgorithm;
@@ -190,11 +215,12 @@ export declare class AttoOpenBlock implements AttoBlock, ReceiveSupport, Represe
     get height(): AttoHeight;
     get address(): AttoAddress;
     get representativeAddress(): AttoAddress;
-    isValid(): boolean;
-    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, balance?: AttoAmount, timestamp?: any/* Instant */, sendHashAlgorithm?: AttoAlgorithm, sendHash?: AttoHash, representativeAlgorithm?: AttoAlgorithm, representativePublicKey?: AttoPublicKey): AttoOpenBlock;
+    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, balance?: AttoAmount, timestamp?: AttoInstant, sendHashAlgorithm?: AttoAlgorithm, sendHash?: AttoHash, representativeAlgorithm?: AttoAlgorithm, representativePublicKey?: AttoPublicKey): AttoOpenBlock;
     toString(): string;
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
+    validate(): any/* AttoValidation */;
+    isValid(): boolean;
     readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & ReceiveSupport["__doNotUseOrImplementIt"] & RepresentativeSupport["__doNotUseOrImplementIt"];
 }
 /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
@@ -202,25 +228,29 @@ export declare namespace AttoOpenBlock.$metadata$ {
     const constructor: abstract new () => AttoOpenBlock;
 }
 export declare namespace AttoOpenBlock {
-    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
         private constructor();
     }
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
         abstract class constructor {
             private constructor();
         }
     }
 }
 export declare class AttoChangeBlock implements AttoBlock, PreviousSupport, RepresentativeSupport {
-    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, height: AttoHeight, balance: AttoAmount, timestamp: any/* Instant */, previous: AttoHash, representativeAlgorithm: AttoAlgorithm, representativePublicKey: AttoPublicKey);
+    constructor(network: AttoNetwork, version: AttoVersion, algorithm: AttoAlgorithm, publicKey: AttoPublicKey, height: AttoHeight, balance: AttoAmount, timestamp: AttoInstant, previous: AttoHash, representativeAlgorithm: AttoAlgorithm, representativePublicKey: AttoPublicKey);
     get network(): AttoNetwork;
     get version(): AttoVersion;
     get algorithm(): AttoAlgorithm;
     get publicKey(): AttoPublicKey;
     get height(): AttoHeight;
     get balance(): AttoAmount;
-    get timestamp(): any/* Instant */;
+    get timestamp(): AttoInstant;
     get previous(): AttoHash;
     get representativeAlgorithm(): AttoAlgorithm;
     get representativePublicKey(): AttoPublicKey;
@@ -228,11 +258,12 @@ export declare class AttoChangeBlock implements AttoBlock, PreviousSupport, Repr
     get hash(): AttoHash;
     get address(): AttoAddress;
     get representativeAddress(): AttoAddress;
-    isValid(): boolean;
-    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, height?: AttoHeight, balance?: AttoAmount, timestamp?: any/* Instant */, previous?: AttoHash, representativeAlgorithm?: AttoAlgorithm, representativePublicKey?: AttoPublicKey): AttoChangeBlock;
+    copy(network?: AttoNetwork, version?: AttoVersion, algorithm?: AttoAlgorithm, publicKey?: AttoPublicKey, height?: AttoHeight, balance?: AttoAmount, timestamp?: AttoInstant, previous?: AttoHash, representativeAlgorithm?: AttoAlgorithm, representativePublicKey?: AttoPublicKey): AttoChangeBlock;
     toString(): string;
     hashCode(): number;
     equals(other: Nullable<any>): boolean;
+    validate(): any/* AttoValidation */;
+    isValid(): boolean;
     readonly __doNotUseOrImplementIt: AttoBlock["__doNotUseOrImplementIt"] & PreviousSupport["__doNotUseOrImplementIt"] & RepresentativeSupport["__doNotUseOrImplementIt"];
 }
 /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
@@ -240,11 +271,15 @@ export declare namespace AttoChangeBlock.$metadata$ {
     const constructor: abstract new () => AttoChangeBlock;
 }
 export declare namespace AttoChangeBlock {
-    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+    abstract class Companion {
+        static readonly getInstance: () => typeof Companion.$metadata$.type;
         private constructor();
     }
     /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
     namespace Companion.$metadata$ {
+        abstract class type extends KtSingleton<constructor>() {
+            private constructor();
+        }
         abstract class constructor {
             private constructor();
         }