aftermath-ts-sdk 3.1.1-dev.3618bb3 → 3.1.1

package/dist/index.d.ts

@@ -14737,21 +14737,7 @@ declare class CoinApi {
         walletAddress: SuiAddress;
         coinType: CoinType;
     }) => Promise<CoinStruct[]>;
-    /**
-     * Checks the wallet's TOTAL balance (owned coins + SIP-58 address balance)
-     * covers `coinAmount`, throwing the canonical insufficient-balance error
-     * otherwise. `coinWithBalance` can source from both, so this is the correct
-     * spendability check for the non-sponsored path.
-     */
-    private assertSufficientTotalBalance;
-    /**
-     * Owned-coin arg for the sponsored path: merge the selected coins and split
-     * the amount without touching `tx.gas` (that's the sponsor's coin) and via
-     * raw commands only, since the tx is serialized unbuilt. `coinData` comes
-     * from `fetchCoinsWithAtLeastAmount`, which guarantees it covers
-     * `coinAmount`.
-     */
-    private static sponsoredCoinWithAmountTx;
+    private static coinWithAmountTx;
 }
 
 declare class DcaApi {

package/dist/index.js

@@ -15980,9 +15980,6 @@ var init_wallet = __esm({
 });
 
 // src/packages/coin/api/coinApi.ts
-import {
-  coinWithBalance
-} from "@mysten/sui/transactions";
 var MAX_COIN_FETCH_PAGES, _CoinApi, CoinApi;
 var init_coinApi = __esm({
   "src/packages/coin/api/coinApi.ts"() {
@@ -15990,6 +15987,7 @@ var init_coinApi = __esm({
     init_transactionsApiHelpers();
     init_grpcCasting();
     init_helpers();
+    init_coin();
     MAX_COIN_FETCH_PAGES = 50;
     _CoinApi = class _CoinApi {
       // =========================================================================
@@ -16003,41 +16001,51 @@ var init_coinApi = __esm({
         this.fetchCoinWithAmountTx = async (inputs) => {
           const { tx, walletAddress, coinType, coinAmount, isSponsoredTx } = inputs;
           tx.setSender(walletAddress);
-          if (isSponsoredTx) {
-            const coinData = await this.fetchCoinsWithAtLeastAmount(inputs);
-            return _CoinApi.sponsoredCoinWithAmountTx({
-              tx,
-              coinData,
-              coinAmount,
-              coinType
-            });
-          }
-          await this.assertSufficientTotalBalance(inputs);
-          return coinWithBalance({ type: coinType, balance: coinAmount })(tx);
+          const coinData = await this.fetchCoinsWithAtLeastAmount(inputs);
+          return _CoinApi.coinWithAmountTx({
+            tx,
+            coinData,
+            coinAmount,
+            coinType,
+            isSponsoredTx
+          });
         };
         this.fetchCoinsWithAmountTx = async (inputs) => {
-          const { coinTypes, coinAmounts } = inputs;
-          const coinArgs = [];
-          for (const [index, coinType] of coinTypes.entries()) {
-            coinArgs.push(
-              await this.fetchCoinWithAmountTx({
+          const { tx, walletAddress, coinTypes, coinAmounts, isSponsoredTx } = inputs;
+          tx.setSender(walletAddress);
+          const allCoinsData = await Promise.all(
+            coinTypes.map(
+              async (coinType, index) => this.fetchCoinsWithAtLeastAmount({
                 ...inputs,
-                coinType,
-                coinAmount: coinAmounts[index]
+                coinAmount: coinAmounts[index],
+                coinType
               })
-            );
+            )
+          );
+          let coinArgs = [];
+          for (const [index, coinData] of allCoinsData.entries()) {
+            const coinArg = _CoinApi.coinWithAmountTx({
+              tx,
+              coinData,
+              coinAmount: coinAmounts[index],
+              coinType: coinTypes[index],
+              isSponsoredTx
+            });
+            coinArgs = [...coinArgs, coinArg];
           }
           return coinArgs;
         };
         this.fetchCoinsWithAtLeastAmount = async (inputs) => {
           const allCoinData = [];
           let cursor;
-          for (let page = 0; page < MAX_COIN_FETCH_PAGES; page++) {
+          let pages = 0;
+          do {
             const paginatedCoins = await this.api.client.listCoins({
               coinType: inputs.coinType,
               owner: inputs.walletAddress,
               cursor
             });
+            pages += 1;
             allCoinData.push(
               ...paginatedCoins.objects.map(GrpcCasting.coinStructFromGrpcCoin)
             );
@@ -16054,10 +16062,15 @@ var init_coinApi = __esm({
             if (paginatedCoins.objects.length === 0 || !paginatedCoins.hasNextPage || !paginatedCoins.cursor) {
               throw new Error("wallet does not have coins of sufficient balance");
             }
+            if (pages >= MAX_COIN_FETCH_PAGES) {
+              throw new Error(
+                "wallet balance is spread across too many coin objects"
+              );
+            }
             cursor = paginatedCoins.cursor;
-          }
-          throw new Error("wallet balance is spread across too many coin objects");
+          } while (true);
         };
+        // fetchCoinsUntilAmountReachedOrEnd
         this.fetchAllCoins = async (inputs) => {
           const allCoinData = [];
           let cursor;
@@ -16070,63 +16083,67 @@ var init_coinApi = __esm({
             allCoinData.push(
               ...paginatedCoins.objects.map(GrpcCasting.coinStructFromGrpcCoin)
             );
-            cursor = paginatedCoins.objects.length > 0 && paginatedCoins.hasNextPage && paginatedCoins.cursor ? paginatedCoins.cursor : void 0;
-          } while (cursor !== void 0);
-          return allCoinData.sort(
-            (b, a) => Number(BigInt(b.coinObjectId) - BigInt(a.coinObjectId))
-          );
-        };
-        // =========================================================================
-        //  Private Helpers
-        // =========================================================================
-        /**
-         * Checks the wallet's TOTAL balance (owned coins + SIP-58 address balance)
-         * covers `coinAmount`, throwing the canonical insufficient-balance error
-         * otherwise. `coinWithBalance` can source from both, so this is the correct
-         * spendability check for the non-sponsored path.
-         */
-        this.assertSufficientTotalBalance = async (inputs) => {
-          const { balance } = await this.api.client.getBalance({
-            owner: inputs.walletAddress,
-            coinType: Helpers.stripLeadingZeroesFromType(inputs.coinType)
-          });
-          if (BigInt(balance.balance) < inputs.coinAmount) {
-            throw new Error("wallet does not have coins of sufficient balance");
-          }
+            if (paginatedCoins.objects.length === 0 || !paginatedCoins.hasNextPage || !paginatedCoins.cursor) {
+              return allCoinData.sort(
+                (b, a) => Number(BigInt(b.coinObjectId) - BigInt(a.coinObjectId))
+              );
+            }
+            cursor = paginatedCoins.cursor;
+          } while (true);
         };
       }
     };
     // =========================================================================
     //  Private Static Methods
     // =========================================================================
-    /**
-     * Owned-coin arg for the sponsored path: merge the selected coins and split
-     * the amount without touching `tx.gas` (that's the sponsor's coin) and via
-     * raw commands only, since the tx is serialized unbuilt. `coinData` comes
-     * from `fetchCoinsWithAtLeastAmount`, which guarantees it covers
-     * `coinAmount`.
-     */
-    _CoinApi.sponsoredCoinWithAmountTx = (inputs) => {
-      const { tx, coinData, coinAmount, coinType } = inputs;
+    _CoinApi.coinWithAmountTx = (inputs) => {
+      const { tx, coinData, coinAmount, coinType, isSponsoredTx } = inputs;
+      if (coinData.length <= 0) {
+        throw new Error("wallet does not have coins of sufficient balance");
+      }
+      const isSuiCoin = Coin.isSuiCoin(coinData[0].coinType);
+      const totalCoinBalance = Helpers.sumBigInt(
+        coinData.map((data) => BigInt(data.balance))
+      );
+      if (totalCoinBalance < coinAmount) {
+        throw new Error("wallet does not have coins of sufficient balance");
+      }
+      if (!isSponsoredTx && isSuiCoin) {
+        tx.setGasPayment(
+          coinData.map((obj) => {
+            return {
+              ...obj,
+              objectId: obj.coinObjectId
+            };
+          })
+        );
+        return tx.splitCoins(tx.gas, [coinAmount]);
+      }
       const coinObjectIds = coinData.map((data) => data.coinObjectId);
       const mergedCoinObjectId = coinObjectIds[0];
       if (coinObjectIds.length > 1) {
-        tx.add({
-          $kind: "MergeCoins",
-          MergeCoins: {
-            destination: tx.object(mergedCoinObjectId),
-            sources: [
-              ...coinObjectIds.slice(1).map((coinId) => tx.object(coinId))
-            ]
-          }
-        });
+        if (isSponsoredTx) {
+          tx.add({
+            $kind: "MergeCoins",
+            MergeCoins: {
+              destination: tx.object(mergedCoinObjectId),
+              sources: [
+                ...coinObjectIds.slice(1).map((coinId) => tx.object(coinId))
+              ]
+            }
+          });
+        } else {
+          tx.mergeCoins(tx.object(mergedCoinObjectId), [
+            ...coinObjectIds.slice(1).map((coinId) => tx.object(coinId))
+          ]);
+        }
       }
-      return TransactionsApiHelpers.splitCoinTx({
+      return isSponsoredTx ? TransactionsApiHelpers.splitCoinTx({
         tx,
         coinId: mergedCoinObjectId,
         amount: coinAmount,
         coinType
-      });
+      }) : tx.splitCoins(mergedCoinObjectId, [coinAmount]);
     };
     CoinApi = _CoinApi;
   }