@tari-project/ootle 0.16.0 → 0.18.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.d.ts CHANGED
@@ -6,6 +6,7 @@ import { ConfidentialWithdrawProof } from '@tari-project/ootle-ts-bindings';
6
6
  import { Decision } from '@tari-project/ootle-ts-bindings';
7
7
  import { Event as Event_2 } from '@tari-project/ootle-ts-bindings';
8
8
  import { ExecuteResult } from '@tari-project/ootle-ts-bindings';
9
+ import { FeeReceipt } from '@tari-project/ootle-ts-bindings';
9
10
  import { FinalizeOutcome } from '@tari-project/ootle-ts-bindings';
10
11
  import { FinalizeResult } from '@tari-project/ootle-ts-bindings';
11
12
  import { GetSubstatesRequest } from '@tari-project/ootle-ts-bindings';
@@ -470,6 +471,17 @@ export declare class EncryptedData {
470
471
  toHex(): string;
471
472
  }
472
473
 
474
+ /**
475
+ * The fee (µTari) to submit a dry-run transaction at: {@link feesCharged} plus
476
+ * {@link FEE_ESTIMATE_ALLOWANCE}, matching the engine's `FeeReceipt::required_fees`.
477
+ *
478
+ * The fee is itself an input to what a transaction is charged, so the real run of a transaction
479
+ * built at a different fee than its dry run meters slightly differently; the allowance covers that
480
+ * drift. It does not cover a different transaction: re-estimate after changing the inputs or
481
+ * outputs.
482
+ */
483
+ export declare function estimatedFee(receipt: Pick<FeeReceipt, "cost_breakdown">): bigint;
484
+
473
485
  export { ExecuteResult }
474
486
 
475
487
  /**
@@ -555,6 +567,22 @@ export declare class FaucetInvokeBuilder {
555
567
  build(): UnsignedTransactionV1;
556
568
  }
557
569
 
570
+ /**
571
+ * µTari a dry-run fee estimate carries on top of what the dry run was charged.
572
+ *
573
+ * Mirrors `tari_engine_types::fees::FEE_ESTIMATE_ALLOWANCE`: the most a real run of the same
574
+ * transaction can cost over its dry run when built at a different fee.
575
+ */
576
+ export declare const FEE_ESTIMATE_ALLOWANCE = 12n;
577
+
578
+ /**
579
+ * The fee a receipt was charged (µTari): the sum of its cost breakdown, as the engine's
580
+ * `FeeReceipt::total_fees_charged` computes it.
581
+ *
582
+ * For a dry run this is what the run cost, not a fee to submit at: use {@link estimatedFee} for that.
583
+ */
584
+ export declare function feesCharged(receipt: Pick<FeeReceipt, "cost_breakdown">): bigint;
585
+
558
586
  export { FinalizeOutcome }
559
587
 
560
588
  export { FinalizeResult }
package/dist/index.js CHANGED
@@ -467,12 +467,21 @@ function at(e11) {
467
467
  is_write: "is_write" in e11 ? e11.is_write : true
468
468
  };
469
469
  }
470
- var ot = {
470
+ var ot = 12n;
471
+ function st(e11) {
472
+ let t2 = 0n;
473
+ for (let n2 of Object.values(e11.cost_breakdown.breakdown)) n2 !== void 0 && (t2 += BigInt(n2));
474
+ return t2;
475
+ }
476
+ function ct(e11) {
477
+ return st(e11) + ot;
478
+ }
479
+ var lt = {
471
480
  [u.LocalNet]: "http://localhost:12500",
472
481
  [u.Esmeralda]: "https://ootle-indexer-a.tari.com"
473
482
  };
474
- function st(e11) {
475
- let t2 = ot[e11];
483
+ function ut(e11) {
484
+ let t2 = lt[e11];
476
485
  if (t2 !== void 0) return t2;
477
486
  throw new v(`No default indexer URL is configured for ${u[e11]}. Pass an explicit URL via ProviderBuilder.withUrl(...) or IndexerProvider.connect({ url, network: Network.${u[e11]} }).`);
478
487
  }
@@ -488,35 +497,35 @@ function V(e11, t2, n2) {
488
497
  }
489
498
  return JSON.parse(r2);
490
499
  }
491
- function ct(e11) {
500
+ function dt(e11) {
492
501
  return V("decodeSubstateValue", ue, e11);
493
502
  }
494
- function lt(e11) {
503
+ function ft(e11) {
495
504
  return V("decodeExecuteResult", ce, e11);
496
505
  }
497
- function ut(e11) {
506
+ function pt(e11) {
498
507
  return V("decodeTransactionReceipt", de, e11);
499
508
  }
500
- function dt(e11) {
509
+ function mt(e11) {
501
510
  return V("decodeEvent", se, e11);
502
511
  }
503
- function ft(e11) {
512
+ function ht(e11) {
504
513
  return V("decodeResource", le, e11);
505
514
  }
506
- function pt(e11) {
515
+ function gt(e11) {
507
516
  return V("decodeUtxo", fe, e11);
508
517
  }
509
518
  function H(e11) {
510
- return "up" in e11.state ? ct(e11.state.up.substate) : null;
519
+ return "up" in e11.state ? dt(e11.state.up.substate) : null;
511
520
  }
512
- var mt = 132, ht = 32;
513
- function* gt(e11) {
521
+ var _t = 132, vt = 32;
522
+ function* yt(e11) {
514
523
  let t2 = /* @__PURE__ */ new Set();
515
- for (let n2 of U(e11, mt)) n2.length === ht * 2 && !t2.has(n2) && (t2.add(n2), yield `vault_${n2}`);
524
+ for (let n2 of U(e11, _t)) n2.length === vt * 2 && !t2.has(n2) && (t2.add(n2), yield `vault_${n2}`);
516
525
  }
517
- async function _t(e11, t2) {
526
+ async function bt(e11, t2) {
518
527
  let n2 = H(await e11.getSubstate(t2));
519
- return yt(n2) ? Array.from(gt(n2.Component.body.state)) : [];
528
+ return St(n2) ? Array.from(yt(n2.Component.body.state)) : [];
520
529
  }
521
530
  function* U(e11, t2) {
522
531
  if (Array.isArray(e11)) {
@@ -529,7 +538,7 @@ function* U(e11, t2) {
529
538
  if (r2 === "tag") {
530
539
  let e12 = n2.value;
531
540
  if (n2.tag === t2) {
532
- let t3 = vt(e12);
541
+ let t3 = xt(e12);
533
542
  t3 !== null && (yield t3);
534
543
  }
535
544
  yield* U(e12, t2);
@@ -541,18 +550,18 @@ function* U(e11, t2) {
541
550
  }
542
551
  for (let e12 of Object.values(n2)) yield* U(e12, t2);
543
552
  }
544
- function vt(e11) {
553
+ function xt(e11) {
545
554
  if (typeof e11 != "object" || !e11) return null;
546
555
  let t2 = e11;
547
556
  if (t2["@cbor"] !== "bytes") return null;
548
557
  let n2 = t2.hex;
549
558
  return typeof n2 == "string" ? n2 : null;
550
559
  }
551
- function yt(e11) {
560
+ function St(e11) {
552
561
  return typeof e11 == "object" && !!e11 && "Component" in e11;
553
562
  }
554
- var bt = "resource_0101010101010101010101010101010101010101010101010101010101010101", xt = "component_0102030000000000000000000000000000000000000000000000000000000000", St = "vault_0102030000000000000000000000000000000000000000000000000000000001", Ct = "resource_0102030000000000000000000000000000000000000000000000000000000002", wt = "__ootleRawJson", Tt = "stealth_revealed_input", Et = "stealth_revealed_change";
555
- function Dt(e11, t2) {
563
+ var Ct = "resource_0101010101010101010101010101010101010101010101010101010101010101", wt = "component_0102030000000000000000000000000000000000000000000000000000000000", Tt = "vault_0102030000000000000000000000000000000000000000000000000000000001", Et = "resource_0102030000000000000000000000000000000000000000000000000000000002", Dt = "__ootleRawJson", Ot = "stealth_revealed_input", kt = "stealth_revealed_change";
564
+ function At(e11, t2) {
556
565
  let n2 = e11.revealedInputBucket === null ? null : t2(e11.revealedInputBucket);
557
566
  return { StealthTransfer: {
558
567
  resource_address_ref: { Address: e11.resourceAddress },
@@ -561,7 +570,7 @@ function Dt(e11, t2) {
561
570
  } };
562
571
  }
563
572
  function W(e11) {
564
- return { [wt]: e11.toCompactJson() };
573
+ return { [Dt]: e11.toCompactJson() };
565
574
  }
566
575
  function G(e11) {
567
576
  return typeof e11 == "object" && !!e11 && "StealthTransfer" in e11;
@@ -571,7 +580,7 @@ function K(e11) {
571
580
  if (typeof r3 == "bigint") return r3.toString();
572
581
  if (typeof r3 == "object" && r3 && "__ootleRawJson" in r3) {
573
582
  let e13 = n2(t2.length);
574
- return t2.push(r3[wt]), e13;
583
+ return t2.push(r3[Dt]), e13;
575
584
  }
576
585
  return r3;
577
586
  });
@@ -590,14 +599,14 @@ async function q(e11, t2) {
590
599
  inputs: n2
591
600
  };
592
601
  }
593
- function Ot() {
602
+ function jt() {
594
603
  let { secret_key: e11, public_key: t2 } = o();
595
604
  return {
596
605
  secret_key: e11,
597
606
  public_key: t2
598
607
  };
599
608
  }
600
- function kt(e11, t2) {
609
+ function Mt(e11, t2) {
601
610
  return {
602
611
  public_key: b(y(e11, 32, "publicKey")),
603
612
  signature: b(y(t2, 64, "sr25519 signature"))
@@ -611,10 +620,10 @@ async function J(e11, t2) {
611
620
  main_signer: { Authorizer: b(n2) }
612
621
  };
613
622
  }
614
- async function At(e11, t2, n2) {
615
- return jt(e11, await J(e11, t2), n2);
623
+ async function Nt(e11, t2, n2) {
624
+ return Pt(e11, await J(e11, t2), n2);
616
625
  }
617
- async function jt(e11, t2, n2) {
626
+ async function Pt(e11, t2, n2) {
618
627
  let r2 = n2 ?? o(), i2 = y(r2.secret_key, 32, "sealKeypair.secret_key"), a2 = y(r2.public_key, 32, "sealKeypair.public_key"), s2 = [];
619
628
  for (let n3 of e11) {
620
629
  let e12 = await n3.signTransaction(t2, a2);
@@ -629,17 +638,17 @@ async function jt(e11, t2, n2) {
629
638
  function Y(e11) {
630
639
  return n(e11.sealedJson);
631
640
  }
632
- async function Mt(e11, t2) {
641
+ async function Ft(e11, t2) {
633
642
  return (await e11.submitTransaction(t2)).transaction_id;
634
643
  }
635
- function Nt(e11) {
644
+ function It(e11) {
636
645
  var _a;
637
646
  if (e11 === "Pending" || !("Finalized" in e11)) return null;
638
647
  let t2 = e11.Finalized, n2 = t2.final_decision;
639
648
  if (n2 === null) return null;
640
649
  if (n2 === "Commit") return { outcome: n2 };
641
650
  if (typeof n2 == "object" && n2 && "Abort" in n2) {
642
- let e12 = t2.abort_details ?? JSON.stringify(n2.Abort), r2 = t2.execution_result === null ? void 0 : (_a = lt(t2.execution_result).finalize) == null ? void 0 : _a.result;
651
+ let e12 = t2.abort_details ?? JSON.stringify(n2.Abort), r2 = t2.execution_result === null ? void 0 : (_a = ft(t2.execution_result).finalize) == null ? void 0 : _a.result;
643
652
  return typeof r2 == "object" && r2 && "AcceptFeeRejectRest" in r2 ? {
644
653
  outcome: "FeeIntentCommit",
645
654
  reason: e12
@@ -650,12 +659,12 @@ function Nt(e11) {
650
659
  }
651
660
  throw new v(`Unexpected final_decision variant: ${JSON.stringify(n2)}`);
652
661
  }
653
- async function Pt(e11, t2, n2) {
662
+ async function Lt(e11, t2, n2) {
654
663
  let r2 = (n2 == null ? void 0 : n2.pollIntervalMs) ?? 500, i2 = (n2 == null ? void 0 : n2.timeoutMs) ?? 6e4, a2 = Date.now() + i2;
655
664
  for (; ; ) {
656
665
  let n3 = await e11.getTransactionResult(t2), o2 = n3.result;
657
666
  if (o2 !== "Pending" && "Finalized" in o2) {
658
- let { outcome: e12, reason: r3 } = Nt(o2) ?? { outcome: "Reject" };
667
+ let { outcome: e12, reason: r3 } = It(o2) ?? { outcome: "Reject" };
659
668
  if (e12 === "Reject") throw new f(`Transaction ${t2} was rejected: ${r3}`, {
660
669
  txId: t2,
661
670
  reason: r3 ?? ""
@@ -670,17 +679,17 @@ async function Pt(e11, t2, n2) {
670
679
  await new Promise((e12) => setTimeout(e12, r2));
671
680
  }
672
681
  }
673
- async function Ft(e11, t2, n2, r2) {
682
+ async function Rt(e11, t2, n2, r2) {
674
683
  let i2 = await q(e11, n2);
675
- return Pt(e11, await Mt(e11, Y(await At(Array.isArray(t2) ? t2 : [t2], i2))), r2);
684
+ return Lt(e11, await Ft(e11, Y(await Nt(Array.isArray(t2) ? t2 : [t2], i2))), r2);
676
685
  }
677
- async function It(e11, t2, n2, r2) {
678
- return Ft(e11, t2, {
686
+ async function zt(e11, t2, n2, r2) {
687
+ return Rt(e11, t2, {
679
688
  ...n2,
680
689
  dry_run: true
681
690
  }, r2);
682
691
  }
683
- var Lt = class {
692
+ var Bt = class {
684
693
  constructor(e11) {
685
694
  __publicField(this, "publicKey");
686
695
  __publicField(this, "sign");
@@ -699,21 +708,21 @@ var Lt = class {
699
708
  try {
700
709
  a2 = await this.sign(i2);
701
710
  } catch (e12) {
702
- throw new g(`External signer failed: ${Rt(e12)}`, { cause: e12 });
711
+ throw new g(`External signer failed: ${Vt(e12)}`, { cause: e12 });
703
712
  }
704
713
  let o2;
705
714
  try {
706
715
  o2 = t(r2, this.publicKey, a2, n2);
707
716
  } catch (e12) {
708
- throw new g(`External signature rejected: ${Rt(e12)}`, { cause: e12 });
717
+ throw new g(`External signature rejected: ${Vt(e12)}`, { cause: e12 });
709
718
  }
710
719
  return JSON.parse(o2).signatures;
711
720
  }
712
721
  };
713
- function Rt(e11) {
722
+ function Vt(e11) {
714
723
  return e11 instanceof Error ? e11.message : String(e11);
715
724
  }
716
- var zt = class {
725
+ var Ht = class {
717
726
  constructor(e11, t2) {
718
727
  __publicField(this, "builder");
719
728
  this.builder = B.new(e11, t2);
@@ -739,7 +748,7 @@ var zt = class {
739
748
  build() {
740
749
  return this.builder.buildUnsignedTransaction();
741
750
  }
742
- }, Bt = class {
751
+ }, Ut = class {
743
752
  constructor(e11, t2, n2) {
744
753
  __publicField(this, "builder");
745
754
  __publicField(this, "faucetAddress");
@@ -776,7 +785,7 @@ var zt = class {
776
785
  build() {
777
786
  return this.builder.buildUnsignedTransaction();
778
787
  }
779
- }, Vt = class {
788
+ }, Wt = class {
780
789
  constructor() {
781
790
  __publicField(this, "keyProviders");
782
791
  __publicField(this, "defaultSignerAddress", null);
@@ -822,7 +831,7 @@ var zt = class {
822
831
  if (n2 === void 0) throw new m(t2 === "default" ? `No key provider registered for default address: ${e11}. Call wallet.registerKeyProvider(address, signer) for that address, or pick a different default with setDefaultSigner(otherAddress).` : `No key provider registered for address: ${e11}. Call wallet.registerKeyProvider(${JSON.stringify(e11)}, signer) before signing.`, { address: e11 });
823
832
  return n2;
824
833
  }
825
- }, Ht = class {
834
+ }, Gt = class {
826
835
  constructor(e11, t2) {
827
836
  __publicField(this, "bytes");
828
837
  this.bytes = new Uint8Array(y(e11, 32, t2));
@@ -833,7 +842,7 @@ var zt = class {
833
842
  toHex() {
834
843
  return b(this.bytes);
835
844
  }
836
- }, X = class e3 extends Ht {
845
+ }, X = class e3 extends Gt {
837
846
  constructor(e11) {
838
847
  super(e11, "Mask");
839
848
  }
@@ -846,7 +855,7 @@ var zt = class {
846
855
  static fromHex(t2) {
847
856
  return new e3(x(t2));
848
857
  }
849
- }, Ut = class e4 {
858
+ }, Kt = class e4 {
850
859
  constructor(e11) {
851
860
  __publicField(this, "bytes");
852
861
  this.bytes = new Uint8Array(e11);
@@ -860,8 +869,8 @@ var zt = class {
860
869
  toHex() {
861
870
  return b(this.bytes);
862
871
  }
863
- }, Wt = Object.freeze({ StealthPublicKey: Object.freeze({}) });
864
- function Gt(e11) {
872
+ }, qt = Object.freeze({ StealthPublicKey: Object.freeze({}) });
873
+ function Jt(e11) {
865
874
  if (e11.amount <= 0n) throw new v(`Output amount must be > 0, got ${e11.amount}`);
866
875
  return {
867
876
  destination: e11.destination,
@@ -869,19 +878,19 @@ function Gt(e11) {
869
878
  resourceAddress: e11.resourceAddress,
870
879
  resourceViewKey: e11.resourceViewKey === void 0 ? void 0 : new Uint8Array(e11.resourceViewKey),
871
880
  memo: e11.memo,
872
- payTo: e11.payTo ?? Wt,
881
+ payTo: e11.payTo ?? qt,
873
882
  minimumValuePromise: e11.minimumValuePromise ?? 0n
874
883
  };
875
884
  }
876
- function Kt(e11, t2) {
885
+ function Yt(e11, t2) {
877
886
  if (e11.trim() === "") throw new v(`${t2} must be a non-empty decimal string`);
878
887
  return BigInt(e11);
879
888
  }
880
- function qt(e11, t2) {
889
+ function Xt(e11, t2) {
881
890
  let n2 = e11.trim();
882
891
  if (!n2.startsWith("{") || !n2.endsWith("}")) throw new v(`StealthTransferStatement.toCompactJson: ${t2} fragment is not a JSON object (got: ${e11.slice(0, 60)}...)`);
883
892
  }
884
- var Jt = class e5 extends Ht {
893
+ var Z = class e5 extends Gt {
885
894
  constructor(e11) {
886
895
  super(e11, "StealthInput.commitment");
887
896
  }
@@ -894,7 +903,7 @@ var Jt = class e5 extends Ht {
894
903
  static fromJSON(t2) {
895
904
  return new e5(x(t2.commitment));
896
905
  }
897
- }, Z = class e6 {
906
+ }, Q = class e6 {
898
907
  constructor(e11, t2) {
899
908
  __publicField(this, "_publicNonce");
900
909
  __publicField(this, "_signature");
@@ -915,7 +924,7 @@ var Jt = class e5 extends Ht {
915
924
  static fromJSON(t2) {
916
925
  return new e6(x(t2.public_nonce), x(t2.signature));
917
926
  }
918
- }, Yt = class e7 {
927
+ }, Zt = class e7 {
919
928
  constructor(e11, t2, n2) {
920
929
  __publicField(this, "inputs");
921
930
  __publicField(this, "revealedAmount");
@@ -932,9 +941,9 @@ var Jt = class e5 extends Ht {
932
941
  };
933
942
  }
934
943
  static fromJSON(t2) {
935
- return new e7(t2.inputs.map(Jt.fromJSON), Kt(t2.revealed_amount, "revealed_amount"));
944
+ return new e7(t2.inputs.map(Z.fromJSON), Yt(t2.revealed_amount, "revealed_amount"));
936
945
  }
937
- }, Xt = class e8 {
946
+ }, Qt = class e8 {
938
947
  constructor(e11) {
939
948
  __publicField(this, "statementJson");
940
949
  this.statementJson = e11;
@@ -948,7 +957,7 @@ var Jt = class e5 extends Ht {
948
957
  static fromJSON(t2) {
949
958
  return new e8(t2);
950
959
  }
951
- }, Q = class e9 {
960
+ }, $ = class e9 {
952
961
  constructor(e11, t2, n2) {
953
962
  __publicField(this, "inputsStatement");
954
963
  __publicField(this, "outputsStatement");
@@ -964,15 +973,15 @@ var Jt = class e5 extends Ht {
964
973
  }
965
974
  toCompactJson() {
966
975
  let e11 = this.inputsStatement.statementJson ?? JSON.stringify(this.inputsStatement.toJSON()), t2 = this.outputsStatement.statementJson;
967
- qt(e11, "inputs_statement"), qt(t2, "outputs_statement");
976
+ Xt(e11, "inputs_statement"), Xt(t2, "outputs_statement");
968
977
  let n2 = `{"inputs_statement":${e11},"outputs_statement":${t2},"covenant_claims":[]`;
969
978
  return this.balanceProof !== void 0 && (n2 += `,"balance_proof":${JSON.stringify(this.balanceProof.toJSON())}`), n2 + "}";
970
979
  }
971
980
  static fromJSON(t2) {
972
- return new e9(Yt.fromJSON(t2.inputs), Xt.fromJSON(t2.outputs), t2.balance_proof === void 0 ? void 0 : Z.fromJSON(t2.balance_proof));
981
+ return new e9(Zt.fromJSON(t2.inputs), Qt.fromJSON(t2.outputs), t2.balance_proof === void 0 ? void 0 : Q.fromJSON(t2.balance_proof));
973
982
  }
974
983
  };
975
- function Zt(e11, t2) {
984
+ function $t(e11, t2) {
976
985
  let n2 = new Uint8Array(e11.length * 32);
977
986
  for (let r2 = 0; r2 < e11.length; r2++) {
978
987
  let i2 = e11[r2];
@@ -980,7 +989,7 @@ function Zt(e11, t2) {
980
989
  }
981
990
  return n2;
982
991
  }
983
- var Qt = "[]", $t = class {
992
+ var en = "[]", tn = class {
984
993
  constructor(e11 = u.LocalNet) {
985
994
  __publicField(this, "network");
986
995
  this.network = e11;
@@ -990,23 +999,23 @@ var Qt = "[]", $t = class {
990
999
  t2 !== null && (y(t2.receiver, 32, "revealed output receiver"), r2 = t2.amount, i2 = t2.receiver);
991
1000
  let a2 = l(n2, r2, i2);
992
1001
  return y(a2.aggregated_output_mask, 32, "StealthOutputsResult.aggregated_output_mask"), {
993
- statement: Xt.fromJSON(a2.statement_json),
1002
+ statement: Qt.fromJSON(a2.statement_json),
994
1003
  outputMask: X.fromBytes(a2.aggregated_output_mask)
995
1004
  };
996
1005
  }
997
1006
  outputWitness(e11) {
998
- let t2 = te(e11.destination), n2 = en(e11.payTo) ? null : JSON.stringify(e11.payTo), r2 = e11.memo === void 0 ? null : JSON.stringify(e11.memo), a2 = e11.resourceViewKey ?? null;
1007
+ let t2 = te(e11.destination), n2 = nn(e11.payTo) ? null : JSON.stringify(e11.payTo), r2 = e11.memo === void 0 ? null : JSON.stringify(e11.memo), a2 = e11.resourceViewKey ?? null;
999
1008
  return i(this.network, t2.owner_key, t2.view_key, e11.amount, e11.resourceAddress, a2, r2, n2, e11.minimumValuePromise);
1000
1009
  }
1001
1010
  async buildInputsStatement(e11, t2) {
1002
- return new Yt(e11, t2, r(Zt(e11.map((e12) => e12.commitment), "input commitment"), t2));
1011
+ return new Zt(e11, t2, r($t(e11.map((e12) => e12.commitment), "input commitment"), t2));
1003
1012
  }
1004
1013
  async generateBalanceProofSignature(e11, t2, n2, r2) {
1005
- let i2 = c(e11.toBytes(), t2.toBytes(), n2, r2, Qt);
1006
- return y(i2.public_nonce, 32, "balance proof public_nonce"), y(i2.signature, 32, "balance proof signature"), new Z(i2.public_nonce, i2.signature);
1014
+ let i2 = c(e11.toBytes(), t2.toBytes(), n2, r2, en);
1015
+ return y(i2.public_nonce, 32, "balance proof public_nonce"), y(i2.signature, 32, "balance proof signature"), new Q(i2.public_nonce, i2.signature);
1007
1016
  }
1008
1017
  async validateBalanceProofSignature(e11, t2, n2) {
1009
- return ae(e11.publicNonce, e11.signature, t2, n2, Qt);
1018
+ return ae(e11.publicNonce, e11.signature, t2, n2, en);
1010
1019
  }
1011
1020
  async deriveAeadKey(e11, t2) {
1012
1021
  y(e11, 32, "deriveAeadKey privateKey"), y(t2, 32, "deriveAeadKey publicKey");
@@ -1023,7 +1032,7 @@ var Qt = "[]", $t = class {
1023
1032
  };
1024
1033
  }
1025
1034
  async aggregateInputMasks(t2) {
1026
- let n2 = e(Zt(t2.map((e11) => e11.toBytes()), "input mask"));
1035
+ let n2 = e($t(t2.map((e11) => e11.toBytes()), "input mask"));
1027
1036
  return X.fromBytes(n2);
1028
1037
  }
1029
1038
  async stealthDhSecret(e11, t2, n2, r2) {
@@ -1035,49 +1044,49 @@ var Qt = "[]", $t = class {
1035
1044
  oe(e11.toCompactJson(), null);
1036
1045
  }
1037
1046
  };
1038
- function en(e11) {
1047
+ function nn(e11) {
1039
1048
  let t2 = Object.keys(e11);
1040
1049
  if (t2.length !== 1 || t2[0] !== "StealthPublicKey") return false;
1041
1050
  let n2 = e11.StealthPublicKey;
1042
1051
  return typeof n2 == "object" && !!n2 && Object.keys(n2).length === 0;
1043
1052
  }
1044
- var tn = "utxo";
1045
- function nn(e11, t2) {
1046
- return `${tn}_${e11.startsWith("resource_") ? e11.slice(9) : e11}_${b(t2)}`;
1053
+ var rn = "utxo";
1054
+ function an(e11, t2) {
1055
+ return `${rn}_${e11.startsWith("resource_") ? e11.slice(9) : e11}_${b(t2)}`;
1047
1056
  }
1048
- var rn = 64;
1049
- function an(e11) {
1057
+ var on = 64;
1058
+ function sn(e11) {
1050
1059
  return typeof e11 == "object" && !!e11 && "Utxo" in e11;
1051
1060
  }
1052
- function on(e11) {
1061
+ function cn(e11) {
1053
1062
  return e11.length > 0 && /^[0-9a-fA-F]+$/.test(e11);
1054
1063
  }
1055
- function sn(e11) {
1064
+ function ln(e11) {
1056
1065
  let t2 = e11.split("_");
1057
- if (t2.length < 3 || t2[0] !== tn) return null;
1066
+ if (t2.length < 3 || t2[0] !== rn) return null;
1058
1067
  let n2 = t2[t2.length - 1];
1059
- return n2.length !== rn || !on(n2) ? null : x(n2);
1068
+ return n2.length !== on || !cn(n2) ? null : x(n2);
1060
1069
  }
1061
- function cn(e11, t2) {
1070
+ function un(e11, t2) {
1062
1071
  let n2 = H(e11);
1063
- if (n2 === null || !an(n2)) return null;
1072
+ if (n2 === null || !sn(n2)) return null;
1064
1073
  let r2 = n2.Utxo;
1065
1074
  if (r2.output === null || r2.is_frozen) return null;
1066
- let i2 = sn(t2);
1075
+ let i2 = ln(t2);
1067
1076
  return i2 === null ? null : {
1068
1077
  commitment: i2,
1069
1078
  body: r2.output.output
1070
1079
  };
1071
1080
  }
1072
- var ln = 0, un = class {
1073
- constructor(e11, t2, n2 = new $t(e11.network())) {
1081
+ var dn = 0, fn = class {
1082
+ constructor(e11, t2, n2 = new tn(e11.network())) {
1074
1083
  __publicField(this, "provider");
1075
1084
  __publicField(this, "crypto");
1076
1085
  __publicField(this, "builder");
1077
1086
  __publicField(this, "state");
1078
1087
  __publicField(this, "maxEpoch", null);
1079
1088
  __publicField(this, "prepared", false);
1080
- this.provider = e11, this.crypto = n2, this.builder = B.new(e11.network(), ln), this.state = {
1089
+ this.provider = e11, this.crypto = n2, this.builder = B.new(e11.network(), dn), this.state = {
1081
1090
  resource: t2,
1082
1091
  revealedInput: null,
1083
1092
  inputsToSpend: /* @__PURE__ */ new Map(),
@@ -1119,7 +1128,7 @@ var ln = 0, un = class {
1119
1128
  return this.builder = e11(this.builder), this;
1120
1129
  }
1121
1130
  spendStealthInput(e11, t2) {
1122
- let n2 = new Jt(t2), r2 = b(n2.commitment), i2 = this.state.inputsToSpend.get(r2);
1131
+ let n2 = new Z(t2), r2 = b(n2.commitment), i2 = this.state.inputsToSpend.get(r2);
1123
1132
  if (i2 !== void 0) throw new v(`spendStealthInput: duplicate commitment ${r2} \u2014 each commitment is one UTXO and may be spent once (already added for owner ${i2.owner}). A commitment uniquely identifies a UTXO; adding it again (even under a different owner) would self-double-spend.`);
1124
1133
  return this.state.inputsToSpend.set(r2, {
1125
1134
  input: n2,
@@ -1130,8 +1139,8 @@ var ln = 0, un = class {
1130
1139
  var _a;
1131
1140
  if (this.prepared) throw new v("StealthTransfer.prepare: already prepared \u2014 create a new StealthTransfer to build again");
1132
1141
  this.validate(), this.prepared = true;
1133
- let { statement: e11, outputMask: t2 } = await this.crypto.generateOutputsStatement(this.state.outputs, this.state.revealedOutput), n2 = new Q(await this.crypto.buildInputsStatement([...this.state.inputsToSpend.values()].map((e12) => e12.input), ((_a = this.state.revealedInput) == null ? void 0 : _a.amount) ?? 0n), e11, void 0);
1134
- this.emitInstructions(n2), this.maxEpoch === null && this.builder.buildUnsignedTransaction().max_epoch === ln && this.builder.withMaxEpoch(await $e(this.provider));
1142
+ let { statement: e11, outputMask: t2 } = await this.crypto.generateOutputsStatement(this.state.outputs, this.state.revealedOutput), n2 = new $(await this.crypto.buildInputsStatement([...this.state.inputsToSpend.values()].map((e12) => e12.input), ((_a = this.state.revealedInput) == null ? void 0 : _a.amount) ?? 0n), e11, void 0);
1143
+ this.emitInstructions(n2), this.maxEpoch === null && this.builder.buildUnsignedTransaction().max_epoch === dn && this.builder.withMaxEpoch(await $e(this.provider));
1135
1144
  let r2 = /* @__PURE__ */ new Set();
1136
1145
  if (this.state.revealedInput !== null) {
1137
1146
  let e12 = this.state.revealedInput.source;
@@ -1139,14 +1148,14 @@ var ln = 0, un = class {
1139
1148
  substate_id: e12,
1140
1149
  version: null
1141
1150
  }), r2.add(e12);
1142
- let t3 = await _t(this.provider, e12);
1151
+ let t3 = await bt(this.provider, e12);
1143
1152
  for (let e13 of t3) r2.has(e13) || (this.builder.addInput({
1144
1153
  substate_id: e13,
1145
1154
  version: null
1146
1155
  }), r2.add(e13));
1147
1156
  }
1148
1157
  for (let { input: e12 } of this.state.inputsToSpend.values()) {
1149
- let t3 = nn(this.state.resource, e12.commitment);
1158
+ let t3 = an(this.state.resource, e12.commitment);
1150
1159
  r2.has(t3) || (this.builder.addInput({
1151
1160
  substate_id: t3,
1152
1161
  version: null
@@ -1185,38 +1194,38 @@ var ln = 0, un = class {
1185
1194
  t2 !== null && (this.builder.callMethod({
1186
1195
  componentAddress: t2.source,
1187
1196
  methodName: "withdraw"
1188
- }, [j(this.state.resource), k(t2.amount)]).saveVar(Tt), n2 = Tt), this.builder.addInstruction(Dt({
1197
+ }, [j(this.state.resource), k(t2.amount)]).saveVar(Ot), n2 = Ot), this.builder.addInstruction(At({
1189
1198
  resourceAddress: this.state.resource,
1190
1199
  revealedInputBucket: n2,
1191
1200
  statement: e11
1192
- }, (e12) => this.builder.resolveWorkspaceOffsetId(e12))), this.state.revealedOutput !== null && t2 !== null && this.builder.saveVar(Et).callMethod({
1201
+ }, (e12) => this.builder.resolveWorkspaceOffsetId(e12))), this.state.revealedOutput !== null && t2 !== null && this.builder.saveVar(kt).callMethod({
1193
1202
  componentAddress: t2.source,
1194
1203
  methodName: "deposit"
1195
- }, [{ Workspace: Et }]);
1204
+ }, [{ Workspace: kt }]);
1196
1205
  }
1197
1206
  };
1198
- function dn(e11) {
1199
- if (fn(e11) || e11.statementJson !== void 0) return e11.statementJson;
1207
+ function pn(e11) {
1208
+ if (mn(e11) || e11.statementJson !== void 0) return e11.statementJson;
1200
1209
  if (e11.inputs.length > 0) throw new _("inputs statement has confidential inputs but no WASM statementJson \u2014 call buildInputsStatement first", { context: "statementJsonFor" });
1201
1210
  return JSON.stringify(e11.toJSON());
1202
1211
  }
1203
- function fn(e11) {
1212
+ function mn(e11) {
1204
1213
  return !("inputs" in e11);
1205
1214
  }
1206
- async function pn(e11, t2, n2, r2, i2) {
1207
- let a2 = dn(r2), o2 = dn(i2);
1215
+ async function hn(e11, t2, n2, r2, i2) {
1216
+ let a2 = pn(r2), o2 = pn(i2);
1208
1217
  return e11.generateBalanceProofSignature(t2, n2, a2, o2);
1209
1218
  }
1210
- async function $(e11, t2, n2, r2) {
1219
+ async function gn(e11, t2, n2, r2) {
1211
1220
  let i2 = await e11.deriveAeadKey(r2.viewSecret, r2.senderPublicNonce);
1212
1221
  return e11.unblindOutput(t2, n2, i2, r2.skipMemo);
1213
1222
  }
1214
- async function mn(e11, t2, n2, r2) {
1215
- let i2 = cn(n2, r2);
1223
+ async function _n(e11, t2, n2, r2) {
1224
+ let i2 = un(n2, r2);
1216
1225
  if (i2 === null) return null;
1217
1226
  let a2 = x(i2.body.encrypted_data), o2 = x(i2.body.public_nonce);
1218
1227
  try {
1219
- return await $(e11, i2.commitment, a2, {
1228
+ return await gn(e11, i2.commitment, a2, {
1220
1229
  senderPublicNonce: o2,
1221
1230
  viewSecret: t2,
1222
1231
  skipMemo: false
@@ -1225,33 +1234,33 @@ async function mn(e11, t2, n2, r2) {
1225
1234
  return null;
1226
1235
  }
1227
1236
  }
1228
- async function hn(e11, t2, n2) {
1237
+ async function vn(e11, t2, n2) {
1229
1238
  if (t2.length === 0) throw new v("generateOutputsStatement: at least one stealth output is required");
1230
1239
  let { statement: r2, outputMask: i2 } = await e11.generateOutputsStatement(t2, n2), a2 = await e11.buildInputsStatement([], 0n);
1231
- return new Q(a2, r2, await pn(e11, X.zero(), i2, a2, r2));
1240
+ return new $(a2, r2, await hn(e11, X.zero(), i2, a2, r2));
1232
1241
  }
1233
- var gn = class e10 {
1242
+ var yn = class e10 {
1234
1243
  constructor(e11, t2, n2, r2, i2) {
1235
1244
  this.wallet = e11, this.spec = t2, this.crypto = n2, this.mustSignWithAccountKey = r2, this.viewSecret = i2;
1236
1245
  }
1237
1246
  static fromSpec(t2, n2, r2 = {}) {
1238
- return new e10(t2, n2, r2.crypto ?? new $t(), r2.mustSignWithAccountKey ?? true, r2.viewSecret);
1247
+ return new e10(t2, n2, r2.crypto ?? new tn(), r2.mustSignWithAccountKey ?? true, r2.viewSecret);
1239
1248
  }
1240
1249
  async prepare(e11) {
1241
- let t2 = await this.resolveStealthInputs(e11), n2 = t2.length === 0 ? X.zero() : await this.crypto.aggregateInputMasks(t2.map((e12) => e12.mask)), r2 = await pn(this.crypto, n2, this.spec.outputMask, this.spec.statement.inputsStatement, this.spec.statement.outputsStatement), i2 = new Q(this.spec.statement.inputsStatement, this.spec.statement.outputsStatement, r2);
1250
+ let t2 = await this.resolveStealthInputs(e11), n2 = t2.length === 0 ? X.zero() : await this.crypto.aggregateInputMasks(t2.map((e12) => e12.mask)), r2 = await hn(this.crypto, n2, this.spec.outputMask, this.spec.statement.inputsStatement, this.spec.statement.outputsStatement), i2 = new $(this.spec.statement.inputsStatement, this.spec.statement.outputsStatement, r2);
1242
1251
  await this.crypto.validateTransfer(i2);
1243
- let a2 = vn(this.spec.unsignedTx, i2), o2 = this.mustSignWithAccountKey ? await J([this.wallet], a2) : a2, s2 = {
1252
+ let a2 = xn(this.spec.unsignedTx, i2), o2 = this.mustSignWithAccountKey ? await J([this.wallet], a2) : a2, s2 = {
1244
1253
  ...this.spec,
1245
1254
  unsignedTx: o2,
1246
1255
  statement: i2
1247
1256
  };
1248
- return new _n({
1257
+ return new bn({
1249
1258
  wallet: this.wallet,
1250
1259
  crypto: this.crypto,
1251
1260
  spec: s2,
1252
1261
  resolvedInputs: t2,
1253
1262
  mustSignWithAccountKey: this.mustSignWithAccountKey,
1254
- sealKeypair: Ot()
1263
+ sealKeypair: jt()
1255
1264
  });
1256
1265
  }
1257
1266
  async resolveViewSecret() {
@@ -1276,11 +1285,11 @@ var gn = class e10 {
1276
1285
  let t2 = await this.resolveViewSecret(), n2 = this.spec.state.resource, r2 = await Promise.allSettled(this.spec.inputs.map(async ({ input: r3, owner: i3 }) => {
1277
1286
  let a2 = b(r3.commitment), o2 = await e11.getStealthUtxo(n2, r3.commitment);
1278
1287
  if (o2 === null) throw new p(`WalletStealthAuthorizer.prepare: stealth input UTXO not found (spent or never created) for ${a2}`);
1279
- let s2 = cn(o2, nn(n2, r3.commitment));
1288
+ let s2 = un(o2, an(n2, r3.commitment));
1280
1289
  if (s2 === null) throw new p(`WalletStealthAuthorizer.prepare: stealth input ${a2} is not a live, spendable UTXO`);
1281
1290
  let c2 = x(s2.body.public_nonce), l2;
1282
1291
  try {
1283
- l2 = await $(this.crypto, s2.commitment, x(s2.body.encrypted_data), {
1292
+ l2 = await gn(this.crypto, s2.commitment, x(s2.body.encrypted_data), {
1284
1293
  senderPublicNonce: c2,
1285
1294
  viewSecret: t2,
1286
1295
  skipMemo: true
@@ -1302,7 +1311,7 @@ var gn = class e10 {
1302
1311
  if (i2 !== void 0) throw i2.reason;
1303
1312
  return r2.map((e12) => e12.value);
1304
1313
  }
1305
- }, _n = class {
1314
+ }, bn = class {
1306
1315
  constructor(e11) {
1307
1316
  __publicField(this, "wallet");
1308
1317
  __publicField(this, "crypto");
@@ -1348,10 +1357,10 @@ var gn = class e10 {
1348
1357
  let e11 = (await this.createAuthorizations()).flatMap((e12) => e12.signatures), t2 = [];
1349
1358
  this.mustSignWithAccountKey && t2.push(this.wallet);
1350
1359
  let n2 = [...e11, ...this.extraSignatures];
1351
- return n2.length > 0 && t2.push(new yn(n2)), Y(await jt(t2, this.spec.unsignedTx, this.sealKeypair));
1360
+ return n2.length > 0 && t2.push(new Sn(n2)), Y(await Pt(t2, this.spec.unsignedTx, this.sealKeypair));
1352
1361
  }
1353
1362
  };
1354
- function vn(e11, t2) {
1363
+ function xn(e11, t2) {
1355
1364
  let n2 = e11.instructions.findIndex(G);
1356
1365
  if (n2 < 0) throw new v("patchStealthStatement: expected exactly one StealthTransfer instruction, found 0 (not a stealth tx)");
1357
1366
  if (e11.instructions.slice(n2 + 1).findIndex(G) >= 0) throw new v("patchStealthStatement: expected exactly one StealthTransfer instruction, found more than one (malformed)");
@@ -1364,7 +1373,7 @@ function vn(e11, t2) {
1364
1373
  instructions: i2
1365
1374
  };
1366
1375
  }
1367
- var yn = class {
1376
+ var Sn = class {
1368
1377
  constructor(e11) {
1369
1378
  this.signatures = e11;
1370
1379
  }
@@ -1379,15 +1388,16 @@ var yn = class {
1379
1388
  }
1380
1389
  };
1381
1390
  export {
1382
- zt as AccountInvokeBuilder,
1383
- _n as AuthorizedTransfer,
1384
- Z as BalanceProofSignature,
1391
+ Ht as AccountInvokeBuilder,
1392
+ bn as AuthorizedTransfer,
1393
+ Q as BalanceProofSignature,
1385
1394
  _ as CryptoBridgeError,
1386
1395
  Qe as DEFAULT_TRANSACTION_VALIDITY_EPOCHS,
1387
1396
  h as DefaultSignerNotSetError,
1388
- Ut as EncryptedData,
1389
- Lt as ExternalKeySigner,
1390
- Bt as FaucetInvokeBuilder,
1397
+ Kt as EncryptedData,
1398
+ Bt as ExternalKeySigner,
1399
+ ot as FEE_ESTIMATE_ALLOWANCE,
1400
+ Ut as FaucetInvokeBuilder,
1391
1401
  pe as IndexerClientError,
1392
1402
  v as InvalidArgumentError,
1393
1403
  m as KeyProviderNotFoundError,
@@ -1395,80 +1405,82 @@ export {
1395
1405
  X as Mask,
1396
1406
  u as Network,
1397
1407
  d as OotleError,
1398
- Vt as OotleWallet,
1408
+ Wt as OotleWallet,
1399
1409
  he as OperationCancelledError,
1400
1410
  g as SignerError,
1401
- Jt as StealthInput,
1402
- Yt as StealthInputsStatement,
1403
- Xt as StealthOutputsStatement,
1404
- un as StealthTransfer,
1405
- Q as StealthTransferStatement,
1406
- bt as TARI_RESOURCE_ADDRESS,
1411
+ Z as StealthInput,
1412
+ Zt as StealthInputsStatement,
1413
+ Qt as StealthOutputsStatement,
1414
+ fn as StealthTransfer,
1415
+ $ as StealthTransferStatement,
1416
+ Ct as TARI_RESOURCE_ADDRESS,
1407
1417
  B as TransactionBuilder,
1408
1418
  f as TransactionRejectedError,
1409
1419
  me as TransactionTimeoutError,
1410
1420
  p as WalletError,
1411
- gn as WalletStealthAuthorizer,
1412
- $t as WasmStealthCrypto,
1413
- Ct as XTR_FAUCET_CLAIM_RESOURCE_ADDRESS,
1414
- xt as XTR_FAUCET_COMPONENT_ADDRESS,
1415
- St as XTR_FAUCET_VAULT_ADDRESS,
1421
+ yn as WalletStealthAuthorizer,
1422
+ tn as WasmStealthCrypto,
1423
+ Et as XTR_FAUCET_CLAIM_RESOURCE_ADDRESS,
1424
+ wt as XTR_FAUCET_COMPONENT_ADDRESS,
1425
+ Tt as XTR_FAUCET_VAULT_ADDRESS,
1416
1426
  k as amountLiteral,
1417
1427
  y as assertByteLength,
1418
1428
  ge as assertUnreachable,
1419
1429
  Fe as boolLiteral,
1420
- kt as buildTransactionSignature,
1430
+ Mt as buildTransactionSignature,
1421
1431
  A as bytesLiteral,
1422
1432
  Be as claimedOutputTombstoneAddressLiteral,
1423
- Nt as classifyOutcome,
1424
- sn as commitmentOf,
1433
+ It as classifyOutcome,
1434
+ ln as commitmentOf,
1425
1435
  Ie as componentAddressLiteral,
1426
- Gt as createOutput,
1427
- dt as decodeEvent,
1428
- lt as decodeExecuteResult,
1429
- ft as decodeResource,
1430
- ct as decodeSubstateValue,
1431
- ut as decodeTransactionReceipt,
1432
- pt as decodeUtxo,
1433
- $ as decryptInputData,
1434
- mn as decryptOwnedUtxo,
1435
- st as defaultIndexerUrl,
1436
+ Jt as createOutput,
1437
+ mt as decodeEvent,
1438
+ ft as decodeExecuteResult,
1439
+ ht as decodeResource,
1440
+ dt as decodeSubstateValue,
1441
+ pt as decodeTransactionReceipt,
1442
+ gt as decodeUtxo,
1443
+ gn as decryptInputData,
1444
+ _n as decryptOwnedUtxo,
1445
+ ut as defaultIndexerUrl,
1446
+ ct as estimatedFee,
1447
+ st as feesCharged,
1436
1448
  x as fromHexStr,
1437
- hn as generateOutputsStatement,
1438
- Ot as generateSealKeypair,
1439
- _t as getVaultIdsForAccount,
1449
+ vn as generateOutputsStatement,
1450
+ jt as generateSealKeypair,
1451
+ bt as getVaultIdsForAccount,
1440
1452
  Ne as intLiteral,
1441
1453
  G as isStealthTransferInstruction,
1442
- gt as iterVaultIdsInState,
1454
+ yt as iterVaultIdsInState,
1443
1455
  je as literalArg,
1444
1456
  Le as metadataLiteral,
1445
1457
  R as microTariLiteral,
1446
1458
  Ye as microTariString,
1447
1459
  Ue as nonFungibleAddressLiteral,
1448
- cn as parseSubstateUtxo,
1460
+ un as parseSubstateUtxo,
1449
1461
  Xe as parseWorkspaceStringKey,
1450
- vn as patchStealthStatement,
1462
+ xn as patchStealthStatement,
1451
1463
  He as publicKeyLiteral,
1452
1464
  J as resolveMainSigner,
1453
1465
  $e as resolveMaxEpoch,
1454
1466
  q as resolveTransaction,
1455
1467
  j as resourceAddressLiteral,
1456
1468
  Y as sealTransaction,
1457
- It as sendDryRun,
1458
- Ft as sendTransaction,
1469
+ zt as sendDryRun,
1470
+ Rt as sendTransaction,
1459
1471
  K as serializeUnsignedTx,
1460
- pn as signBalanceProof,
1461
- At as signTransaction,
1472
+ hn as signBalanceProof,
1473
+ Nt as signTransaction,
1462
1474
  W as statementAsWire,
1463
- Dt as stealthTransferInstruction,
1464
- nn as stealthUtxoSubstateId,
1475
+ At as stealthTransferInstruction,
1476
+ an as stealthUtxoSubstateId,
1465
1477
  Pe as stringLiteral,
1466
- Mt as submitTransaction,
1478
+ Ft as submitTransaction,
1467
1479
  ze as templateAddressLiteral,
1468
1480
  b as toHexStr,
1469
1481
  H as upSubstateValue,
1470
1482
  We as utxoAddressLiteral,
1471
1483
  Ve as validatorFeePoolAddressLiteral,
1472
1484
  Re as vaultIdLiteral,
1473
- Pt as watchTransaction
1485
+ Lt as watchTransaction
1474
1486
  };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@tari-project/ootle",
3
- "version": "0.16.0",
3
+ "version": "0.18.0",
4
4
  "repository": {
5
5
  "type": "git",
6
6
  "url": "git+https://github.com/tari-project/ootle.ts.git",
@@ -26,8 +26,8 @@
26
26
  },
27
27
  "dependencies": {
28
28
  "@tari-project/ootle-ts-bindings": "^1.65.0",
29
- "@tari-project/ootle-wasm": "^0.53.3",
30
- "@tari-project/ootle-wasm-bor": "^0.53.3"
29
+ "@tari-project/ootle-wasm": "^0.53.5",
30
+ "@tari-project/ootle-wasm-bor": "^0.53.5"
31
31
  },
32
32
  "devDependencies": {
33
33
  "@scure/sr25519": "^2.4.0",