@scallop-io/scallop-swap-sdk 1.0.0

package/dist/interface/base.d.ts

@@ -0,0 +1,73 @@
+import { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions';
+import { FetchRouteResult } from './route';
+import { SuiClient } from '@mysten/sui/client';
+export type FetchRouteParams = {
+    coinInType: string;
+    coinOutType: string;
+    swapAmount: bigint;
+};
+export type SwapParams = {
+    slippage: number;
+    minAmountOut?: bigint;
+    txExtensionParams?: {
+        initTx: Transaction;
+        coinIn: TransactionObjectArgument;
+    };
+    mergeOutputCoin?: boolean;
+};
+export interface SwapBuildResult {
+    tx: Transaction;
+    coinOut: TransactionObjectArgument;
+}
+export interface SwapSdkConstructorParams {
+    client?: SuiClient;
+    fetchTimeoutInMs?: number;
+    cacheTimeInMs?: number;
+    walletAddress: string;
+}
+/**
+ * Base interface for Swap SDK
+ */
+export interface SwapSdkBaseInterface<T = string, U = any, V = any> {
+    /**
+     * How long the route result is cached (in milliseconds)
+     */
+    cacheTimeInMs?: number;
+    lastFetchTimestamp?: number;
+    /**
+     * How long the route fetch request should wait before timing out (in milliseconds)
+     */
+    fetchTimeoutInMs?: number;
+    /**
+     * Pools or DEXes available in the SDK
+     */
+    pools?: T[];
+    /**
+     * Fetch route settings based on SDK-specific settings
+     */
+    fetchSettings?: V;
+    /**
+     * Set fetch route settings based on SDK-specific settings
+     * @param settings
+     * @returns
+     */
+    setFetchRouteSettings: (settings: V) => void;
+    changeClient: (client: SuiClient) => void;
+    setWalletAddress: (address: string) => void;
+    /**
+     * Calculate slippage based on basis points (bps) input.
+     * @param slippageInBps
+     * @returns slippage in required format or notation
+     */
+    calcSlippage: (slippageInBps: number) => number;
+    fetchRoute: (params: FetchRouteParams) => Promise<FetchRouteResult<U>>;
+    /**
+     * Select coinIn for swap transaction
+     * @param tx
+     * @param amount
+     * @param coinType
+     * @returns Promise<TransactionObjectArgument>
+     */
+    selectCoinInForSwap: (tx: Transaction, amount: bigint, coinType: string) => Promise<TransactionObjectArgument>;
+    buildSwapTransaction: (params: SwapParams) => Promise<SwapBuildResult>;
+}

package/dist/interface/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './base';
+export type * from './route';

package/dist/interface/route.d.ts

@@ -0,0 +1,29 @@
+export interface Coin {
+    type: string;
+    amount: bigint;
+}
+interface SwapCoinInfo {
+    coinIn: Coin;
+    coinOut: Coin;
+}
+interface SwapPath extends SwapCoinInfo {
+    protocolName: string;
+}
+export interface SwapRoute extends SwapCoinInfo {
+    paths: SwapPath[];
+    splitPercentage?: number;
+}
+/**
+ * Common interface for route result (for frontend display purposes)
+ */
+export interface FormattedRouteResult {
+    routes: SwapRoute[];
+    coinIn: Coin;
+    coinOut: Coin;
+    name: string;
+}
+export type FetchRouteResult<T> = {
+    rawRouteResult: T;
+    formattedResult: FormattedRouteResult;
+};
+export {};

package/dist/sdk/7k.d.ts

@@ -0,0 +1,38 @@
+import { Commission, QuoteResponse, SourceDex } from '@7kprotocol/sdk-ts';
+import { Transaction, TransactionObjectArgument } from '@scallop-io/sui-kit';
+import { SwapSdkBase } from 'src/class';
+import { FetchRouteParams, FetchRouteResult, SwapParams, SwapSdkConstructorParams } from 'src/interface';
+interface Params {
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: string;
+    /**
+     * @default DEFAULT_SOURCES
+     * @warning BluefinX must be explicitly specified if needed
+     * @example ```sources: [...DEFAULT_SOURCES, "bluefinx"]``` */
+    sources?: SourceDex[];
+    commissionBps?: number;
+    /** Limit the route to a specific set of pools */
+    targetPools?: string[];
+    /** Exclude a specific set of pools from the route */
+    excludedPools?: string[];
+    /** The taker address, required for bluefinx */
+    taker?: string;
+    /** If true, excludes all liquidity sources that depend on pyth price feeds - pyth client use tx.gas to pay the fee*/
+    isSponsored?: boolean;
+}
+export declare class _7kSwap extends SwapSdkBase<SourceDex, QuoteResponse, Omit<Params, 'tokenIn' | 'tokenOut' | 'amountIn'>> {
+    commission: Commission;
+    constructor(params: SwapSdkConstructorParams & {
+        commission?: Commission;
+    });
+    setFetchRouteSettings(settings: Omit<Params, 'tokenIn' | 'tokenOut' | 'amountIn'>): void;
+    private createRoute;
+    private parseRawRouteToFormattedResult;
+    fetchRoute(params: FetchRouteParams): Promise<FetchRouteResult<QuoteResponse>>;
+    buildSwapTransaction(params: SwapParams): Promise<{
+        tx: Transaction;
+        coinOut: TransactionObjectArgument;
+    }>;
+}
+export {};

package/dist/sdk/aftermath.d.ts

@@ -0,0 +1,19 @@
+import { Transaction } from '@scallop-io/sui-kit';
+import { RouterProtocolName, RouterCompleteTradeRoute, ApiRouterPartialCompleteTradeRouteBody, Aftermath, ConfigAddresses, AftermathApi } from 'aftermath-ts-sdk';
+import { SwapSdkBase } from 'src/class';
+import { FetchRouteParams, FetchRouteResult, SwapParams, SwapSdkConstructorParams } from 'src/interface';
+export declare class AftermathSwap extends SwapSdkBase<RouterProtocolName, RouterCompleteTradeRoute, ApiRouterPartialCompleteTradeRouteBody> {
+    readonly afClient: Aftermath;
+    readonly afApi: AftermathApi;
+    constructor(params: SwapSdkConstructorParams & {
+        addresses?: ConfigAddresses;
+    });
+    get router(): import("aftermath-ts-sdk").Router;
+    setFetchRouteSettings(settings: ApiRouterPartialCompleteTradeRouteBody): void;
+    private parseRawRouteToFormattedResult;
+    fetchRoute(params: FetchRouteParams): Promise<FetchRouteResult<RouterCompleteTradeRoute>>;
+    buildSwapTransaction(params: SwapParams): Promise<{
+        tx: Transaction;
+        coinOut: any;
+    }>;
+}

package/dist/sdk/cetus.d.ts

@@ -0,0 +1,30 @@
+import { Transaction } from '@mysten/sui/transactions';
+import { AggregatorClient, AggregatorClientParams, FindRouterParams, RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
+import { SwapSdkBase } from 'src/class';
+import { FetchRouteParams, SwapParams, SwapSdkConstructorParams, SwapRoute } from 'src/interface';
+type RawRouteResult = RouterDataV3;
+export declare class CetusSwap extends SwapSdkBase<string, RawRouteResult, FindRouterParams> {
+    readonly cetusClient: AggregatorClient;
+    constructor(params: SwapSdkConstructorParams & AggregatorClientParams);
+    private createRoute;
+    /**
+     * Parse the raw route data from Cetus to the standardized FetchRouteResult format.
+     * @returns FormattedRouteResult
+     */
+    private parseRawToFormattedResult;
+    setFetchRouteSettings(settings: FindRouterParams): void;
+    fetchRoute(params: FetchRouteParams): Promise<{
+        formattedResult: {
+            name: string;
+            routes: SwapRoute[];
+            coinIn: import("src/interface").Coin;
+            coinOut: import("src/interface").Coin;
+        };
+        rawRouteResult: RouterDataV3;
+    }>;
+    buildSwapTransaction(params: SwapParams): Promise<{
+        tx: Transaction;
+        coinOut: any;
+    }>;
+}
+export {};

package/dist/sdk/flowx.d.ts

@@ -0,0 +1,19 @@
+import { Coin, Commission, GetRoutesResult, Protocol, SingleQuoteQueryParams } from '@flowx-finance/sdk';
+import { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions';
+import { SwapSdkBase } from 'src/class';
+import { FetchRouteParams, FetchRouteResult, FormattedRouteResult, SwapParams, SwapSdkConstructorParams } from 'src/interface';
+export declare class FlowXSwap extends SwapSdkBase<Protocol, GetRoutesResult<Coin, Coin>, Omit<SingleQuoteQueryParams, 'amountIn' | 'tokenIn' | 'tokenOut'>> {
+    private quoter;
+    commission?: Commission;
+    constructor(params: SwapSdkConstructorParams & Omit<SingleQuoteQueryParams, 'amountIn' | 'tokenIn' | 'tokenOut'> & {
+        commission?: Commission;
+    });
+    setFetchRouteSettings(settings: Omit<SingleQuoteQueryParams, 'amountIn'>): void;
+    calcSlippage(slippageInBps: number): number;
+    protected parseRawRouteToFormattedResult(rawRouteResult: GetRoutesResult<Coin, Coin>): FormattedRouteResult;
+    fetchRoute(params: FetchRouteParams): Promise<FetchRouteResult<GetRoutesResult<Coin, Coin>>>;
+    buildSwapTransaction(params: SwapParams): Promise<{
+        tx: Transaction;
+        coinOut: TransactionObjectArgument;
+    }>;
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cetus';
+export * from './aftermath';
+export * from './7k';
+export * from './flowx';

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+import { CoinStruct, SuiClient } from '@mysten/sui/client';
+import { Transaction, TransactionObjectArgument } from '@mysten/sui/transactions';
+export declare const isSuiType: (coinType: string) => boolean;
+export declare const selectCoins: (client: SuiClient, coinType: string, amount: string, owner: string) => Promise<CoinStruct[]>;
+export declare const mergeWithExistingOrTransfer: (tx: Transaction, coin: TransactionObjectArgument, client: SuiClient, coinType: string, sender: string) => Promise<void>;
+export declare const transformProperCase: (provider: Lowercase<string>) => string;

package/package.json

@@ -0,0 +1,168 @@
+{
+  "name": "@scallop-io/scallop-swap-sdk",
+  "version": "1.0.0",
+  "description": "Swap SDK Aggregator for Sui Blockchain developed by Scallop Labs.",
+  "keywords": [
+    "sui",
+    "scallop labs",
+    "move",
+    "blockchain",
+    "swap sdk aggregator",
+    "scallop-swap-sdk-aggregator"
+  ],
+  "author": "team@scallop.io",
+  "homepage": "https://github.com/scallop-io/scallop-swap-sdk-aggregator#readme",
+  "bugs": "https://github.com/scallop-io/scallop-swap-sdk-aggregator/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/scallop-io/scallop-swap-sdk-aggregator.git"
+  },
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@7kprotocol/sdk-ts": "^3.4.1",
+    "@cetusprotocol/aggregator-sdk": "^1.4.1",
+    "@flowx-finance/sdk": "^1.13.8",
+    "@mysten/sui": "^1.43.1",
+    "@scallop-io/sui-kit": "^1.4.3",
+    "aftermath-ts-sdk": "^1.3.23",
+    "assert": "^2.1.0",
+    "bignumber.js": "^9.3.1",
+    "bn.js": "^5.2.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^18.0.0",
+    "@commitlint/config-conventional": "^18.0.0",
+    "@commitlint/prompt-cli": "^18.0.0",
+    "@types/bn.js": "^5.2.0",
+    "@types/node": "^20.8.7",
+    "@types/tmp": "^0.2.5",
+    "@typescript-eslint/eslint-plugin": "^8.11.0",
+    "@typescript-eslint/parser": "8.10.0",
+    "@vitest/coverage-v8": "3.1.1",
+    "@vitest/expect": "^3.1.1",
+    "@vitest/runner": "^3.1.1",
+    "@vitest/spy": "^3.1.1",
+    "dotenv": "^16.6.1",
+    "eslint": "^8.52.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-prettier": "^5.0.1",
+    "husky": "^8.0.3",
+    "lint-staged": "^15.0.2",
+    "prettier": "^3.0.3",
+    "standard-version": "^9.5.0",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
+    "tsup": "^7.2.0",
+    "typedoc": "^0.25.2",
+    "typescript": "5.5.4",
+    "vitest": "^3.1.1"
+  },
+  "resolutions": {
+    "@mysten/sui": "^1.43.1"
+  },
+  "lint-staged": {
+    "**/*.ts": [
+      "pnpm run format:fix",
+      "pnpm run lint:fix"
+    ],
+    "**/*.json|md": [
+      "pnpm run format:fix"
+    ]
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "prettier": {
+    "trailingComma": "es5",
+    "tabWidth": 2,
+    "semi": true,
+    "singleQuote": true,
+    "useTabs": false,
+    "quoteProps": "as-needed",
+    "bracketSpacing": true,
+    "arrowParens": "always",
+    "endOfLine": "lf"
+  },
+  "eslintConfig": {
+    "root": true,
+    "env": {
+      "browser": true,
+      "node": true,
+      "es2022": true
+    },
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/eslint-recommended",
+      "plugin:prettier/recommended"
+    ],
+    "plugins": [
+      "@typescript-eslint",
+      "prettier"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "rules": {
+      "prettier/prettier": "warn",
+      "@typescript-eslint/no-explicit-any": "off",
+      "no-unused-vars": "off",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          "argsIgnorePattern": "^_",
+          "varsIgnorePattern": "^_",
+          "caughtErrorsIgnorePattern": "^_"
+        }
+      ]
+    }
+  },
+  "scripts": {
+    "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
+    "build": "npm run build:types && npm run build:tsup",
+    "build:tsup": "tsup ./src/index.ts --format esm,cjs --splitting --minify --treeshake",
+    "build:types": "tsc --build",
+    "watch:tsup": "tsup ./src/index.ts --format esm,cjs --clean --splitting --watch",
+    "watch:types": "tsc --watch",
+    "watch": "pnpm run clean & pnpm run watch:types & pnpm run watch:tsup",
+    "test": "pnpm test:typecheck && pnpm test:unit",
+    "test:typecheck": "tsc -p ./test",
+    "test:unit": "vitest run --test-timeout=60000",
+    "test:watch": "vitest",
+    "test:coverage-unit": "vitest run test/unit --coverage --test-timeout=60000",
+    "test:coverage-integration": "vitest run test/integration --coverage --test-timeout=60000",
+    "test:coverage": "vitest run --coverage --test-timeout=60000",
+    "format:fix": "prettier --ignore-path 'dist/* docs/*' --write '**/*.{ts,json,md}'",
+    "lint:fix": "eslint . --ignore-pattern dist --ext .ts --fix",
+    "commit": "commit",
+    "release": "standard-version -f",
+    "release:major": "standard-version -r major",
+    "release:minor": "standard-version -r minor",
+    "release:patch": "standard-version -r patch",
+    "doc": "typedoc --out docs src/index.ts"
+  }
+}

package/src/class/aggregator.ts

@@ -0,0 +1,245 @@
+import {
+  Transaction,
+  TransactionObjectArgument,
+} from '@mysten/sui/transactions';
+import { isValidSuiAddress } from '@mysten/sui/utils';
+import { SwapSdkBase } from './base';
+import { AggregatorConstructorParams } from 'src/interface/aggregator';
+import { FetchRouteParams, SwapBuildResult } from 'src/interface/base';
+import { BigNumber } from 'bignumber.js';
+import {
+  DryRunTransactionBlockResponse,
+  SuiClient,
+  SuiTransactionBlockResponse,
+} from '@mysten/sui/client';
+import { FetchRouteResult } from 'src/interface/route';
+import { CoinMetadataRegistry } from './coinMetadata';
+import { SuiKit } from '@scallop-io/sui-kit';
+import { mergeWithExistingOrTransfer } from 'src/utils';
+
+export class Aggregator {
+  readonly coinMetadata: CoinMetadataRegistry;
+  readonly suiKit: SuiKit;
+  readonly aggregators: SwapSdkBase[] = [];
+
+  protected slippage: number = 30; // in bps, 1bps = 0.01% = 0.0001, defaults to 0.3%
+  protected routes: FetchRouteResult<any>[] = [];
+  protected buildResult?: SwapBuildResult & { coinOutType: string };
+
+  walletAddress: string;
+  client: SuiClient;
+
+  constructor(params: AggregatorConstructorParams) {
+    this.client = new SuiClient({
+      url: params.fullnodeUrl || 'https://fullnode.mainnet.sui.io:443',
+    });
+    this.suiKit = new SuiKit({
+      ...params,
+      suiClients: [this.client],
+    });
+
+    this.coinMetadata = new CoinMetadataRegistry(this.client);
+
+    if (params.secretKey || params.mnemonics) {
+      this.walletAddress = this.suiKit.currentAddress;
+    } else if (params.walletAddress) {
+      if (!isValidSuiAddress(params.walletAddress)) {
+        throw new Error('Invalid Sui wallet address');
+      }
+      this.walletAddress = params.walletAddress;
+    } else {
+      throw new Error(
+        'One of secretKey, mnemonics or walletAddress must be provided'
+      );
+    }
+  }
+
+  // ------------ AGGREGATOR MANAGEMENT ---------------
+  addAggregator(aggregator: SwapSdkBase[]) {
+    this.aggregators.push(...aggregator);
+  }
+
+  getAggregators() {
+    return this.aggregators;
+  }
+
+  removeAggregator(name: string) {
+    const idx = this.aggregators.findIndex((t) => t.name === name);
+    if (idx === -1) {
+      throw new Error(`Aggregator ${name} not found`);
+    }
+
+    this.aggregators.splice(idx, 1);
+  }
+
+  /**
+   * Set slippage in bps (1bps = 0.01% = 0.0001)
+   * @param slippageInBps
+   */
+  setSlippage(slippageInBps: number) {
+    this.slippage = slippageInBps;
+  }
+
+  // ------------ GUARDS ---------------
+  #validateSuiKit(): asserts this is typeof Aggregator & { suiKit: SuiKit } {
+    if (!this.suiKit) {
+      throw new Error('SuiKit is not initialized.');
+    }
+  }
+
+  #validateBuildResult(): asserts this is typeof Aggregator & {
+    buildResult: SwapBuildResult;
+  } {
+    if (!this.buildResult) {
+      throw new Error(
+        'Build result is not available. Please build the best route transaction first.'
+      );
+    }
+  }
+
+  // ------------ CLIENT MANAGEMENT ---------------
+  changeSuiClient(client: SuiClient) {
+    this.aggregators.forEach((aggregator) => {
+      aggregator.changeClient(client);
+    });
+    this.client = client;
+  }
+
+  changeWalletAddress(address: string) {
+    if (this.suiKit) {
+      throw new Error(
+        'Cannot change wallet address when SuiKit is initialized with secretKey or mnemonics.'
+      );
+    }
+
+    if (!isValidSuiAddress(address)) {
+      throw new Error('Invalid Sui wallet address');
+    }
+
+    this.walletAddress = address;
+    this.aggregators.forEach((aggregator) => {
+      aggregator.setWalletAddress(address);
+    });
+  }
+
+  // ------------ COINS METADATA ---------------
+  async getCoinMetadata(coinType: string) {
+    return this.coinMetadata.getCoinMetadata(coinType);
+  }
+
+  // ------------ METHODS ---------------
+  /**
+   * Fetch swap routes from all aggregators, and sort them by best output amount
+   * @param params FetchRouteParams
+   */
+  async fetchRoute(params: FetchRouteParams) {
+    console.log(
+      'Available aggregators: ',
+      this.aggregators.map((t) => t.name).join(', ')
+    );
+    console.log(
+      `Fetching routes for ${params.coinInType} -> ${params.coinOutType}...`
+    );
+    const results = await Promise.allSettled(
+      this.aggregators.map((aggregator) => aggregator.fetchRoute(params))
+    );
+
+    // Filter only successful results
+    const successfulResults = results
+      .filter((t) => t.status === 'fulfilled')
+      .map((t) => t.value);
+
+    // Sort by best output amount
+    const sorted = successfulResults.sort((a, b) =>
+      BigNumber(b.formattedResult.coinOut.amount)
+        .minus(a.formattedResult.coinOut.amount)
+        .toNumber()
+    );
+
+    this.routes = sorted;
+    return sorted;
+  }
+
+  /**
+   * Build transaction with the best route
+   * @param txExtensionParams Optional transaction extension parameters
+   */
+  async buildBestRouteTransaction(txExtensionParams?: {
+    initTx: Transaction;
+    coinIn: TransactionObjectArgument;
+  }) {
+    if (this.routes.length === 0) {
+      throw new Error('No routes available. Please fetch routes first.');
+    }
+
+    const bestRoute = this.routes[0];
+
+    // Get aggregator
+    const aggregator = this.aggregators.find(
+      (t) => t.name === bestRoute.formattedResult.name
+    );
+    if (!aggregator) {
+      throw new Error(
+        `Aggregator ${bestRoute.formattedResult.name} not found in the aggregator list`
+      );
+    }
+
+    const [
+      { decimals: decimalsIn, symbol: symbolIn },
+      { decimals: decimalsOut, symbol: symbolOut },
+    ] = await Promise.all([
+      this.coinMetadata.getCoinMetadata(bestRoute.formattedResult.coinIn.type),
+      this.coinMetadata.getCoinMetadata(bestRoute.formattedResult.coinOut.type),
+    ]);
+
+    const amountIn = BigNumber(bestRoute.formattedResult.coinIn.amount)
+      .shiftedBy(-decimalsIn)
+      .toString();
+
+    const amountOut = BigNumber(bestRoute.formattedResult.coinOut.amount)
+      .shiftedBy(-decimalsOut)
+      .toString();
+
+    console.log(
+      `Swapping ${amountIn} ${symbolIn} for ${amountOut} ${symbolOut} via ${bestRoute.formattedResult.name}`
+    );
+
+    // Build transaction
+    const buildResult = await aggregator.buildSwapTransaction({
+      slippage: this.slippage,
+      txExtensionParams,
+    });
+    this.buildResult = {
+      ...buildResult,
+      coinOutType: bestRoute.formattedResult.coinOut.type,
+    };
+    return buildResult;
+  }
+
+  /**
+   * Merge or transfer the output coin to user's wallet and execute the best route transaction
+   */
+  async executeBestRoute(): Promise<SuiTransactionBlockResponse>;
+  async executeBestRoute(dryRun: true): Promise<DryRunTransactionBlockResponse>;
+  async executeBestRoute(dryRun: false): Promise<SuiTransactionBlockResponse>;
+
+  async executeBestRoute(dryRun: boolean = false) {
+    this.#validateSuiKit();
+    this.#validateBuildResult();
+
+    await mergeWithExistingOrTransfer(
+      this.buildResult.tx,
+      this.buildResult.coinOut,
+      this.suiKit.client,
+      this.buildResult.coinOutType,
+      this.suiKit.currentAddress
+    );
+
+    if (dryRun) {
+      // inferred: Promise<DryRunTransactionBlockResponse>
+      return this.suiKit.dryRunTxn(this.buildResult.tx);
+    }
+    // inferred: Promise<SuiTransactionBlockResponse>
+    return this.suiKit.signAndSendTxn(this.buildResult.tx);
+  }
+}