@mysten/sui 2.12.1 → 2.13.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @mysten/sui.js
 
+## 2.13.0
+
+### Minor Changes
+
+- 329350a: Add `tx.coin()` and `tx.balance()` methods and rewrite CoinWithBalance intent resolution.
+  - `tx.coin({ type, balance })` — produces a `Coin<T>` of the requested balance, sourced from owned
+    coins and gas
+  - `tx.balance({ type, balance })` — produces a `Balance<T>` of the requested balance, sourced from
+    address balance or owned coins
+  - When balance intents are used, the merged pool remainder is converted to Balance and returned to
+    the sender's address balance via `send_funds`
+  - Multiple intents of the same coin type are now resolved with a single combined `SplitCoins`
+    instead of per-intent splits
+
+- 3c83909: Optimize transaction resolver to parallelize independent network requests (system state,
+  balance, coins, protocol config) and add coin reservation compat mode for address balance gas
+  payment when `coin_reservation` feature flag is enabled.
+
 ## 2.12.1
 
 ### Patch Changes

package/dist/bcs/bcs.d.mts

@@ -3,7 +3,6 @@ import * as _mysten_bcs830 from "@mysten/bcs";
 import { BcsType } from "@mysten/bcs";
 
 //#region src/bcs/bcs.d.ts
-
 declare const TypeTag: BcsType<string, string | TypeTag$1, string>;
 declare function IntentMessage<T extends BcsType<any>>(T: T): _mysten_bcs830.BcsStruct<{
   intent: _mysten_bcs830.BcsStruct<{

package/dist/bcs/bcs.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"bcs.d.mts","names":[],"sources":["../../src/bcs/bcs.ts"],"sourcesContent":[],"mappings":";;;;;;cAoIa,SAAO,yBAAA;iBAuKJ,wBAAwB,iBAAiB,mBAAC;;WAAA,cAAA,CAAA"}
+{"version":3,"file":"bcs.d.mts","names":[],"sources":["../../src/bcs/bcs.ts"],"mappings":";;;;;cAoIa,OAAA,EAAO,OAAA,kBAAA,SAAA;AAAA,iBAuKJ,aAAA,WAAwB,OAAA,MAAA,CAAc,CAAA,EAAG,CAAA,kBAAC,SAAA;;WAAA,cAAA,CAAA,OAAA"}

package/dist/bcs/index.d.mts

@@ -545,7 +545,7 @@ declare const suiBcs: {
           version: string;
           digest: string;
         };
-      }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
+      }, "Receiving" | "ImmOrOwnedObject" | "SharedObject">;
       FundsWithdrawal: {
         reservation: {
           MaxAmountU64: string;
@@ -560,7 +560,7 @@ declare const suiBcs: {
           Sponsor: true;
         }, "Sender" | "Sponsor">;
       };
-    }, "Pure" | "Object" | "FundsWithdrawal">[], Iterable<_mysten_bcs0.EnumInputShape<{
+    }, "Object" | "Pure" | "FundsWithdrawal">[], Iterable<_mysten_bcs0.EnumInputShape<{
       Pure: {
         bytes: string | Uint8Array<ArrayBufferLike>;
       };
@@ -793,7 +793,7 @@ declare const suiBcs: {
           TransactionEffects: true;
           CheckpointSummary: true;
           PersonalMessage: true;
-        }, "TransactionData" | "TransactionEffects" | "CheckpointSummary" | "PersonalMessage">;
+        }, "TransactionEffects" | "TransactionData" | "CheckpointSummary" | "PersonalMessage">;
         version: {
           V0: true;
           $kind: "V0";
@@ -827,7 +827,7 @@ declare const suiBcs: {
                     version: string;
                     digest: string;
                   };
-                }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
+                }, "Receiving" | "ImmOrOwnedObject" | "SharedObject">;
                 FundsWithdrawal: {
                   reservation: {
                     MaxAmountU64: string;
@@ -842,7 +842,7 @@ declare const suiBcs: {
                     Sponsor: true;
                   }, "Sender" | "Sponsor">;
                 };
-              }, "Pure" | "Object" | "FundsWithdrawal">[];
+              }, "Object" | "Pure" | "FundsWithdrawal">[];
               commands: _mysten_bcs0.EnumOutputShapeWithKeys<{
                 MoveCall: {
                   package: string;
@@ -950,7 +950,7 @@ declare const suiBcs: {
               chain: string;
               nonce: number;
             };
-          }, "None" | "Epoch" | "ValidDuring">;
+          }, "Epoch" | "None" | "ValidDuring">;
         };
         $kind: "V1";
       };
@@ -1193,7 +1193,7 @@ declare const suiBcs: {
                     version: string;
                     digest: string;
                   };
-                }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
+                }, "Receiving" | "ImmOrOwnedObject" | "SharedObject">;
                 FundsWithdrawal: {
                   reservation: {
                     MaxAmountU64: string;
@@ -1208,7 +1208,7 @@ declare const suiBcs: {
                     Sponsor: true;
                   }, "Sender" | "Sponsor">;
                 };
-              }, "Pure" | "Object" | "FundsWithdrawal">[], Iterable<_mysten_bcs0.EnumInputShape<{
+              }, "Object" | "Pure" | "FundsWithdrawal">[], Iterable<_mysten_bcs0.EnumInputShape<{
                 Pure: {
                   bytes: string | Uint8Array<ArrayBufferLike>;
                 };
@@ -1508,7 +1508,7 @@ declare const suiBcs: {
                 version: string;
                 digest: string;
               };
-            }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
+            }, "Receiving" | "ImmOrOwnedObject" | "SharedObject">;
             FundsWithdrawal: {
               reservation: {
                 MaxAmountU64: string;
@@ -1523,7 +1523,7 @@ declare const suiBcs: {
                 Sponsor: true;
               }, "Sender" | "Sponsor">;
             };
-          }, "Pure" | "Object" | "FundsWithdrawal">[], Iterable<_mysten_bcs0.EnumInputShape<{
+          }, "Object" | "Pure" | "FundsWithdrawal">[], Iterable<_mysten_bcs0.EnumInputShape<{
             Pure: {
               bytes: string | Uint8Array<ArrayBufferLike>;
             };
@@ -1799,7 +1799,7 @@ declare const suiBcs: {
               version: string;
               digest: string;
             };
-          }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
+          }, "Receiving" | "ImmOrOwnedObject" | "SharedObject">;
           FundsWithdrawal: {
             reservation: {
               MaxAmountU64: string;
@@ -1814,7 +1814,7 @@ declare const suiBcs: {
               Sponsor: true;
             }, "Sender" | "Sponsor">;
           };
-        }, "Pure" | "Object" | "FundsWithdrawal">[], Iterable<_mysten_bcs0.EnumInputShape<{
+        }, "Object" | "Pure" | "FundsWithdrawal">[], Iterable<_mysten_bcs0.EnumInputShape<{
           Pure: {
             bytes: string | Uint8Array<ArrayBufferLike>;
           };
@@ -2271,7 +2271,7 @@ declare const suiBcs: {
           startVersion: string;
           owner: string;
         };
-      }, "AddressOwner" | "ObjectOwner" | "Shared" | "Immutable" | "ConsensusAddressOwner">][], Iterable<readonly [{
+      }, "AddressOwner" | "ConsensusAddressOwner" | "Immutable" | "ObjectOwner" | "Shared">][], Iterable<readonly [{
         objectId: string | Uint8Array<ArrayBufferLike>;
         version: string | number | bigint;
         digest: string;
@@ -2304,7 +2304,7 @@ declare const suiBcs: {
           startVersion: string;
           owner: string;
         };
-      }, "AddressOwner" | "ObjectOwner" | "Shared" | "Immutable" | "ConsensusAddressOwner">][], Iterable<readonly [{
+      }, "AddressOwner" | "ConsensusAddressOwner" | "Immutable" | "ObjectOwner" | "Shared">][], Iterable<readonly [{
         objectId: string | Uint8Array<ArrayBufferLike>;
         version: string | number | bigint;
         digest: string;
@@ -2337,7 +2337,7 @@ declare const suiBcs: {
           startVersion: string;
           owner: string;
         };
-      }, "AddressOwner" | "ObjectOwner" | "Shared" | "Immutable" | "ConsensusAddressOwner">][], Iterable<readonly [{
+      }, "AddressOwner" | "ConsensusAddressOwner" | "Immutable" | "ObjectOwner" | "Shared">][], Iterable<readonly [{
         objectId: string | Uint8Array<ArrayBufferLike>;
         version: string | number | bigint;
         digest: string;
@@ -2604,7 +2604,7 @@ declare const suiBcs: {
               startVersion: string;
               owner: string;
             };
-          }, "AddressOwner" | "ObjectOwner" | "Shared" | "Immutable" | "ConsensusAddressOwner">];
+          }, "AddressOwner" | "ConsensusAddressOwner" | "Immutable" | "ObjectOwner" | "Shared">];
         }, "NotExist" | "Exist">;
         outputState: _mysten_bcs0.EnumOutputShapeWithKeys<{
           NotExist: true;
@@ -2619,7 +2619,7 @@ declare const suiBcs: {
               startVersion: string;
               owner: string;
             };
-          }, "AddressOwner" | "ObjectOwner" | "Shared" | "Immutable" | "ConsensusAddressOwner">];
+          }, "AddressOwner" | "ConsensusAddressOwner" | "Immutable" | "ObjectOwner" | "Shared">];
           PackageWrite: [string, string];
           AccumulatorWriteV1: {
             address: {
@@ -2705,7 +2705,7 @@ declare const suiBcs: {
         ReadConsensusStreamEnded: string;
         Cancelled: string;
         PerEpochConfig: true;
-      }, "ReadOnlyRoot" | "MutateConsensusStreamEnded" | "ReadConsensusStreamEnded" | "Cancelled" | "PerEpochConfig">][], Iterable<readonly [string | Uint8Array<ArrayBufferLike>, _mysten_bcs0.EnumInputShape<{
+      }, "MutateConsensusStreamEnded" | "PerEpochConfig" | "ReadConsensusStreamEnded" | "ReadOnlyRoot" | "Cancelled">][], Iterable<readonly [string | Uint8Array<ArrayBufferLike>, _mysten_bcs0.EnumInputShape<{
         ReadOnlyRoot: readonly [string | number | bigint, string];
         MutateConsensusStreamEnded: string | number | bigint;
         ReadConsensusStreamEnded: string | number | bigint;
@@ -2751,7 +2751,7 @@ declare const suiBcs: {
             version: string;
             digest: string;
           };
-        }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
+        }, "Receiving" | "ImmOrOwnedObject" | "SharedObject">;
         FundsWithdrawal: {
           reservation: {
             MaxAmountU64: string;
@@ -2766,7 +2766,7 @@ declare const suiBcs: {
             Sponsor: true;
           }, "Sender" | "Sponsor">;
         };
-      }, "Pure" | "Object" | "FundsWithdrawal">[], Iterable<_mysten_bcs0.EnumInputShape<{
+      }, "Object" | "Pure" | "FundsWithdrawal">[], Iterable<_mysten_bcs0.EnumInputShape<{
         Pure: {
           bytes: string | Uint8Array<ArrayBufferLike>;
         };

package/dist/bcs/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/bcs/index.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/bcs/index.ts"],"mappings":";;;;;;;;cA2DM,MAAA;MAkDL,YAAA,CAAA,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mQAQ22J,YAAA,CAAA,cAAA,2BAAA,CAAA,GAAA,CAAA,CAAA,GAAA,UAAA,YAAA,CAAA,OAAA,mBAAA,GAAA,4BAAA,CAAA,GAAA,CAAA,CAAA,GAAA,UAAA,YAAA,CAAA,OAAA,mBAAA,GAAA,YAAA,IAAA,IAAA,YAAA,CAAA,QAAA,CAAA,CAAA,EAAA,IAAA;kCAAA,YAAA,CAAA,OAAA"}

package/dist/bcs/pure.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pure.d.mts","names":[],"sources":["../../src/bcs/pure.ts"],"sourcesContent":[],"mappings":";;;KAQY,YAAA;UAYF,eAAA;EAZE,EAAA,EAAA,MAAA;EAYF,GAAA,EAAA,MAAA;EAaE,GAAA,EAAA,MAAA;EACA,GAAA,EAAA,MAAA,GAAA,MAAiB,GAAA,MAAA;EAAqB,IAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA;EAAU,IAAA,EAAA,MAAA,GAAA,MAAA,GAAA,MAAA;EACzD,IAAA,EAAA,OAAA;EACA,MAAA,EAAA,MAAA;EACmB,EAAA,EAAA,MAAA,GARR,UAQQ;EAAlB,OAAA,EAAA,MAAA,GAPe,UAOf;;AAEmB,KANX,YAAA,GAAe,YAMJ,GAAA,UAAA,MAAA,GAAA,GAAA,UAAA,MAAA,GAAA;AAAlB,KALO,iBAKP,CAAA,UAAA,MAAA,CAAA,GAL6C,CAK7C,SALuD,YAKvD,GAJF,YAIE,GAHF,CAGE,SAAA,UAAA,KAAA,EAAA,GAAA,GAFD,iBAEC,CAFiB,CAEjB,CAAA,GADD,CACC,SAAA,UAAA,KAAA,EAAA,GAAA,GAAA,iBAAA,CAAkB,CAAlB,CAAA,GACA,uBADA,CACwB,CADxB,CAAA;AACwB,KAEjB,qBAFiB,CAAA,UAEe,YAFf,CAAA,GAE+B,CAF/B,SAEyC,YAFzC,GAG1B,eAH0B,CAGV,CAHU,CAAA,GAI1B,CAJ0B,SAAA,UAAA,KAAA,WAIU,YAJV,GAAA,GAKzB,qBALyB,CAKH,CALG,CAAA,EAAA,GAMzB,CANyB,SAAA,UAAA,KAAA,WAMW,YANX,GAAA,GAOxB,qBAPwB,CAOF,CAPE,CAAA,GAAA,IAAA,GAAA,KAAA;KAUxB,uBAVA,CAAA,UAAA,MAAA,CAAA,GAAA;EAAuB,KAAA,EAAA,2BAWO,CAXP,EAAA;AAE5B,CAAA,GAAY,CAAA,CAAA;AAAgC,iBAY5B,yBAZ4B,CAAA,UAYQ,YAZR,CAAA,CAAA,IAAA,EAarC,CAbqC,SAa3B,YAb2B,GAaZ,iBAbY,CAaM,CAbN,CAAA,GAaW,CAbX,CAAA,EAczC,OAdyC,CAcjC,qBAdiC,CAcX,CAdW,CAAA,CAAA"}
+{"version":3,"file":"pure.d.mts","names":[],"sources":["../../src/bcs/pure.ts"],"mappings":";;;KAQY,YAAA;AAAA,UAYF,eAAA;EACT,EAAA;EACA,GAAA;EACA,GAAA;EACA,GAAA;EACA,IAAA;EACA,IAAA;EACA,IAAA;EACA,MAAA;EACA,EAAA,WAAa,UAAA;EACb,OAAA,WAAkB,UAAA;AAAA;AAAA,KAGP,YAAA,GAAe,YAAA;AAAA,KACf,iBAAA,qBAAsC,CAAA,SAAU,YAAA,GACzD,YAAA,GACA,CAAA,gCACC,iBAAA,CAAkB,CAAA,IAClB,CAAA,gCACC,iBAAA,CAAkB,CAAA,IAClB,uBAAA,CAAwB,CAAA;AAAA,KAEjB,qBAAA,WAAgC,YAAA,IAAgB,CAAA,SAAU,YAAA,GACnE,eAAA,CAAgB,CAAA,IAChB,CAAA,mCAAoC,YAAA,MACnC,qBAAA,CAAsB,CAAA,MACtB,CAAA,mCAAoC,YAAA,MACnC,qBAAA,CAAsB,CAAA;AAAA,KAGtB,uBAAA;EACJ,KAAA,6BAAkC,CAAA;AAAA;AAAA,iBAGnB,yBAAA,WAAoC,YAAA,CAAA,CACnD,IAAA,EAAM,CAAA,SAAU,YAAA,GAAe,iBAAA,CAAkB,CAAA,IAAK,CAAA,GACpD,OAAA,CAAQ,qBAAA,CAAsB,CAAA"}

package/dist/bcs/type-tag-serializer.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"type-tag-serializer.d.mts","names":[],"sources":["../../src/bcs/type-tag-serializer.ts"],"sourcesContent":[],"mappings":";;;cAWa,iBAAA;gEACgD;EADhD,OAAA,mBAAiB,CAAA,GAAA,EAAA,MAAA,EAAA,gBAAA,CAAA,EAAA,OAAA,CAAA,EAgDsC,OAhDtC,EAAA;EAC+B,OAAA,WAAA,CAAA,GAAA,EAqDpC,OArDoC,CAAA,EAAA,MAAA;;AAqDpC,iBA0CT,gBAAA,CA1CS,IAAA,EAAA,MAAA,CAAA,EAAA,MAAA"}
+{"version":3,"file":"type-tag-serializer.d.mts","names":[],"sources":["../../src/bcs/type-tag-serializer.ts"],"mappings":";;;cAWa,iBAAA;EAAA,OACL,YAAA,CAAa,GAAA,UAAa,gBAAA,aAA2B,OAAA;EAAA,OA+CrD,mBAAA,CAAoB,GAAA,UAAa,gBAAA,aAA2B,OAAA;EAAA,OAM5D,WAAA,CAAY,GAAA,EAAK,OAAA;AAAA;AAAA,iBA0CT,gBAAA,CAAiB,IAAA"}

package/dist/bcs/types.d.mts

@@ -1,5 +1,4 @@
 //#region src/bcs/types.d.ts
-
 /**
  * Kind of a TypeTag which is represented by a Move type identifier.
  */

package/dist/bcs/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/bcs/types.ts"],"sourcesContent":[],"mappings":";;;;;KAoFY,SAAA;;;;cAIC;;;;;KAMD,OAAA;;;;;;;;;;;;;UAOC;;UACA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/bcs/types.ts"],"mappings":";;;;KAoFY,SAAA;EACX,OAAA;EACA,MAAA;EACA,IAAA;EACA,UAAA,EAAY,OAAA;AAAA;;;;KAMD,OAAA;EACP,IAAA;AAAA;EACA,EAAA;AAAA;EACA,GAAA;AAAA;EACA,IAAA;AAAA;EACA,OAAA;AAAA;EACA,MAAA;AAAA;EACA,MAAA,EAAQ,OAAA;AAAA;EACR,MAAA,EAAQ,SAAA;AAAA;EACR,GAAA;AAAA;EACA,GAAA;AAAA;EACA,IAAA;AAAA"}

package/dist/client/cache.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.mts","names":[],"sources":["../../src/client/cache.ts"],"sourcesContent":[],"mappings":";UAGiB,kBAAA;EAAA,MAAA,CAAA,EAAA,MAAA,EAAA;EAKJ,KAAA,CAAA,EAHJ,GAGI,CAAA,MAAW,EAAA,OAAA,CAAA;;AAID,cAJV,WAAA,CAIU;EAAS,CAAA,OAAA;EAKiB,WAAA,CAAA;IAAA,MAAA;IAAA;EAAA,CAAA,CAAA,EALjB,kBAKiB;EAAY,IAAA,CAAA,CAAA,CAAA,CAAA,GAAA,EAAA,CAAA,MAAA,EAAA,GAAA,MAAA,EAAA,CAAA,EAAA,IAAA,EAAA,GAAA,GAAZ,CAAY,GAAR,OAAQ,CAAA,CAAA,CAAA,CAAA,EAAK,CAAL,GAAS,OAAT,CAAiB,CAAjB,CAAA;EAAR,QAAA,CAAA,CAAA,CAAA,CAAA,GAAA,EAAA,CAAA,MAAA,EAAA,GAAA,MAAA,EAAA,CAAA,EAAA,IAAA,EAAA,GAAA,GA0BA,CA1BA,CAAA,EA0BI,CA1BJ;EAAa,KAAA,CAAA,MAAA,CAAA,EAAA,MAAA,EAAA,CAAA,EAAA,IAAA;EAAY,KAAA,CAAA,MAAA,EAAA,MAAA,GAAA,MAAA,EAAA,CAAA,EAsD9C,WAtD8C"}
+{"version":3,"file":"cache.d.mts","names":[],"sources":["../../src/client/cache.ts"],"mappings":";UAGiB,kBAAA;EAChB,MAAA;EACA,KAAA,GAAQ,GAAA;AAAA;AAAA,cAGI,WAAA;EAAA;;IAIE,MAAA;IAAQ;EAAA,IAAS,kBAAA;EAK/B,IAAA,GAAA,CAAQ,GAAA,yBAA4B,IAAA,QAAY,CAAA,GAAI,OAAA,CAAQ,CAAA,IAAK,CAAA,GAAI,OAAA,CAAQ,CAAA;EA0B7E,QAAA,GAAA,CAAY,GAAA,yBAA4B,IAAA,QAAY,CAAA,GAAI,CAAA;EAcxD,KAAA,CAAM,MAAA;EAcN,KAAA,CAAM,MAAA,sBAAyB,WAAA;AAAA"}

package/dist/client/client.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.mts","names":[],"sources":["../../src/client/client.ts"],"sourcesContent":[],"mappings":";;;;;;uBAQsB,UAAA;WACZ,cAAA,CAAe;EADH,KAAA,EAEd,WAFwB;EACtB,IAAA,EAEH,UAFkB;EACjB,WAAA,CAAA;IAAA,OAAA;IAAA,IAAA;IAAA;EAAA,CAAA,EAOJ,cAAA,CAAe,gBAPX;EACD,SAAA,IAAA,EAYS,UAZT;EAGL,OAAA,CAAA,4BAWmC,qBAXnC,CAAA,IAAA,CAAA,EAAA,CAAA,CAAA,GAAA,aAAA,EAYkB,aAZlB,CAAA,EAuCM,oBAvCN,CAwCC,QAxCD,CAyCE,mBAzCF,CAAA,QAAA,MA2CgB,aA3ChB,GA2CgC,aA3ChC,CA2C8C,CA3C9C,CAAA,SA2CyD,qBA3CzD,CAAA,IAAA,EAAA,KAAA,cAAA,MAAA,EAAA,KAAA,UAAA,CAAA,GAAA,SAiDc,IAjDd,GAiDqB,SAjDrB,EAAA,GAAA,KAAA,EAAA,CAAA,MAAA,CAAA,CAAA,CAAA,EAAA,IAAA,CAAA"}
+{"version":3,"file":"client.d.mts","names":[],"sources":["../../src/client/client.ts"],"mappings":";;;;;;uBAQsB,UAAA;EACrB,OAAA,EAAS,cAAA,CAAe,OAAA;EACxB,KAAA,EAAO,WAAA;EACP,IAAA,EAAM,UAAA;;IAGL,OAAA;IACA,IAAA;IACA;EAAA,GACE,cAAA,CAAe,gBAAA;EAAA,SAMT,IAAA,EAAM,UAAA;EAEf,OAAA,6BAAoC,qBAAA,SAAA,CAAA,GAChC,aAAA,EAAe,aAAA,GA2BZ,oBAAA,CACL,QAAA,CACC,mBAAA,eAEc,aAAA,GAAgB,aAAA,CAAc,CAAA,UAAW,qBAAA,8DAM3C,IAAA,GAAO,SAAA;AAAA"}

package/dist/client/core-resolver.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"core-resolver.d.mts","names":[],"sources":["../../src/client/core-resolver.ts"],"sourcesContent":[],"mappings":";;;;;iBAiCsB,kCAAA,kBACJ,iCACR,qCACG,gBAAa"}
+{"version":3,"file":"core-resolver.d.mts","names":[],"sources":["../../src/client/core-resolver.ts"],"mappings":";;;;;iBAoCsB,kCAAA,CACrB,eAAA,EAAiB,sBAAA,EACjB,OAAA,EAAS,uBAAA,EACT,IAAA,QAAY,OAAA,SAAa,OAAA"}

package/dist/client/core-resolver.mjs

@@ -1,11 +1,10 @@
-import { normalizeSuiAddress, normalizeSuiObjectId } from "../utils/sui-types.mjs";
-import { ObjectRefSchema } from "../transactions/data/internal.mjs";
+import { normalizeStructTag, normalizeSuiAddress, normalizeSuiObjectId } from "../utils/sui-types.mjs";
 import { SimulationError } from "./errors.mjs";
 import { SUI_TYPE_ARG } from "../utils/constants.mjs";
+import { createCoinReservationRef } from "../utils/coin-reservation.mjs";
 import { Inputs } from "../transactions/Inputs.mjs";
 import { getPureBcsSchema, isTxContext } from "../transactions/serializer.mjs";
 import { chunk } from "@mysten/utils";
-import { parse } from "valibot";
 
 //#region src/client/core-resolver.ts
 const MAX_OBJECTS_PER_FETCH = 50;
@@ -17,20 +16,56 @@ function getClient(options) {
 }
 async function coreClientResolveTransactionPlugin(transactionData, options, next) {
 	const client = getClient(options);
-	await normalizeInputs(transactionData, client);
+	const needsGasPrice = !options.onlyTransactionKind && !transactionData.gasData.price;
+	const needsPayment = !options.onlyTransactionKind && !transactionData.gasData.payment;
+	const gasPayer = transactionData.gasData.owner ?? transactionData.sender;
+	let usesGasCoin = false;
+	let withdrawals = 0n;
+	transactionData.mapArguments((arg) => {
+		if (arg.$kind === "GasCoin") usesGasCoin = true;
+		return arg;
+	});
+	const normalizedGasPayer = gasPayer ? normalizeSuiAddress(gasPayer) : null;
+	for (const input of transactionData.inputs) {
+		if (input.$kind !== "FundsWithdrawal" || !normalizedGasPayer) continue;
+		if (normalizeStructTag(input.FundsWithdrawal.typeArg.Balance) !== SUI_TYPE_ARG) continue;
+		const withdrawalOwner = input.FundsWithdrawal.withdrawFrom.Sender ? transactionData.sender : gasPayer;
+		if (withdrawalOwner && normalizeSuiAddress(withdrawalOwner) === normalizedGasPayer && input.FundsWithdrawal.reservation.$kind === "MaxAmountU64") withdrawals += BigInt(input.FundsWithdrawal.reservation.MaxAmountU64);
+	}
+	const needsSystemState = needsGasPrice || needsPayment && usesGasCoin;
+	const [, systemStateResult, balanceResult, coinsResult, protocolConfigResult, chainIdResult] = await Promise.all([
+		normalizeInputs(transactionData, client),
+		needsSystemState ? client.core.getCurrentSystemState() : null,
+		needsPayment && gasPayer ? client.core.getBalance({ owner: gasPayer }) : null,
+		needsPayment && gasPayer ? client.core.listCoins({
+			owner: gasPayer,
+			coinType: SUI_TYPE_ARG
+		}) : null,
+		needsPayment && usesGasCoin ? client.core.getProtocolConfig() : null,
+		needsPayment && usesGasCoin ? client.core.getChainIdentifier() : null
+	]);
 	await resolveObjectReferences(transactionData, client);
-	if (!options.onlyTransactionKind) await setGasData(transactionData, client);
-	return await next();
-}
-async function setGasData(transactionData, client) {
-	let systemState = null;
-	if (!transactionData.gasData.price) {
-		systemState = (await client.core.getCurrentSystemState()).systemState;
-		transactionData.gasData.price = systemState.referenceGasPrice;
+	if (!options.onlyTransactionKind) {
+		const systemState = systemStateResult?.systemState ?? null;
+		if (systemState && !transactionData.gasData.price) transactionData.gasData.price = systemState.referenceGasPrice;
+		await setGasBudget(transactionData, client);
+		if (needsPayment) {
+			if (!balanceResult || !coinsResult) throw new Error("Could not resolve gas payment: a gas owner or sender must be set to fetch balance and coins.");
+			setGasPayment({
+				transactionData,
+				balance: balanceResult,
+				coins: coinsResult,
+				usesGasCoin,
+				withdrawals,
+				protocolConfig: protocolConfigResult?.protocolConfig,
+				gasPayer,
+				chainIdentifier: chainIdResult?.chainIdentifier ?? null,
+				epoch: systemState?.epoch ?? null
+			});
+		}
+		if (!transactionData.expiration && transactionData.gasData.payment?.length === 0) await setExpiration(transactionData, client, systemState, chainIdResult?.chainIdentifier ?? null);
 	}
-	await setGasBudget(transactionData, client);
-	await setGasPayment(transactionData, client);
-	if (!transactionData.expiration) await setExpiration(transactionData, client, systemState);
+	return await next();
 }
 async function setGasBudget(transactionData, client) {
 	if (transactionData.gasData.budget) return;
@@ -54,52 +89,32 @@ async function setGasBudget(transactionData, client) {
 	const gasBudget = baseComputationCostWithOverhead + BigInt(gasUsed.storageCost) - BigInt(gasUsed.storageRebate);
 	transactionData.gasData.budget = String(gasBudget > baseComputationCostWithOverhead ? gasBudget : baseComputationCostWithOverhead);
 }
-async function setGasPayment(transactionData, client) {
-	if (!transactionData.gasData.payment) {
-		const gasPayer = transactionData.gasData.owner ?? transactionData.sender;
-		if (!gasPayer) throw new Error("Either a gas owner or sender must be set to determine gas payment.");
-		const normalizedGasPayer = normalizeSuiAddress(gasPayer);
-		let usesGasCoin = false;
-		let withdrawals = 0n;
-		transactionData.mapArguments((arg) => {
-			if (arg.$kind === "GasCoin") usesGasCoin = true;
-			else if (arg.$kind === "Input") {
-				const input = transactionData.inputs[arg.Input];
-				if (input.$kind === "FundsWithdrawal") {
-					const withdrawalOwner = input.FundsWithdrawal.withdrawFrom.Sender ? transactionData.sender : gasPayer;
-					if (withdrawalOwner && normalizeSuiAddress(withdrawalOwner) === normalizedGasPayer) {
-						if (input.FundsWithdrawal.reservation.$kind === "MaxAmountU64") withdrawals += BigInt(input.FundsWithdrawal.reservation.MaxAmountU64);
-					}
-				}
-			}
-			return arg;
-		});
-		const [suiBalance, coins] = await Promise.all([usesGasCoin ? null : client.core.getBalance({ owner: gasPayer }), client.core.listCoins({
-			owner: gasPayer,
-			coinType: SUI_TYPE_ARG
-		})]);
-		if (suiBalance?.balance.addressBalance && BigInt(suiBalance.balance.addressBalance) >= BigInt(transactionData.gasData.budget || "0") + withdrawals) {
-			transactionData.gasData.payment = [];
-			return;
-		}
-		const paymentCoins = coins.objects.filter((coin) => {
-			return !transactionData.inputs.find((input) => {
-				if (input.Object?.ImmOrOwnedObject) return coin.objectId === input.Object.ImmOrOwnedObject.objectId;
-				return false;
-			});
-		}).map((coin) => parse(ObjectRefSchema, {
-			objectId: coin.objectId,
-			digest: coin.digest,
-			version: coin.version
-		}));
-		if (!paymentCoins.length) throw new Error("No valid gas coins found for the transaction.");
-		transactionData.gasData.payment = paymentCoins;
+function setGasPayment({ transactionData, balance, coins, usesGasCoin, withdrawals, protocolConfig, gasPayer, chainIdentifier, epoch }) {
+	const budget = BigInt(transactionData.gasData.budget);
+	const addressBalance = BigInt(balance.balance.addressBalance);
+	if (budget === 0n || !usesGasCoin && addressBalance >= budget + withdrawals) {
+		transactionData.gasData.payment = [];
+		return;
 	}
+	const filteredCoins = coins.objects.filter((coin) => {
+		return !transactionData.inputs.find((input) => {
+			if (input.Object?.ImmOrOwnedObject) return coin.objectId === input.Object.ImmOrOwnedObject.objectId;
+			return false;
+		});
+	});
+	const paymentCoins = filteredCoins.map((coin) => ({
+		objectId: coin.objectId,
+		digest: coin.digest,
+		version: coin.version
+	}));
+	const reservationAmount = addressBalance - withdrawals;
+	if (usesGasCoin && reservationAmount > 0n && protocolConfig?.featureFlags?.["enable_coin_reservation_obj_refs"] && chainIdentifier && epoch) transactionData.gasData.payment = [createCoinReservationRef(reservationAmount, gasPayer, chainIdentifier, epoch), ...paymentCoins];
+	else if (!filteredCoins.length) throw new Error("No valid gas coins found for the transaction.");
+	else transactionData.gasData.payment = paymentCoins;
 }
-async function setExpiration(transactionData, client, existingSystemState) {
-	if (transactionData.expiration || hasVersionedInputs(transactionData)) return;
-	const [systemState, { chainIdentifier }] = await Promise.all([existingSystemState ?? client.core.getCurrentSystemState().then((r) => r.systemState), client.core.getChainIdentifier()]);
-	const currentEpoch = BigInt(systemState.epoch);
+async function setExpiration(transactionData, client, systemState, existingChainIdentifier = null) {
+	const [chainIdentifier, resolvedSystemState] = await Promise.all([existingChainIdentifier ?? client.core.getChainIdentifier().then((r) => r.chainIdentifier), systemState ?? client.core.getCurrentSystemState().then((r) => r.systemState)]);
+	const currentEpoch = BigInt(resolvedSystemState.epoch);
 	transactionData.expiration = {
 		$kind: "ValidDuring",
 		ValidDuring: {
@@ -112,10 +127,6 @@ async function setExpiration(transactionData, client, existingSystemState) {
 		}
 	};
 }
-function hasVersionedInputs(transactionData) {
-	if (transactionData.gasData.payment?.length) return true;
-	return transactionData.inputs.some((input) => input.Object?.ImmOrOwnedObject || input.UnresolvedObject && input.UnresolvedObject.version);
-}
 async function resolveObjectReferences(transactionData, client) {
 	const objectsToResolve = transactionData.inputs.filter((input) => {
 		return input.UnresolvedObject && !(input.UnresolvedObject.version || input.UnresolvedObject?.initialSharedVersion);
@@ -128,14 +139,14 @@ async function resolveObjectReferences(transactionData, client) {
 	}));
 	const invalidObjects = Array.from(responsesById).filter(([_, obj]) => obj instanceof Error).map(([_, obj]) => obj.message);
 	if (invalidObjects.length) throw new Error(`The following input objects are invalid: ${invalidObjects.join(", ")}`);
-	const objects = resolved.map((object$1) => {
-		if (object$1 instanceof Error) throw new Error(`Failed to fetch object: ${object$1.message}`);
-		const owner = object$1.owner;
+	const objects = resolved.map((object) => {
+		if (object instanceof Error) throw new Error(`Failed to fetch object: ${object.message}`);
+		const owner = object.owner;
 		const initialSharedVersion = owner && typeof owner === "object" ? owner.$kind === "Shared" ? owner.Shared.initialSharedVersion : owner.$kind === "ConsensusAddressOwner" ? owner.ConsensusAddressOwner.startVersion : null : null;
 		return {
-			objectId: object$1.objectId,
-			digest: object$1.digest,
-			version: object$1.version,
+			objectId: object.objectId,
+			digest: object.digest,
+			version: object.version,
 			initialSharedVersion
 		};
 	});
@@ -146,21 +157,21 @@ async function resolveObjectReferences(transactionData, client) {
 		if (!input.UnresolvedObject) continue;
 		let updated;
 		const id = normalizeSuiAddress(input.UnresolvedObject.objectId);
-		const object$1 = objectsById.get(id);
-		if (input.UnresolvedObject.initialSharedVersion ?? object$1?.initialSharedVersion) updated = Inputs.SharedObjectRef({
+		const object = objectsById.get(id);
+		if (input.UnresolvedObject.initialSharedVersion ?? object?.initialSharedVersion) updated = Inputs.SharedObjectRef({
 			objectId: id,
-			initialSharedVersion: input.UnresolvedObject.initialSharedVersion || object$1?.initialSharedVersion,
+			initialSharedVersion: input.UnresolvedObject.initialSharedVersion || object?.initialSharedVersion,
 			mutable: input.UnresolvedObject.mutable || isUsedAsMutable(transactionData, index)
 		});
 		else if (isUsedAsReceiving(transactionData, index)) updated = Inputs.ReceivingRef({
 			objectId: id,
-			digest: input.UnresolvedObject.digest ?? object$1?.digest,
-			version: input.UnresolvedObject.version ?? object$1?.version
+			digest: input.UnresolvedObject.digest ?? object?.digest,
+			version: input.UnresolvedObject.version ?? object?.version
 		});
 		transactionData.inputs[transactionData.inputs.indexOf(input)] = updated ?? Inputs.ObjectRef({
 			objectId: id,
-			digest: input.UnresolvedObject.digest ?? object$1?.digest,
-			version: input.UnresolvedObject.version ?? object$1?.version
+			digest: input.UnresolvedObject.digest ?? object?.digest,
+			version: input.UnresolvedObject.version ?? object?.version
 		});
 	}
 }