@attocash/commons-js 5.0.0

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

@@ -0,0 +1,341 @@
+import {
+  THROW_IAE23kobfj9wdoxr as THROW_IAE,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import {
+  _UByte___init__impl__g9hnc43ude1dscg1q30 as _UByte___init__impl__g9hnc4,
+  _UByte___get_data__impl__jof9qr2p2xx2i2jvnz8 as _UByte___get_data__impl__jof9qr,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/UByte.mjs';
+import { Enum3alwj03lh1n41 as Enum } from '../../../../kotlin-kotlin-stdlib/kotlin/Enum.mjs';
+import {
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  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,
+  ULong3f9k7s38t3rfp as ULong,
+  ULong__toString_impl_f9au7kivnvhcxkib53 as ULong__toString_impl_f9au7k,
+  ULong__hashCode_impl_6hv2lb37naj4fr4k4il as ULong__hashCode_impl_6hv2lb,
+  Companion_getInstance1puqqwzccfvrg as Companion_getInstance,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/ULong.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 {
+  split3d3yeauc4rm2n as split,
+  padStart36w1507hs626a as padStart,
+  trimEndvvzjdhan75g as trimEnd,
+} from '../../../../kotlin-kotlin-stdlib/kotlin/text/Strings.mjs';
+import { toULong266mnyksbttkw as toULong } from '../../../../kotlin-kotlin-stdlib/kotlin/text/UStrings.mjs';
+import { toByte4i43936u611k as toByte } from '../../../../kotlin-kotlin-stdlib/kotlin/js/numberConversion.mjs';
+import {
+  ulongDivide3e52ct8hxp5n7 as ulongDivide,
+  ulongCompare29yg6v52hxi4l as ulongCompare,
+  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';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+var AttoUnit_ATTO_instance;
+var AttoUnit_RAW_instance;
+function values() {
+  return [AttoUnit_ATTO_getInstance(), AttoUnit_RAW_getInstance()];
+}
+function valueOf(value) {
+  switch (value) {
+    case 'ATTO':
+      return AttoUnit_ATTO_getInstance();
+    case 'RAW':
+      return AttoUnit_RAW_getInstance();
+    default:
+      AttoUnit_initEntries();
+      THROW_IAE('No enum constant value.');
+      break;
+  }
+}
+var AttoUnit_entriesInitialized;
+function AttoUnit_initEntries() {
+  if (AttoUnit_entriesInitialized)
+    return Unit_instance;
+  AttoUnit_entriesInitialized = true;
+  AttoUnit_ATTO_instance = new (AttoUnit())('ATTO', 0, 'atto', _UByte___init__impl__g9hnc4(9));
+  AttoUnit_RAW_instance = new (AttoUnit())('RAW', 1, 'raw', _UByte___init__impl__g9hnc4(0));
+}
+var AttoUnitClass;
+function AttoUnit() {
+  if (AttoUnitClass === VOID) {
+    class $ extends Enum() {
+      constructor(name, ordinal, prefix, scale) {
+        super(name, ordinal);
+        this.prefix = prefix;
+        this.v2x_1 = scale;
+      }
+      w2x() {
+        return this.prefix;
+      }
+      x2x() {
+        return this.v2x_1;
+      }
+      get name() {
+        return this.i3();
+      }
+      get ordinal() {
+        return this.j3();
+      }
+    }
+    initMetadataForClass($, 'AttoUnit');
+    AttoUnitClass = $;
+  }
+  return AttoUnitClass;
+}
+function pow($this, _this__u8e3s4, exponent) {
+  var result = _ULong___init__impl__c78o9k(new (Long())(1, 0));
+  // Inline function 'kotlin.repeat' call
+  var inductionVariable = 0;
+  if (inductionVariable < exponent)
+    do {
+      var index = inductionVariable;
+      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)));
+    }
+     while (inductionVariable < exponent);
+  return result;
+}
+function scaleFactor($this, scale) {
+  var tmp = _ULong___init__impl__c78o9k(new (Long())(10, 0));
+  // Inline function 'kotlin.UByte.toInt' call
+  var tmp$ret$0 = _UByte___get_data__impl__jof9qr(scale) & 255;
+  return pow($this, tmp, tmp$ret$0);
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {
+      constructor() {
+        Companion_instance = this;
+        this.y2x_1 = _ULong___init__impl__c78o9k(new (Long())(-989331456, -104015711));
+        this.MAX = new (AttoAmount())(this.y2x_1);
+        this.z2x_1 = _ULong___init__impl__c78o9k(new (Long())(0, 0));
+        this.MIN = new (AttoAmount())(this.z2x_1);
+      }
+      a2y() {
+        return this.MAX;
+      }
+      b2y() {
+        return this.MIN;
+      }
+      from(unit, string) {
+        var parts = split(string, charArrayOf([_Char___init__impl__6a9atx(46)]));
+        var wholePart = toULong(parts.j1(0));
+        var factor = scaleFactor(this, unit.v2x_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 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)));
+          // Inline function 'kotlin.toUByte' call
+          var this_0 = parts.j1(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)));
+        }
+        return new (AttoAmount())(scaledValue);
+      }
+      q2u() {
+        return AttoAmountSerializer_getInstance();
+      }
+    }
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance_0() {
+  if (Companion_instance === VOID)
+    new (Companion())();
+  return Companion_instance;
+}
+var AttoAmountClass;
+function AttoAmount() {
+  if (AttoAmountClass === VOID) {
+    class $ {
+      constructor(raw) {
+        Companion_getInstance_0();
+        this.raw = raw;
+        var tmp0 = this.raw;
+        // Inline function 'kotlin.ULong.compareTo' call
+        var other = Companion_getInstance_0().y2x_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().y2x_1));
+        }
+      }
+      c2y() {
+        return this.raw;
+      }
+      toFormattedString(unit) {
+        var factor = scaleFactor(Companion_getInstance_0(), unit.v2x_1);
+        // Inline function 'kotlin.ULong.div' call
+        var this_0 = this.raw;
+        var wholePart = ulongDivide(this_0, factor);
+        // Inline function 'kotlin.ULong.rem' call
+        var this_1 = this.raw;
+        var fractionalPart = ulongRemainder(this_1, factor);
+        var tmp;
+        if (equals(fractionalPart, _ULong___init__impl__c78o9k(new (Long())(0, 0)))) {
+          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.v2x_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;
+        }
+        return tmp;
+      }
+      plus(amount) {
+        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 tmp;
+        // 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) {
+          tmp = true;
+        } else {
+          // Inline function 'kotlin.ULong.compareTo' call
+          var other_1 = amount.raw;
+          tmp = ulongCompare(_ULong___get_data__impl__fggpzb(total), _ULong___get_data__impl__fggpzb(other_1)) < 0;
+        }
+        if (tmp) {
+          throw IllegalStateException().o4('ULong overflow');
+        }
+        return new (AttoAmount())(total);
+      }
+      minus(amount) {
+        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)));
+        // 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');
+        }
+        return new (AttoAmount())(total);
+      }
+      d2y(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.d2y(other instanceof AttoAmount() ? other : THROW_CCE());
+      }
+      toString() {
+        return '' + new (ULong())(this.raw);
+      }
+      e2y() {
+        return this.raw;
+      }
+      f2y(raw) {
+        return new (AttoAmount())(raw);
+      }
+      copy(raw, $super) {
+        raw = raw === VOID ? this.raw : raw;
+        return $super === VOID ? this.f2y(raw) : $super.f2y.call(this, new (ULong())(raw));
+      }
+      hashCode() {
+        return ULong__hashCode_impl_6hv2lb(this.raw);
+      }
+      equals(other) {
+        if (this === other)
+          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))
+          return false;
+        return true;
+      }
+    }
+    initMetadataForClass($, 'AttoAmount', VOID, VOID, [Comparable()], VOID, VOID, {0: AttoAmountSerializer_getInstance});
+    AttoAmountClass = $;
+  }
+  return AttoAmountClass;
+}
+var AttoAmountSerializerClass;
+function AttoAmountSerializer() {
+  if (AttoAmountSerializerClass === VOID) {
+    class $ {
+      constructor() {
+        AttoAmountSerializer_instance = this;
+        this.g2y_1 = serializer(Companion_getInstance()).xs();
+      }
+      xs() {
+        return this.g2y_1;
+      }
+      h2y(encoder, value) {
+        serializer(Companion_getInstance()).ys(encoder, new (ULong())(value.raw));
+      }
+      ys(encoder, value) {
+        return this.h2y(encoder, value instanceof AttoAmount() ? value : THROW_CCE());
+      }
+      zs(decoder) {
+        return new (AttoAmount())(serializer(Companion_getInstance()).zs(decoder).fs_1);
+      }
+    }
+    initMetadataForObject($, 'AttoAmountSerializer', VOID, VOID, [KSerializer()]);
+    AttoAmountSerializerClass = $;
+  }
+  return AttoAmountSerializerClass;
+}
+var AttoAmountSerializer_instance;
+function AttoAmountSerializer_getInstance() {
+  if (AttoAmountSerializer_instance === VOID)
+    new (AttoAmountSerializer())();
+  return AttoAmountSerializer_instance;
+}
+function AttoUnit_ATTO_getInstance() {
+  AttoUnit_initEntries();
+  return AttoUnit_ATTO_instance;
+}
+function AttoUnit_RAW_getInstance() {
+  AttoUnit_initEntries();
+  return AttoUnit_RAW_instance;
+}
+//region block: exports
+export {
+  Companion as Companion311shwy120dnf,
+  AttoAmount as AttoAmount28z2ffm4ih7im,
+  valueOf as valueOf2yt2l9kimc6n,
+  values as values3ntpkxfaw56c5,
+  AttoUnit as AttoUnit3uf7k0bjq9xrg,
+  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,
+};
+//endregion
+
+//# sourceMappingURL=AttoAmount.mjs.map

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

@@ -0,0 +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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"}

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

@@ -0,0 +1,252 @@
+type Nullable<T> = T | null | undefined
+declare function KtSingleton<T>(): T & (abstract new() => any);
+export declare abstract class AttoBlockType {
+    private constructor();
+    static get UNKNOWN(): AttoBlockType & {
+        get name(): "UNKNOWN";
+        get ordinal(): 0;
+    };
+    static get OPEN(): AttoBlockType & {
+        get name(): "OPEN";
+        get ordinal(): 1;
+    };
+    static get RECEIVE(): AttoBlockType & {
+        get name(): "RECEIVE";
+        get ordinal(): 2;
+    };
+    static get SEND(): AttoBlockType & {
+        get name(): "SEND";
+        get ordinal(): 3;
+    };
+    static get CHANGE(): AttoBlockType & {
+        get name(): "CHANGE";
+        get ordinal(): 4;
+    };
+    get name(): "UNKNOWN" | "OPEN" | "RECEIVE" | "SEND" | "CHANGE";
+    get ordinal(): 0 | 1 | 2 | 3 | 4;
+    get code(): any/* UByte */;
+    get size(): number;
+    static values(): Array<AttoBlockType>;
+    static valueOf(value: string): AttoBlockType;
+}
+/** @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 AttoBlockType.$metadata$ {
+    const constructor: abstract new () => AttoBlockType;
+}
+export declare namespace AttoBlockType {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Companion.$metadata$ {
+        abstract class constructor {
+            from(code: any/* UByte */): AttoBlockType;
+            private constructor();
+        }
+    }
+}
+export declare interface HeightSupport {
+    readonly height: AttoHeight;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.HeightSupport": unique symbol;
+    };
+}
+export declare interface AttoBlock extends HeightSupport, AttoHashable/*, AttoSerializable */ {
+    readonly hash: AttoHash;
+    readonly type: AttoBlockType;
+    readonly network: AttoNetwork;
+    readonly version: AttoVersion;
+    readonly algorithm: AttoAlgorithm;
+    readonly publicKey: AttoPublicKey;
+    readonly height: AttoHeight;
+    readonly balance: AttoAmount;
+    readonly timestamp: any/* Instant */;
+    isValid(): boolean;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.AttoBlock": unique symbol;
+    } & HeightSupport["__doNotUseOrImplementIt"] & AttoHashable["__doNotUseOrImplementIt"];
+}
+export declare abstract class AttoBlock extends KtSingleton<AttoBlock.$metadata$.constructor>() {
+    private constructor();
+}
+/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+export declare namespace AttoBlock.$metadata$ {
+    abstract class constructor /* implements SerializerFactory */ {
+        fromBuffer(serializedBlock: any/* Buffer */): Nullable<AttoBlock>;
+        private constructor();
+    }
+}
+export declare interface PreviousSupport {
+    readonly height: AttoHeight;
+    readonly previous: AttoHash;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.PreviousSupport": unique symbol;
+    };
+}
+export declare interface ReceiveSupport {
+    readonly sendHashAlgorithm: AttoAlgorithm;
+    readonly sendHash: AttoHash;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.ReceiveSupport": unique symbol;
+    };
+}
+export declare interface RepresentativeSupport {
+    readonly representativeAlgorithm: AttoAlgorithm;
+    readonly representativePublicKey: AttoPublicKey;
+    readonly __doNotUseOrImplementIt: {
+        readonly "cash.atto.commons.RepresentativeSupport": unique symbol;
+    };
+}
+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);
+    get network(): AttoNetwork;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get height(): AttoHeight;
+    get balance(): AttoAmount;
+    get timestamp(): any/* Instant */;
+    get previous(): AttoHash;
+    get receiverAlgorithm(): AttoAlgorithm;
+    get receiverPublicKey(): AttoPublicKey;
+    get amount(): AttoAmount;
+    get type(): AttoBlockType;
+    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;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): 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 */
+export declare namespace AttoSendBlock.$metadata$ {
+    const constructor: abstract new () => AttoSendBlock;
+}
+export declare namespace AttoSendBlock {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Companion.$metadata$ {
+        abstract class constructor {
+            private constructor();
+        }
+    }
+}
+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);
+    get network(): AttoNetwork;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get height(): AttoHeight;
+    get balance(): AttoAmount;
+    get timestamp(): any/* Instant */;
+    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;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): 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 */
+export declare namespace AttoReceiveBlock.$metadata$ {
+    const constructor: abstract new () => AttoReceiveBlock;
+}
+export declare namespace AttoReceiveBlock {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Companion.$metadata$ {
+        abstract class constructor {
+            private constructor();
+        }
+    }
+}
+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);
+    get network(): AttoNetwork;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get balance(): AttoAmount;
+    get timestamp(): any/* Instant */;
+    get sendHashAlgorithm(): AttoAlgorithm;
+    get sendHash(): AttoHash;
+    get representativeAlgorithm(): AttoAlgorithm;
+    get representativePublicKey(): AttoPublicKey;
+    get type(): AttoBlockType;
+    get hash(): AttoHash;
+    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;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): 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 */
+export declare namespace AttoOpenBlock.$metadata$ {
+    const constructor: abstract new () => AttoOpenBlock;
+}
+export declare namespace AttoOpenBlock {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Companion.$metadata$ {
+        abstract class constructor {
+            private constructor();
+        }
+    }
+}
+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);
+    get network(): AttoNetwork;
+    get version(): AttoVersion;
+    get algorithm(): AttoAlgorithm;
+    get publicKey(): AttoPublicKey;
+    get height(): AttoHeight;
+    get balance(): AttoAmount;
+    get timestamp(): any/* Instant */;
+    get previous(): AttoHash;
+    get representativeAlgorithm(): AttoAlgorithm;
+    get representativePublicKey(): AttoPublicKey;
+    get type(): AttoBlockType;
+    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;
+    toString(): string;
+    hashCode(): number;
+    equals(other: Nullable<any>): 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 */
+export declare namespace AttoChangeBlock.$metadata$ {
+    const constructor: abstract new () => AttoChangeBlock;
+}
+export declare namespace AttoChangeBlock {
+    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
+        private constructor();
+    }
+    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
+    namespace Companion.$metadata$ {
+        abstract class constructor {
+            private constructor();
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+import {
+  AttoBlockType2o3t26mpp4g1m as AttoBlockType,
+  values1esofir5pvotm as values,
+  valueOfb8c3bsf1tbuo as valueOf,
+  AttoBlockType_UNKNOWN_getInstance3dnnplul63rg3 as AttoBlockType_UNKNOWN_getInstance,
+  AttoBlockType_OPEN_getInstance2qq2w4m4uqmq7 as AttoBlockType_OPEN_getInstance,
+  AttoBlockType_RECEIVE_getInstancemszz2w4jvf1a as AttoBlockType_RECEIVE_getInstance,
+  AttoBlockType_SEND_getInstance381mhjyjs1zzi as AttoBlockType_SEND_getInstance,
+  AttoBlockType_CHANGE_getInstance3orw5rx2tjqv2 as AttoBlockType_CHANGE_getInstance,
+  Companion3u1bosrh7rroz as Companion,
+  Companion_getInstance2phtijzt3ebp3 as Companion_getInstance,
+  Companion1dgdscbdp629o as Companion_0,
+  Companion_getInstance1l72fs50ibztr as Companion_getInstance_0,
+  AttoSendBlock3okbwu66utugk as AttoSendBlock,
+  Companion2stbuimptwsmu as Companion_1,
+  Companion_getInstance1oozvss6gswmf as Companion_getInstance_1,
+  AttoReceiveBlock1rskhrovahuhh as AttoReceiveBlock,
+  Companion35frkk3dh8l5t as Companion_2,
+  Companion_getInstance3uyok5rq53k69 as Companion_getInstance_2,
+  AttoOpenBlock12k0m6lgjqi4d as AttoOpenBlock,
+  Companion22hic3dn5hjie as Companion_3,
+  Companion_getInstance30jgubha5f9hp as Companion_getInstance_3,
+  AttoChangeBlock2ght5eopbdd3a as AttoChangeBlock,
+  Companion3m333c3oak3ah as Companion_4,
+  Companion_getInstance22d8d928ihuoo as Companion_getInstance_4,
+} from './AttoBlock.mjs';
+import { defineProp3hxgpk2knu2px as defineProp } from '../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+//region block: exports
+var AttoBlockType_0 = AttoBlockType();
+AttoBlockType_0.values = values;
+AttoBlockType_0.valueOf = valueOf;
+defineProp(AttoBlockType_0, 'UNKNOWN', AttoBlockType_UNKNOWN_getInstance);
+defineProp(AttoBlockType_0, 'OPEN', AttoBlockType_OPEN_getInstance);
+defineProp(AttoBlockType_0, 'RECEIVE', AttoBlockType_RECEIVE_getInstance);
+defineProp(AttoBlockType_0, 'SEND', AttoBlockType_SEND_getInstance);
+defineProp(AttoBlockType_0, 'CHANGE', AttoBlockType_CHANGE_getInstance);
+defineProp(AttoBlockType_0, 'Companion', Companion_getInstance);
+var AttoBlock = {getInstance: Companion_getInstance_0};
+var AttoSendBlock_0 = AttoSendBlock();
+defineProp(AttoSendBlock_0, 'Companion', Companion_getInstance_1);
+var AttoReceiveBlock_0 = AttoReceiveBlock();
+defineProp(AttoReceiveBlock_0, 'Companion', Companion_getInstance_2);
+var AttoOpenBlock_0 = AttoOpenBlock();
+defineProp(AttoOpenBlock_0, 'Companion', Companion_getInstance_3);
+var AttoChangeBlock_0 = AttoChangeBlock();
+defineProp(AttoChangeBlock_0, 'Companion', Companion_getInstance_4);
+export {
+  AttoBlockType_0 as AttoBlockType,
+  AttoBlock as AttoBlock,
+  AttoSendBlock_0 as AttoSendBlock,
+  AttoReceiveBlock_0 as AttoReceiveBlock,
+  AttoOpenBlock_0 as AttoOpenBlock,
+  AttoChangeBlock_0 as AttoChangeBlock,
+};
+//endregion
+
+//# sourceMappingURL=AttoBlock.export.mjs.map

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

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