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

package/dist/index.d.ts

@@ -14737,7 +14737,21 @@ declare class CoinApi {
         walletAddress: SuiAddress;
         coinType: CoinType;
     }) => Promise<CoinStruct[]>;
-    private static coinWithAmountTx;
+    /**
+     * 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;
 }
 
 declare class DcaApi {

package/dist/index.js

@@ -15980,14 +15980,17 @@ var init_wallet = __esm({
 });
 
 // src/packages/coin/api/coinApi.ts
-var _CoinApi, CoinApi;
+import {
+  coinWithBalance
+} from "@mysten/sui/transactions";
+var MAX_COIN_FETCH_PAGES, _CoinApi, CoinApi;
 var init_coinApi = __esm({
   "src/packages/coin/api/coinApi.ts"() {
     "use strict";
     init_transactionsApiHelpers();
     init_grpcCasting();
     init_helpers();
-    init_coin();
+    MAX_COIN_FETCH_PAGES = 50;
     _CoinApi = class _CoinApi {
       // =========================================================================
       //  Constructor
@@ -16000,74 +16003,63 @@ var init_coinApi = __esm({
         this.fetchCoinWithAmountTx = async (inputs) => {
           const { tx, walletAddress, coinType, coinAmount, isSponsoredTx } = inputs;
           tx.setSender(walletAddress);
-          const coinData = await this.fetchCoinsWithAtLeastAmount(inputs);
-          return _CoinApi.coinWithAmountTx({
-            tx,
-            coinData,
-            coinAmount,
-            coinType,
-            isSponsoredTx
-          });
+          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);
         };
         this.fetchCoinsWithAmountTx = async (inputs) => {
-          const { tx, walletAddress, coinTypes, coinAmounts, isSponsoredTx } = inputs;
-          tx.setSender(walletAddress);
-          const allCoinsData = await Promise.all(
-            coinTypes.map(
-              async (coinType, index) => this.fetchCoinsWithAtLeastAmount({
+          const { coinTypes, coinAmounts } = inputs;
+          const coinArgs = [];
+          for (const [index, coinType] of coinTypes.entries()) {
+            coinArgs.push(
+              await this.fetchCoinWithAmountTx({
                 ...inputs,
-                coinAmount: coinAmounts[index],
-                coinType
+                coinType,
+                coinAmount: coinAmounts[index]
               })
-            )
-          );
-          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) => {
-          let allCoinData = [];
+          const allCoinData = [];
           let cursor;
-          do {
+          for (let page = 0; page < MAX_COIN_FETCH_PAGES; page++) {
             const paginatedCoins = await this.api.client.listCoins({
               coinType: inputs.coinType,
               owner: inputs.walletAddress,
               cursor
             });
-            const coinData = paginatedCoins.objects.map(
-              GrpcCasting.coinStructFromGrpcCoin
+            allCoinData.push(
+              ...paginatedCoins.objects.map(GrpcCasting.coinStructFromGrpcCoin)
             );
-            allCoinData = [...allCoinData, ...coinData];
-            if (paginatedCoins.objects.length === 0 || !paginatedCoins.hasNextPage || !paginatedCoins.cursor) {
-              allCoinData.sort(
-                (b, a) => Number(BigInt(a.balance) - BigInt(b.balance))
-              );
-              const coinDatas = [];
-              let sum = BigInt(0);
-              for (const coinData2 of allCoinData) {
-                coinDatas.push(coinData2);
-                sum += BigInt(coinData2.balance);
-                if (sum >= inputs.coinAmount) {
-                  return coinDatas;
-                }
+            allCoinData.sort((b, a) => Number(BigInt(a.balance) - BigInt(b.balance)));
+            const selectedCoins = [];
+            let sum = BigInt(0);
+            for (const coinData of allCoinData) {
+              selectedCoins.push(coinData);
+              sum += BigInt(coinData.balance);
+              if (sum >= inputs.coinAmount) {
+                return selectedCoins;
               }
+            }
+            if (paginatedCoins.objects.length === 0 || !paginatedCoins.hasNextPage || !paginatedCoins.cursor) {
               throw new Error("wallet does not have coins of sufficient balance");
             }
             cursor = paginatedCoins.cursor;
-          } while (true);
+          }
+          throw new Error("wallet balance is spread across too many coin objects");
         };
-        // fetchCoinsUntilAmountReachedOrEnd
         this.fetchAllCoins = async (inputs) => {
-          let allCoinData = [];
+          const allCoinData = [];
           let cursor;
           do {
             const paginatedCoins = await this.api.client.listCoins({
@@ -16075,71 +16067,66 @@ var init_coinApi = __esm({
               owner: inputs.walletAddress,
               cursor
             });
-            const coinData = paginatedCoins.objects.map(
-              GrpcCasting.coinStructFromGrpcCoin
+            allCoinData.push(
+              ...paginatedCoins.objects.map(GrpcCasting.coinStructFromGrpcCoin)
             );
-            allCoinData = [...allCoinData, ...coinData];
-            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);
+            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");
+          }
         };
       }
     };
     // =========================================================================
     //  Private Static Methods
     // =========================================================================
-    _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]);
-      }
+    /**
+     * 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;
       const coinObjectIds = coinData.map((data) => data.coinObjectId);
       const mergedCoinObjectId = coinObjectIds[0];
       if (coinObjectIds.length > 1) {
-        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))
-          ]);
-        }
+        tx.add({
+          $kind: "MergeCoins",
+          MergeCoins: {
+            destination: tx.object(mergedCoinObjectId),
+            sources: [
+              ...coinObjectIds.slice(1).map((coinId) => tx.object(coinId))
+            ]
+          }
+        });
       }
-      return isSponsoredTx ? TransactionsApiHelpers.splitCoinTx({
+      return TransactionsApiHelpers.splitCoinTx({
         tx,
         coinId: mergedCoinObjectId,
         amount: coinAmount,
         coinType
-      }) : tx.splitCoins(mergedCoinObjectId, [coinAmount]);
+      });
     };
     CoinApi = _CoinApi;
   }