SDKs, Frontends, Wallets & Indexers

Note: the Sui SDK continues to evolve (newer major versions add gRPC/GraphQL-based clients alongside the JSON-RPC client, which is planned for deprecation).

41.1 Sui TypeScript SDK (@mysten/sui)

tx.object(id), tx.object.clock(), tx.object.random() Object inputs (system objects have helpers)

tx.pure.u64(n), tx.pure.address(a), tx.pure.string(s), tx.pure.vector('u8', bytes) Pure (BCS) inputs

tx.splitCoins, tx.mergeCoins, tx.transferObjects, tx.makeMoveVec Native PTB commands

client.devInspectTransactionBlock / dryRunTransactionBlock

Simulate without executing (read return values, estimate gas) Encode/decode BCS data React hooks and wallet connection @mysten/enoki, @mysten/zklogin zkLogin and sponsored transactions

Note: the Sui SDK continues to evolve (newer major versions add gRPC/GraphQL-based clients alongside the JSON-RPC client, which is planned for deprecation). The transaction-building API above stays conceptually the same; check the current SDK docs for client class names.

import { SuiClient, getFullnodeUrl } from '@mysten/sui/client';
import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
import { Transaction } from '@mysten/sui/transactions';

const client = new SuiClient({ url: getFullnodeUrl('testnet') });
const keypair = Ed25519Keypair.deriveKeypair(process.env.MNEMONIC!); // never hard-code secrets

// Read an object
const counter = await client.getObject({ id: COUNTER_ID, options: { showContent: true } });

// Write: build, sign, execute
const tx = new Transaction();
tx.moveCall({
  target: `${PACKAGE_ID}::counter::increment`,
  arguments: [tx.object(COUNTER_ID)],
});
const result = await client.signAndExecuteTransaction({
  signer: keypair,
  transaction: tx,
  options: { showEffects: true, showEvents: true },
});
await client.waitForTransaction({ digest: result.digest });

// Query events
const events = await client.queryEvents({
  query: { MoveEventType: `${PACKAGE_ID}::counter::Incremented` },
});

41.2 Sui dApp frontend with dApp Kit (React)

Scaffold quickly with npm create @mysten/dapp. Wallets implement the Wallet Standard: Slush (formerly Sui Wallet), Suiet, Phantom, OKX, Nightly, and others.

import { createNetworkConfig, SuiClientProvider, WalletProvider, ConnectButton,
         useCurrentAccount, useSignAndExecuteTransaction } from '@mysten/dapp-kit';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { getFullnodeUrl } from '@mysten/sui/client';
import { Transaction } from '@mysten/sui/transactions';
import '@mysten/dapp-kit/dist/index.css';

const { networkConfig } = createNetworkConfig({ testnet: { url: getFullnodeUrl('testnet') } });
const queryClient = new QueryClient();

function IncrementButton() {
  const account = useCurrentAccount();
  const { mutate: signAndExecute } = useSignAndExecuteTransaction();
  if (!account) return <p>Connect a wallet</p>;
  return (
    <button onClick={() => {
      const tx = new Transaction();
      tx.moveCall({ target: `${PACKAGE_ID}::counter::increment`, arguments: [tx.object(COUNTER_ID)] });
      signAndExecute({ transaction: tx }, { onSuccess: (r) => console.log(r.digest) });
    }}>Increment</button>
  );
}

export function App() {
  return (
    <QueryClientProvider client={queryClient}>
      <SuiClientProvider networks={networkConfig} defaultNetwork="testnet">
        <WalletProvider autoC
…

41.3 Aptos TypeScript SDK (@aptos-labs/ts-sdk)

Fund (devnet/localnet) aptos.fundAccount({ accountAddress, amount })

aptos.getAccountAPTAmount, FA balance queries aptos.getOwnedDigitalAssets, aptos.getCollectionData Multi-agent / fee payer

build.multiAgent, withFeePayer: true aptos.deriveKeylessAccount (OAuth flow)

import { Aptos, AptosConfig, Network, Account, Ed25519PrivateKey } from '@aptos-labs/ts-sdk';

const aptos = new Aptos(new AptosConfig({ network: Network.TESTNET }));
const account = Account.fromPrivateKey({
  privateKey: new Ed25519PrivateKey(process.env.APTOS_PRIVATE_KEY!),
});

// Write
const txn = await aptos.transaction.build.simple({
  sender: account.accountAddress,
  data: {
    function: `${MODULE_ADDR}::counter::increment`,
    functionArguments: [],
  },
});
const pending = await aptos.signAndSubmitTransaction({ signer: account, transaction: txn });
await aptos.waitForTransaction({ transactionHash: pending.hash });

// Read via view function
const [value] = await aptos.view({
  payload: {
    function: `${MODULE_ADDR}::counter::value`,
    functionArguments: [account.accountAddress.toString()],
  },
});

// Read a resource directly
const res = await aptos.getAccountResource({
  accountAddress: account.accountAddress,
  resourceType: `${MODULE_ADDR}::counter::Counter`,
});

41.4 Aptos wallet adapter (React)

Scaffold with npx create-aptos-dapp. Wallets supporting AIP-62 (wallet standard): Petra, Nightly, Pontem, OKX, and Aptos Connect (keyless web wallet).

import { AptosWalletAdapterProvider, useWallet } from '@aptos-labs/wallet-adapter-react';
import { Network } from '@aptos-labs/ts-sdk';

function Increment() {
  const { account, connected, signAndSubmitTransaction } = useWallet();
  if (!connected) return <p>Connect a wallet</p>;
  return (
    <button onClick={() => signAndSubmitTransaction({
      data: { function: `${MODULE_ADDR}::counter::increment`, functionArguments: [] },
    })}>Increment</button>
  );
}

export const App = () => (
  <AptosWalletAdapterProvider autoConnect dappConfig={{ network: Network.TESTNET }}>
    <Increment />
  </AptosWalletAdapterProvider>
);

41.5 Other SDKs

sui-sdk (Sui repo) aptos-sdk (Aptos repo) pysui (community) aptos-sdk (official) official Go SDK Kotlin / Swift / Dart / Unity community SDKs (e.g., Sui Kotlin SDK) official/community Unity, Kotlin, Swift SDKs

41.6 Indexers and data access

Full node RPC (getObject, getOwnedObjects, queryEvents)

REST API (/accounts/{addr}/resources, view functions) Sui GraphQL RPC service; gRPC full-node API Indexer GraphQL API (Hasura-based)

Custom indexer framework (sui-indexer-alt style pipelines in Rust) reading checkpoints

Transaction Stream Service + indexer SDK processors; no-code indexers Various data providers and RPC services

Typical architecture: Move contracts emit events → indexer consumes checkpoints/transactions → writes to Postgres → your API/frontend queries the database for history, leaderboards, and search.