@attocash/commons-js 5.4.1 → 6.1.0

package/commons-commons-wallet/cash/atto/commons/wallet/AttoWallet.mjs

@@ -0,0 +1,987 @@
+import { get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/Intrinsics.mjs';
+import { Unit_instance1fbcbse1fwigr as Unit_instance } from '../../../../../kotlin-kotlin-stdlib/kotlin/Unit.mjs';
+import { ArrayList3it5z8td81qkl as ArrayList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/ArrayListJs.mjs';
+import { collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/Iterables.mjs';
+import {
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/exceptions.mjs';
+import {
+  to2cs3ny02qtbcb as to,
+  Paire9pteg33gng7 as Pair,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/Tuples.mjs';
+import {
+  putAlliz90jhzb8z23 as putAll,
+  toMap1vec9topfei08 as toMap,
+  toMap2blj7l1rjb1hx as toMap_0,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/Maps.mjs';
+import {
+  toSet2orjxp16sotqu as toSet,
+  toList3jhuyej2anx2q as toList,
+  asSequence2phdjljfh9jhx as asSequence,
+  first28gmhyvs4kf06 as first,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/_Collections.mjs';
+import { toString1pkumu07cwy4m as toString } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/coreRuntime.mjs';
+import { Companion_getInstance1zxsxskq6zbhe as Companion_getInstance } from '../../../../../commons-commons-core/cash/atto/commons/AttoAccount.mjs';
+import {
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/js/metadataUtils.mjs';
+import { VOID3gxj6tk5isa35 as VOID } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/void.mjs';
+import { emptyList1g2z5xcrvp2zy as emptyList } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/CollectionsKt.mjs';
+import { LinkedHashMap1zhqxkxv3xnkl as LinkedHashMap } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/LinkedHashMap.mjs';
+import { mapsbvh18eqox7a as map } from '../../../../../kotlin-kotlin-stdlib/kotlin/sequences/_Sequences.mjs';
+import { AttoTransaction14p2u1c57z17z as AttoTransaction } from '../../../../../commons-commons-core/cash/atto/commons/AttoTransaction.mjs';
+import { Mutex16li1l0asjv17 as Mutex } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/sync/Mutex.mjs';
+import { suspendOrReturn49pspzlx5djv as suspendOrReturn } from '../../../../../kotlin-kotlin-stdlib/kotlin/coroutines/intrinsics/IntrinsicsJs.mjs';
+import { emptySetcxexqki71qfa as emptySet } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/Sets.mjs';
+import { MutableStateFlow34bfoyvwu8czu as MutableStateFlow } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/StateFlow.mjs';
+import { asStateFlow34rribx643ke5 as asStateFlow } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/Share.mjs';
+import {
+  compareTop92g04qgdk58 as compareTo,
+  AttoKeyIndex1s9zn741nq4qi as AttoKeyIndex,
+} from '../../../../../commons-commons-core/cash/atto/commons/AttoKeyIndex.mjs';
+import {
+  _UInt___init__impl__l7qpdltd1eeof8nsuj as _UInt___init__impl__l7qpdl,
+  _UInt___get_data__impl__f0vqqw13y1a2xkii3dn as _UInt___get_data__impl__f0vqqw,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/UInt.mjs';
+import { Dispatchers_getInstanceitgtkvqfcnx3 as Dispatchers_getInstance } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Dispatchers.mjs';
+import { _ULong___init__impl__c78o9k1p6qzv0dh0bvg as _ULong___init__impl__c78o9k } from '../../../../../kotlin-kotlin-stdlib/kotlin/ULong.mjs';
+import { toAttoAmountkv09taydvu7m as toAttoAmount } from '../../../../../commons-commons-core/cash/atto/commons/AttoAmount.mjs';
+import {
+  Companion_getInstance3vz87v4c01z2t as Companion_getInstance_0,
+  toDuration7gy6v749ektt as toDuration,
+  Duration__toString_impl_8d916b11f1kpclwmkpg as Duration__toString_impl_8d916b,
+} from '../../../../../kotlin-kotlin-stdlib/kotlin/time/Duration.mjs';
+import { DurationUnit_SECONDS_getInstance3jias9ne5z4er as DurationUnit_SECONDS_getInstance } from '../../../../../kotlin-kotlin-stdlib/kotlin/time/DurationUnitJs.mjs';
+import { CoroutineScopelux7s7zphw7e as CoroutineScope } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/CoroutineScope.mjs';
+import { AttoJob1jkwx1uqpl60h as AttoJob } from '../../../../../commons-commons-core/cash/atto/commons/AttoJob.mjs';
+import { buffer2o7vhreze5nfc as buffer } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/Context.mjs';
+import {
+  onEach13yrgg7fxnyl6 as onEach,
+  runningFold34m5nusi2en7n as runningFold,
+} from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/Transform.mjs';
+import {
+  retryWhenf2aqzvtrvxoo as retryWhen,
+  catchrcnx5mlu3pkp as catch_0,
+} from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/Errors.mjs';
+import { onCompletion2zzj1m13j2omp as onCompletion } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/Emitters.mjs';
+import { launchInn279ped9kwez as launchIn } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/Collect.mjs';
+import { THROW_CCE2g6jy02ryeudk as THROW_CCE } from '../../../../../kotlin-kotlin-stdlib/kotlin/hacks.mjs';
+import { AttoReceivable1xbn2f5t545d2 as AttoReceivable } from '../../../../../commons-commons-core/cash/atto/commons/AttoReceivable.mjs';
+import { delay1diib1rb84y4j as delay } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/Delay.mjs';
+import { FlowCollector26clgpmzihvke as FlowCollector } from '../../../../../kotlinx-coroutines-core/kotlinx/coroutines/flow/FlowCollector.mjs';
+import { isInterface3d6p8outrmvmk as isInterface } from '../../../../../kotlin-kotlin-stdlib/kotlin/js/typeCheckUtils.mjs';
+import { KtSetjrjc7fhfd6b9 as KtSet } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/Collections.mjs';
+import { minus165a8u1e0x1lu as minus } from '../../../../../kotlin-kotlin-stdlib/kotlin/collections/_Sets.mjs';
+import { KotlinLogging_instance177vcamif7bv as KotlinLogging_instance } from '../../../../../kotlin-logging/io/github/oshai/kotlinlogging/KotlinLogging.mjs';
+//region block: imports
+//endregion
+//region block: pre-declaration
+//endregion
+function get_logger() {
+  _init_properties_AttoWallet_kt__ddmhp5();
+  return logger;
+}
+var logger;
+function *_generator_withLock__kuz2eh($this, action, $completion) {
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.e3o_1;
+  var tmp = this_0.n1i(null, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0;
+  try {
+    var tmp_1 = action($completion);
+    if (tmp_1 === get_COROUTINE_SUSPENDED())
+      tmp_1 = yield tmp_1;
+    tmp_0 = tmp_1;
+  }finally {
+    this_0.y1h(null);
+  }
+  return tmp_0;
+}
+function *_generator_add__cbj1ot($this, accounts, $completion) {
+  if (accounts.o())
+    return Unit_instance;
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.i3o_1;
+  var tmp = this_0.n1i(null, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  try {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList().u(collectionSizeOrDefault(accounts, 10));
+    var _iterator__ex2g4s = accounts.k1();
+    while (_iterator__ex2g4s.l1()) {
+      var item = _iterator__ex2g4s.m1();
+      if ($this.g3o_1.n3(item.b3o_1)) {
+        throw IllegalArgumentException().j1('Account already exists for index ' + item.b3o_1.toString());
+      }
+      var tmp$ret$0 = to(item.b3o_1, item);
+      destination.v(tmp$ret$0);
+    }
+    var accounts_0 = destination;
+    var tmp0 = $this.f3o_1;
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList().u(collectionSizeOrDefault(accounts_0, 10));
+    var _iterator__ex2g4s_0 = accounts_0.k1();
+    while (_iterator__ex2g4s_0.l1()) {
+      var item_0 = _iterator__ex2g4s_0.m1();
+      var tmp$ret$3 = to(item_0.se_1.c3o_1, item_0.se_1);
+      destination_0.v(tmp$ret$3);
+    }
+    // Inline function 'kotlin.collections.plusAssign' call
+    putAll(tmp0, destination_0);
+    var tmp0_0 = $this.g3o_1;
+    // Inline function 'kotlin.collections.plusAssign' call
+    var map = toMap(accounts_0);
+    tmp0_0.j3(map);
+    $this.h3o_1.w1b(toSet($this.f3o_1.l3()));
+  }finally {
+    this_0.y1h(null);
+  }
+  return Unit_instance;
+}
+function *_generator_contains__sklk95($this, index, $completion) {
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.i3o_1;
+  var tmp = this_0.n1i(null, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0;
+  try {
+    tmp_0 = $this.g3o_1.n3(index);
+  }finally {
+    this_0.y1h(null);
+  }
+  return tmp_0;
+}
+function *_generator_contains__sklk95_0($this, address, $completion) {
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.i3o_1;
+  var tmp = this_0.n1i(null, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0;
+  try {
+    tmp_0 = $this.f3o_1.n3(address);
+  }finally {
+    this_0.y1h(null);
+  }
+  return tmp_0;
+}
+function *_generator_get__cbf6n6($this, index, $completion) {
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.i3o_1;
+  var tmp = this_0.n1i(null, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0;
+  try {
+    var tmp0_elvis_lhs = $this.g3o_1.p3(index);
+    var tmp_1;
+    if (tmp0_elvis_lhs == null) {
+      throw IllegalArgumentException().j1("Account doesn't exist for index " + index.toString());
+    } else {
+      tmp_1 = tmp0_elvis_lhs;
+    }
+    tmp_0 = tmp_1;
+  }finally {
+    this_0.y1h(null);
+  }
+  return tmp_0;
+}
+function *_generator_get__cbf6n6_0($this, address, $completion) {
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.i3o_1;
+  var tmp = this_0.n1i(null, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0;
+  try {
+    var tmp0_elvis_lhs = $this.f3o_1.p3(address);
+    var tmp_1;
+    if (tmp0_elvis_lhs == null) {
+      throw IllegalArgumentException().j1("Account doesn't exist for address " + address.toString());
+    } else {
+      tmp_1 = tmp0_elvis_lhs;
+    }
+    tmp_0 = tmp_1;
+  }finally {
+    this_0.y1h(null);
+  }
+  return tmp_0;
+}
+function *_generator_remove__l4h01w($this, index, $completion) {
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.i3o_1;
+  var tmp = this_0.n1i(null, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  try {
+    var tmp0_safe_receiver = $this.g3o_1.i3(index);
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      $this.f3o_1.i3(tmp0_safe_receiver.c3o_1);
+    }
+    $this.h3o_1.w1b(toSet($this.f3o_1.l3()));
+  }finally {
+    this_0.y1h(null);
+  }
+  return Unit_instance;
+}
+function *_generator_invoke__zhh2q8($this, $completion) {
+  var tmp0_elvis_lhs = $this.j3o_1.d3o_1;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    throw IllegalStateException().x4('Account is not open yet for index ' + $this.k3o_1.toString());
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var account = tmp;
+  var tmp1_elvis_lhs = $this.l3o_1;
+  var tmp_0;
+  if (tmp1_elvis_lhs == null) {
+    var tmp_1 = $this.m3o_1.p3o_1.o3h($completion);
+    if (tmp_1 === get_COROUTINE_SUSPENDED())
+      tmp_1 = yield tmp_1;
+    tmp_0 = tmp_1;
+  } else {
+    tmp_0 = tmp1_elvis_lhs;
+  }
+  var timestamp = tmp_0;
+  var _destruct__k2r9zo = account.v2u($this.n3o_1.algorithm, $this.n3o_1.publicKey, $this.o3o_1, timestamp);
+  var block = _destruct__k2r9zo.te();
+  var updatedAccount = _destruct__k2r9zo.ue();
+  var tmp_2 = $this.m3o_1.u3o($this.k3o_1, block, $completion);
+  if (tmp_2 === get_COROUTINE_SUSPENDED())
+    tmp_2 = yield tmp_2;
+  var transaction = tmp_2;
+  $this.j3o_1.d3o_1 = updatedAccount;
+  return transaction;
+}
+function *_generator_invoke__zhh2q8_0($this, $completion) {
+  var account = $this.v3o_1.d3o_1;
+  var tmp0_elvis_lhs = $this.w3o_1;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    var tmp_0 = $this.x3o_1.p3o_1.o3h($completion);
+    if (tmp_0 === get_COROUTINE_SUSPENDED())
+      tmp_0 = yield tmp_0;
+    tmp = tmp_0;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var timestamp = tmp;
+  var tmp_1;
+  if (account == null) {
+    // Inline function 'kotlin.require' call
+    if (!!($this.y3o_1 == null)) {
+      var message = 'Representative address must be provided for a new account';
+      throw IllegalArgumentException().j1(toString(message));
+    }
+    tmp_1 = Companion_getInstance().m2t($this.y3o_1.algorithm, $this.y3o_1.publicKey, $this.z3o_1, timestamp);
+  } else {
+    tmp_1 = account.w2u($this.z3o_1, timestamp);
+  }
+  var _destruct__k2r9zo = tmp_1;
+  var block = _destruct__k2r9zo.te();
+  var updatedAccount = _destruct__k2r9zo.ue();
+  var tmp_2 = $this.x3o_1.u3o($this.v3o_1.b3o_1, block, $completion);
+  if (tmp_2 === get_COROUTINE_SUSPENDED())
+    tmp_2 = yield tmp_2;
+  var transaction = tmp_2;
+  $this.v3o_1.d3o_1 = updatedAccount;
+  return transaction;
+}
+function *_generator_invoke__zhh2q8_1($this, $completion) {
+  var tmp0_elvis_lhs = $this.a3p_1.d3o_1;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    throw IllegalStateException().x4('Account is not open yet for index ' + $this.b3p_1.toString());
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var account = tmp;
+  var tmp1_elvis_lhs = $this.c3p_1;
+  var tmp_0;
+  if (tmp1_elvis_lhs == null) {
+    var tmp_1 = $this.d3p_1.p3o_1.o3h($completion);
+    if (tmp_1 === get_COROUTINE_SUSPENDED())
+      tmp_1 = yield tmp_1;
+    tmp_0 = tmp_1;
+  } else {
+    tmp_0 = tmp1_elvis_lhs;
+  }
+  var timestamp = tmp_0;
+  var _destruct__k2r9zo = account.y2u($this.e3p_1.algorithm, $this.e3p_1.publicKey, timestamp);
+  var block = _destruct__k2r9zo.te();
+  var updatedAccount = _destruct__k2r9zo.ue();
+  var tmp_2 = $this.d3p_1.u3o($this.b3p_1, block, $completion);
+  if (tmp_2 === get_COROUTINE_SUSPENDED())
+    tmp_2 = yield tmp_2;
+  var transaction = tmp_2;
+  $this.a3p_1.d3o_1 = updatedAccount;
+  return transaction;
+}
+var CompanionClass;
+function Companion() {
+  if (CompanionClass === VOID) {
+    class $ {}
+    initMetadataForCompanion($);
+    CompanionClass = $;
+  }
+  return CompanionClass;
+}
+var Companion_instance;
+function Companion_getInstance_1() {
+  return Companion_instance;
+}
+function *_generator_openAccount__127imp($this, indexes, $completion) {
+  if (indexes.o())
+    return emptyList();
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.s3o_1;
+  var tmp = this_0.n1i(null, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0;
+  try {
+    // Inline function 'kotlin.collections.mutableMapOf' call
+    var indexMap = LinkedHashMap().t4();
+    // Inline function 'kotlin.collections.forEach' call
+    var _iterator__ex2g4s = indexes.k1();
+    while (_iterator__ex2g4s.l1()) {
+      var element = _iterator__ex2g4s.m1();
+      var tmp_1 = $this.r3o_1(element, $completion);
+      if (tmp_1 === get_COROUTINE_SUSPENDED())
+        tmp_1 = yield tmp_1;
+      var signer = tmp_1;
+      // Inline function 'kotlin.collections.set' call
+      var key = signer.t2u();
+      indexMap.h3(key, element);
+    }
+    var tmp_2 = $this.p3o_1.g3h(toList(indexMap.l3()), $completion);
+    if (tmp_2 === get_COROUTINE_SUSPENDED())
+      tmp_2 = yield tmp_2;
+    var tmp_3 = asSequence(tmp_2);
+    var attoAccountMap = toMap_0(map(tmp_3, AttoWallet$openAccount$lambda));
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList().u(indexMap.n1());
+    // Inline function 'kotlin.collections.iterator' call
+    var _iterator__ex2g4s_0 = indexMap.x1().k1();
+    while (_iterator__ex2g4s_0.l1()) {
+      var item = _iterator__ex2g4s_0.m1();
+      var tmp$ret$5 = new (Account())(item.z1(), item.y1(), attoAccountMap.p3(item.y1()));
+      destination.v(tmp$ret$5);
+    }
+    var newAccounts = destination;
+    var tmp_4 = $this.t3o_1.f3p(newAccounts, $completion);
+    if (tmp_4 === get_COROUTINE_SUSPENDED())
+      tmp_4 = yield tmp_4;
+    return newAccounts;
+  }finally {
+    this_0.y1h(null);
+  }
+}
+function *_generator_openAccount__127imp_0($this, index, $completion) {
+  var tmp = $this.g3p(index, index, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return first(tmp);
+}
+function *_generator_closeAccount__jpnujx($this, index, $completion) {
+  // Inline function 'kotlinx.coroutines.sync.withLock' call
+  var this_0 = $this.s3o_1;
+  var tmp = this_0.n1i(null, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  try {
+    var tmp_0 = $this.t3o_1.h3p(index, $completion);
+    if (tmp_0 === get_COROUTINE_SUSPENDED())
+      tmp_0 = yield tmp_0;
+  }finally {
+    this_0.y1h(null);
+  }
+  return Unit_instance;
+}
+function *_generator_getAccount__zi3j4f($this, index, $completion) {
+  var tmp = $this.t3o_1.i3p(index, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return tmp.d3o_1;
+}
+function *_generator_getAccount__zi3j4f_0($this, address, $completion) {
+  var tmp = $this.t3o_1.j3p(address, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return tmp.d3o_1;
+}
+function *_generator_getAddress__kbacty($this, index, $completion) {
+  var tmp = $this.t3o_1.i3p(index, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return tmp.c3o_1;
+}
+function *_generator_publish__pkz857($this, index, block, $completion) {
+  var tmp = $this.r3o_1(index, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0 = tmp.p32(block, $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  var signature = tmp_0;
+  var tmp_1 = $this.q3o_1.m3m(block, $completion);
+  if (tmp_1 === get_COROUTINE_SUSPENDED())
+    tmp_1 = yield tmp_1;
+  var work = tmp_1;
+  var transaction = new (AttoTransaction())(block, signature, work);
+  var tmp_2 = $this.p3o_1.s3g(transaction, $completion);
+  if (tmp_2 === get_COROUTINE_SUSPENDED())
+    tmp_2 = yield tmp_2;
+  return transaction;
+}
+function *_generator_send__qhx0g0($this, index, receiverAddress, amount, timestamp, $completion) {
+  var tmp = $this.t3o_1.i3p(index, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var walletAccount = tmp;
+  var tmp_0 = walletAccount.k3p(AttoWallet$send$slambda_0(walletAccount, index, timestamp, $this, receiverAddress, amount), $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return tmp_0;
+}
+function *_generator_send__qhx0g0_0($this, address, receiverAddress, amount, timestamp, $completion) {
+  var tmp = $this.t3o_1.j3p(address, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var tmp_0 = $this.l3p(tmp.b3o_1, receiverAddress, amount, timestamp, $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return tmp_0;
+}
+function *_generator_receive__aoggq9($this, receivable, representativeAddress, timestamp, $completion) {
+  var tmp = $this.t3o_1.j3p(receivable.receiverAddress, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var walletAccount = tmp;
+  var tmp_0 = walletAccount.k3p(AttoWallet$receive$slambda_0(walletAccount, timestamp, $this, representativeAddress, receivable), $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return tmp_0;
+}
+function *_generator_change__fadal4($this, index, representativeAddress, timestamp, $completion) {
+  var tmp = $this.t3o_1.i3p(index, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  var walletAccount = tmp;
+  var tmp_0 = walletAccount.k3p(AttoWallet$change$slambda_0(walletAccount, index, timestamp, $this, representativeAddress), $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return tmp_0;
+}
+var AccountClass;
+function Account() {
+  if (AccountClass === VOID) {
+    class $ {
+      constructor(index, address, account) {
+        account = account === VOID ? null : account;
+        this.b3o_1 = index;
+        this.c3o_1 = address;
+        this.d3o_1 = account;
+        this.e3o_1 = Mutex();
+      }
+      k3p(action, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_withLock__kuz2eh.bind(VOID, this, action), $completion);
+      }
+    }
+    initMetadataForClass($, 'Account', VOID, VOID, VOID, [1]);
+    AccountClass = $;
+  }
+  return AccountClass;
+}
+var WalletAccountsClass;
+function WalletAccounts() {
+  if (WalletAccountsClass === VOID) {
+    class $ {
+      constructor() {
+        var tmp = this;
+        // Inline function 'kotlin.collections.mutableMapOf' call
+        tmp.f3o_1 = LinkedHashMap().t4();
+        var tmp_0 = this;
+        // Inline function 'kotlin.collections.mutableMapOf' call
+        tmp_0.g3o_1 = LinkedHashMap().t4();
+        this.h3o_1 = MutableStateFlow(emptySet());
+        this.i3o_1 = Mutex();
+      }
+      f3p(accounts, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_add__cbj1ot.bind(VOID, this, accounts), $completion);
+      }
+      m3p(index, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_contains__sklk95.bind(VOID, this, index), $completion);
+      }
+      n3p(address, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_contains__sklk95_0.bind(VOID, this, address), $completion);
+      }
+      i3p(index, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_get__cbf6n6.bind(VOID, this, index), $completion);
+      }
+      j3p(address, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_get__cbf6n6_0.bind(VOID, this, address), $completion);
+      }
+      h3p(index, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_remove__l4h01w.bind(VOID, this, index), $completion);
+      }
+      o3p() {
+        return asStateFlow(this.h3o_1);
+      }
+    }
+    initMetadataForClass($, 'WalletAccounts', WalletAccounts, VOID, VOID, [1]);
+    WalletAccountsClass = $;
+  }
+  return WalletAccountsClass;
+}
+function AttoWallet$openAccount$lambda(it) {
+  return to(it.address, it);
+}
+var AttoWallet$send$slambdaClass;
+function AttoWallet$send$slambda() {
+  if (AttoWallet$send$slambdaClass === VOID) {
+    class $ {
+      constructor($walletAccount, $index, $timestamp, this$0, $receiverAddress, $amount) {
+        this.j3o_1 = $walletAccount;
+        this.k3o_1 = $index;
+        this.l3o_1 = $timestamp;
+        this.m3o_1 = this$0;
+        this.n3o_1 = $receiverAddress;
+        this.o3o_1 = $amount;
+      }
+      jd($completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8.bind(VOID, this), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [0]);
+    AttoWallet$send$slambdaClass = $;
+  }
+  return AttoWallet$send$slambdaClass;
+}
+function AttoWallet$send$slambda_0($walletAccount, $index, $timestamp, this$0, $receiverAddress, $amount) {
+  var i = new (AttoWallet$send$slambda())($walletAccount, $index, $timestamp, this$0, $receiverAddress, $amount);
+  var l = ($completion) => i.jd($completion);
+  l.$arity = 0;
+  return l;
+}
+var AttoWallet$receive$slambdaClass;
+function AttoWallet$receive$slambda() {
+  if (AttoWallet$receive$slambdaClass === VOID) {
+    class $ {
+      constructor($walletAccount, $timestamp, this$0, $representativeAddress, $receivable) {
+        this.v3o_1 = $walletAccount;
+        this.w3o_1 = $timestamp;
+        this.x3o_1 = this$0;
+        this.y3o_1 = $representativeAddress;
+        this.z3o_1 = $receivable;
+      }
+      jd($completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8_0.bind(VOID, this), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [0]);
+    AttoWallet$receive$slambdaClass = $;
+  }
+  return AttoWallet$receive$slambdaClass;
+}
+function AttoWallet$receive$slambda_0($walletAccount, $timestamp, this$0, $representativeAddress, $receivable) {
+  var i = new (AttoWallet$receive$slambda())($walletAccount, $timestamp, this$0, $representativeAddress, $receivable);
+  var l = ($completion) => i.jd($completion);
+  l.$arity = 0;
+  return l;
+}
+var AttoWallet$change$slambdaClass;
+function AttoWallet$change$slambda() {
+  if (AttoWallet$change$slambdaClass === VOID) {
+    class $ {
+      constructor($walletAccount, $index, $timestamp, this$0, $representativeAddress) {
+        this.a3p_1 = $walletAccount;
+        this.b3p_1 = $index;
+        this.c3p_1 = $timestamp;
+        this.d3p_1 = this$0;
+        this.e3p_1 = $representativeAddress;
+      }
+      jd($completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8_1.bind(VOID, this), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [0]);
+    AttoWallet$change$slambdaClass = $;
+  }
+  return AttoWallet$change$slambdaClass;
+}
+function AttoWallet$change$slambda_0($walletAccount, $index, $timestamp, this$0, $representativeAddress) {
+  var i = new (AttoWallet$change$slambda())($walletAccount, $index, $timestamp, this$0, $representativeAddress);
+  var l = ($completion) => i.jd($completion);
+  l.$arity = 0;
+  return l;
+}
+var AttoWalletClass;
+function AttoWallet() {
+  if (AttoWalletClass === VOID) {
+    class $ {
+      constructor(client, worker, signerProvider) {
+        this.p3o_1 = client;
+        this.q3o_1 = worker;
+        this.r3o_1 = signerProvider;
+        this.s3o_1 = Mutex();
+        this.t3o_1 = new (WalletAccounts())();
+      }
+      p3p(indexes, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_openAccount__127imp.bind(VOID, this, indexes), $completion);
+      }
+      g3p(fromIndex, toIndex, $completion) {
+        // Inline function 'kotlin.require' call
+        if (!(compareTo(fromIndex, toIndex) <= 0)) {
+          var message = 'fromIndex (' + fromIndex.toString() + ') must be less than or equal to toIndex (' + toIndex.toString() + ')';
+          throw IllegalArgumentException().j1(toString(message));
+        }
+        // Inline function 'kotlin.collections.buildList' call
+        // Inline function 'kotlin.collections.buildListInternal' call
+        // Inline function 'kotlin.apply' call
+        var this_0 = ArrayList().r1();
+        var v = fromIndex;
+        while (compareTo(v, toIndex) <= 0) {
+          this_0.v(v);
+          var tmp0 = v.value;
+          // Inline function 'kotlin.UInt.plus' call
+          var other = _UInt___init__impl__l7qpdl(1);
+          var tmp$ret$2 = _UInt___init__impl__l7qpdl(_UInt___get_data__impl__f0vqqw(tmp0) + _UInt___get_data__impl__f0vqqw(other) | 0);
+          v = new (AttoKeyIndex())(tmp$ret$2);
+        }
+        var indexes = this_0.m4();
+        return this.p3p(indexes, $completion);
+      }
+      q3p(index, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_openAccount__127imp_0.bind(VOID, this, index), $completion);
+      }
+      r3p(index, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_closeAccount__jpnujx.bind(VOID, this, index), $completion);
+      }
+      o3p() {
+        return this.t3o_1.o3p();
+      }
+      s3p(index, $completion) {
+        return this.t3o_1.m3p(index, $completion);
+      }
+      t3p(address, $completion) {
+        return this.t3o_1.n3p(address, $completion);
+      }
+      u3p(index, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_getAccount__zi3j4f.bind(VOID, this, index), $completion);
+      }
+      v3p(address, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_getAccount__zi3j4f_0.bind(VOID, this, address), $completion);
+      }
+      w3p(index, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_getAddress__kbacty.bind(VOID, this, index), $completion);
+      }
+      u3o(index, block, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_publish__pkz857.bind(VOID, this, index, block), $completion);
+      }
+      l3p(index, receiverAddress, amount, timestamp, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_send__qhx0g0.bind(VOID, this, index, receiverAddress, amount, timestamp), $completion);
+      }
+      x3p(address, receiverAddress, amount, timestamp, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_send__qhx0g0_0.bind(VOID, this, address, receiverAddress, amount, timestamp), $completion);
+      }
+      y3p(receivable, representativeAddress, timestamp, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_receive__aoggq9.bind(VOID, this, receivable, representativeAddress, timestamp), $completion);
+      }
+      z3p(receivable, representativeAddress, timestamp, $completion, $super) {
+        representativeAddress = representativeAddress === VOID ? null : representativeAddress;
+        timestamp = timestamp === VOID ? null : timestamp;
+        return $super === VOID ? this.y3p(receivable, representativeAddress, timestamp, $completion) : $super.y3p.call(this, receivable, representativeAddress, timestamp, $completion);
+      }
+      a3q(index, representativeAddress, timestamp, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_change__fadal4.bind(VOID, this, index, representativeAddress, timestamp), $completion);
+      }
+    }
+    initMetadataForClass($, 'AttoWallet', VOID, VOID, VOID, [1, 2, 4, 3]);
+    AttoWalletClass = $;
+  }
+  return AttoWalletClass;
+}
+function startAutoReceiver(_this__u8e3s4, monitor, dispatcher, minAmount, retryAfter, defaultRepresentativeAddressProvider) {
+  dispatcher = dispatcher === VOID ? Dispatchers_getInstance().a15_1 : dispatcher;
+  minAmount = minAmount === VOID ? toAttoAmount(_ULong___init__impl__c78o9k(1n)) : minAmount;
+  var tmp;
+  if (retryAfter === VOID) {
+    // Inline function 'kotlin.time.Companion.seconds' call
+    Companion_getInstance_0();
+    tmp = toDuration(10, DurationUnit_SECONDS_getInstance());
+  } else {
+    tmp = retryAfter;
+  }
+  retryAfter = tmp;
+  _init_properties_AttoWallet_kt__ddmhp5();
+  var scope = CoroutineScope(dispatcher);
+  var job = startAutoReceiver_0(_this__u8e3s4, scope, monitor, minAmount, retryAfter, defaultRepresentativeAddressProvider);
+  return new (AttoJob())(job);
+}
+function startAutoReceiver_0(_this__u8e3s4, scope, monitor, minAmount, retryAfter, defaultRepresentativeAddressProvider) {
+  minAmount = minAmount === VOID ? toAttoAmount(_ULong___init__impl__c78o9k(1n)) : minAmount;
+  var tmp;
+  if (retryAfter === VOID) {
+    // Inline function 'kotlin.time.Companion.seconds' call
+    Companion_getInstance_0();
+    tmp = toDuration(10, DurationUnit_SECONDS_getInstance());
+  } else {
+    tmp = retryAfter;
+  }
+  retryAfter = tmp;
+  _init_properties_AttoWallet_kt__ddmhp5();
+  var bindJob = bindTo(_this__u8e3s4, scope, monitor);
+  var tmp_0 = buffer(monitor.r3k(minAmount));
+  var tmp_1 = onEach(tmp_0, startAutoReceiver$slambda_0(_this__u8e3s4, defaultRepresentativeAddressProvider));
+  var tmp_2 = retryWhen(tmp_1, startAutoReceiver$slambda_2(retryAfter));
+  return launchIn(onCompletion(tmp_2, startAutoReceiver$slambda_4(bindJob)), scope);
+}
+function bindTo(_this__u8e3s4, scope, monitor) {
+  _init_properties_AttoWallet_kt__ddmhp5();
+  var tmp = _this__u8e3s4.o3p();
+  var tmp_0 = to(emptySet(), emptySet());
+  var tmp_1 = runningFold(tmp, tmp_0, bindTo$slambda_0());
+  var tmp_2 = onEach(tmp_1, bindTo$slambda_2(monitor));
+  return launchIn(catch_0(tmp_2, bindTo$slambda_4()), scope);
+}
+function logger$lambda() {
+  _init_properties_AttoWallet_kt__ddmhp5();
+  return Unit_instance;
+}
+function *_generator_invoke__zhh2q8_2($this, it, $completion) {
+  var tmp = $this.b3q_1.z3p(it, $this.c3q_1(), VOID, $completion);
+  if (tmp === get_COROUTINE_SUSPENDED())
+    tmp = yield tmp;
+  return Unit_instance;
+}
+var startAutoReceiver$slambdaClass;
+function startAutoReceiver$slambda() {
+  if (startAutoReceiver$slambdaClass === VOID) {
+    class $ {
+      constructor($this_startAutoReceiver, $defaultRepresentativeAddressProvider) {
+        this.b3q_1 = $this_startAutoReceiver;
+        this.c3q_1 = $defaultRepresentativeAddressProvider;
+      }
+      d3q(it, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8_2.bind(VOID, this, it), $completion);
+      }
+      hd(p1, $completion) {
+        return this.d3q(p1 instanceof AttoReceivable() ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    startAutoReceiver$slambdaClass = $;
+  }
+  return startAutoReceiver$slambdaClass;
+}
+function startAutoReceiver$slambda_0($this_startAutoReceiver, $defaultRepresentativeAddressProvider) {
+  var i = new (startAutoReceiver$slambda())($this_startAutoReceiver, $defaultRepresentativeAddressProvider);
+  var l = (it, $completion) => i.d3q(it, $completion);
+  l.$arity = 1;
+  return l;
+}
+function *_generator_invoke__zhh2q8_3($this, $this$retryWhen, e, _unused_var__etf5q3, $completion) {
+  var tmp = get_logger();
+  tmp.zs(e, startAutoReceiver$slambda$lambda($this.e3q_1));
+  var tmp_0 = delay($this.e3q_1, $completion);
+  if (tmp_0 === get_COROUTINE_SUSPENDED())
+    tmp_0 = yield tmp_0;
+  return true;
+}
+function startAutoReceiver$slambda$lambda($retryAfter) {
+  return () => 'Failed to collect receivables. Retrying in ' + Duration__toString_impl_8d916b($retryAfter) + '...';
+}
+var startAutoReceiver$slambdaClass_0;
+function startAutoReceiver$slambda_1() {
+  if (startAutoReceiver$slambdaClass_0 === VOID) {
+    class $ {
+      constructor($retryAfter) {
+        this.e3q_1 = $retryAfter;
+      }
+      f3q($this$retryWhen, e, _unused_var__etf5q3, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8_3.bind(VOID, this, $this$retryWhen, e, _unused_var__etf5q3), $completion);
+      }
+      g3q(p1, p2, p3, $completion) {
+        var tmp = (!(p1 == null) ? isInterface(p1, FlowCollector()) : false) ? p1 : THROW_CCE();
+        var tmp_0 = p2 instanceof Error ? p2 : THROW_CCE();
+        return this.f3q(tmp, tmp_0, (!(p3 == null) ? typeof p3 === 'bigint' : false) ? p3 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [3]);
+    startAutoReceiver$slambdaClass_0 = $;
+  }
+  return startAutoReceiver$slambdaClass_0;
+}
+function startAutoReceiver$slambda_2($retryAfter) {
+  var i = new (startAutoReceiver$slambda_1())($retryAfter);
+  var l = ($this$retryWhen, e, _unused_var__etf5q3, $completion) => i.f3q($this$retryWhen, e, _unused_var__etf5q3, $completion);
+  l.$arity = 3;
+  return l;
+}
+var startAutoReceiver$slambdaClass_1;
+function startAutoReceiver$slambda_3() {
+  if (startAutoReceiver$slambdaClass_1 === VOID) {
+    class $ {
+      constructor($bindJob) {
+        this.h3q_1 = $bindJob;
+      }
+      i3q($this$onCompletion, it, $completion) {
+        this.h3q_1.aw();
+      }
+      id(p1, p2, $completion) {
+        var tmp = (!(p1 == null) ? isInterface(p1, FlowCollector()) : false) ? p1 : THROW_CCE();
+        return this.i3q(tmp, (p2 == null ? true : p2 instanceof Error) ? p2 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [2]);
+    startAutoReceiver$slambdaClass_1 = $;
+  }
+  return startAutoReceiver$slambdaClass_1;
+}
+function startAutoReceiver$slambda_4($bindJob) {
+  var i = new (startAutoReceiver$slambda_3())($bindJob);
+  var l = ($this$onCompletion, it, $completion) => i.i3q($this$onCompletion, it, $completion);
+  l.$arity = 2;
+  return l;
+}
+var bindTo$slambdaClass;
+function bindTo$slambda() {
+  if (bindTo$slambdaClass === VOID) {
+    class $ {
+      j3q(_destruct__k2r9zo, next, $completion) {
+        var previous = _destruct__k2r9zo.te();
+        return to(next, previous);
+      }
+      id(p1, p2, $completion) {
+        var tmp = p1 instanceof Pair() ? p1 : THROW_CCE();
+        return this.j3q(tmp, (!(p2 == null) ? isInterface(p2, KtSet()) : false) ? p2 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [2]);
+    bindTo$slambdaClass = $;
+  }
+  return bindTo$slambdaClass;
+}
+function bindTo$slambda_0() {
+  var i = new (bindTo$slambda())();
+  var l = (_destruct__k2r9zo, next, $completion) => i.j3q(_destruct__k2r9zo, next, $completion);
+  l.$arity = 2;
+  return l;
+}
+function *_generator_invoke__zhh2q8_4($this, _destruct__k2r9zo, $completion) {
+  var next = _destruct__k2r9zo.te();
+  var previous = _destruct__k2r9zo.ue();
+  var toAdd = minus(next, previous);
+  var toRemove = minus(previous, next);
+  var _iterator__ex2g4s = toAdd.k1();
+  while (_iterator__ex2g4s.l1()) {
+    var address = _iterator__ex2g4s.m1();
+    var tmp = $this.k3q_1.k3k(address, $completion);
+    if (tmp === get_COROUTINE_SUSPENDED())
+      tmp = yield tmp;
+    if (!tmp) {
+      var tmp_0 = $this.k3q_1.o3k(address, $completion);
+      if (tmp_0 === get_COROUTINE_SUSPENDED())
+        tmp_0 = yield tmp_0;
+    }
+  }
+  var _iterator__ex2g4s_0 = toRemove.k1();
+  while (_iterator__ex2g4s_0.l1()) {
+    var address_0 = _iterator__ex2g4s_0.m1();
+    var tmp_1 = $this.k3q_1.k3k(address_0, $completion);
+    if (tmp_1 === get_COROUTINE_SUSPENDED())
+      tmp_1 = yield tmp_1;
+    if (tmp_1) {
+      var tmp_2 = $this.k3q_1.p3k(address_0, $completion);
+      if (tmp_2 === get_COROUTINE_SUSPENDED())
+        tmp_2 = yield tmp_2;
+    }
+  }
+  return Unit_instance;
+}
+var bindTo$slambdaClass_0;
+function bindTo$slambda_1() {
+  if (bindTo$slambdaClass_0 === VOID) {
+    class $ {
+      constructor($monitor) {
+        this.k3q_1 = $monitor;
+      }
+      l3q(_destruct__k2r9zo, $completion) {
+        return suspendOrReturn(/*#__NOINLINE__*/_generator_invoke__zhh2q8_4.bind(VOID, this, _destruct__k2r9zo), $completion);
+      }
+      hd(p1, $completion) {
+        return this.l3q(p1 instanceof Pair() ? p1 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [1]);
+    bindTo$slambdaClass_0 = $;
+  }
+  return bindTo$slambdaClass_0;
+}
+function bindTo$slambda_2($monitor) {
+  var i = new (bindTo$slambda_1())($monitor);
+  var l = (_destruct__k2r9zo, $completion) => i.l3q(_destruct__k2r9zo, $completion);
+  l.$arity = 1;
+  return l;
+}
+function bindTo$slambda$lambda($e) {
+  return () => 'Bind to monitor failed with ' + $e.toString();
+}
+var bindTo$slambdaClass_1;
+function bindTo$slambda_3() {
+  if (bindTo$slambdaClass_1 === VOID) {
+    class $ {
+      m3q($this$catch, e, $completion) {
+        var tmp = get_logger();
+        tmp.zs(e, bindTo$slambda$lambda(e));
+      }
+      id(p1, p2, $completion) {
+        var tmp = (!(p1 == null) ? isInterface(p1, FlowCollector()) : false) ? p1 : THROW_CCE();
+        return this.m3q(tmp, p2 instanceof Error ? p2 : THROW_CCE(), $completion);
+      }
+    }
+    initMetadataForLambda($, VOID, VOID, [2]);
+    bindTo$slambdaClass_1 = $;
+  }
+  return bindTo$slambdaClass_1;
+}
+function bindTo$slambda_4() {
+  var i = new (bindTo$slambda_3())();
+  var l = ($this$catch, e, $completion) => i.m3q($this$catch, e, $completion);
+  l.$arity = 2;
+  return l;
+}
+var properties_initialized_AttoWallet_kt_jwxii1;
+function _init_properties_AttoWallet_kt__ddmhp5() {
+  if (!properties_initialized_AttoWallet_kt_jwxii1) {
+    properties_initialized_AttoWallet_kt_jwxii1 = true;
+    var tmp = KotlinLogging_instance;
+    logger = tmp.ct(logger$lambda);
+  }
+}
+//region block: init
+Companion_instance = new (Companion())();
+//endregion
+//region block: exports
+export {
+  AttoWallet as AttoWallet1whmu3qyz4let,
+  startAutoReceiver as startAutoReceiver1iqaoyf7nw3ww,
+};
+//endregion
+
+//# sourceMappingURL=AttoWallet.mjs.map