Migrating from JSON-RPC

- import { SuiJsonRpcClient, getJsonRpcFullnodeUrl } from '@mysten/sui/jsonRpc';
+ import { SuiGrpcClient } from '@mysten/sui/grpc';

- const client = new SuiJsonRpcClient({
-   url: getJsonRpcFullnodeUrl('mainnet'),
-   network: 'mainnet',
- });
+ const client = new SuiGrpcClient({
+   baseUrl: 'https://fullnode.mainnet.sui.io:443',
+   network: 'mainnet',
+ });

- const result = await jsonRpcClient.queryTransactionBlocks({
-   filter: { FromAddress: '0xabc...' },
-   options: { showEffects: true },
-   limit: 10,
- });
- const digests = result.data.map((tx) => tx.digest);
+ const result = await client.core.listTransactions({
+   filter: { sender: '0xabc...' },
+   include: { effects: true },
+   limit: 10,
+ });
+ const digests = result.transactions.map(
+   (tx) => (tx.Transaction ?? tx.FailedTransaction).digest,
+ );

- const result = await jsonRpcClient.queryEvents({
-   query: { MoveEventType: '0x2::coin::CoinCreated' },
-   limit: 10,
-   order: 'descending',
- });
+ const result = await client.core.listEvents({
+   filter: { eventType: '0x2::coin::CoinCreated' },
+   limit: 10,
+   order: 'descending',
+ });

- const result = await jsonRpcClient.getCheckpoints({
-   descendingOrder: true,
-   limit: 10,
- });
- const checkpoints = result.data;
+ const result = await client.core.listCheckpoints({
+   order: 'descending',
+   limit: 10,
+ });
+ const checkpoints = result.checkpoints;

- const result = await jsonRpcClient.devInspectTransactionBlock({
-   sender: '0xabc...',
-   transactionBlock: tx,
- });
- const returnValues = result.results?.[0]?.returnValues;
+ const result = await client.core.simulateTransaction({
+   transaction: tx,
+   checksEnabled: false,
+   include: { commandResults: true },
+ });
+ const returnValues = result.commandResults?.[0]?.returnValues;

- const { data } = await jsonRpcClient.getOwnedObjects({
-   owner: '0xabc...',
-   options: { showContent: true },
- });
+ const { objects } = await grpcClient.listOwnedObjects({
+   owner: '0xabc...',
+   include: { content: true },
+ });

import { SuiGrpcClient } from '@mysten/sui/grpc';

const client = new SuiGrpcClient({
	baseUrl: 'https://fullnode.mainnet.sui.io:443',
	network: 'mainnet',
});

// Get the latest checkpoint sequence number (replaces getLatestCheckpointSequenceNumber)
const { response: info } = await client.ledgerService.getServiceInfo({});
const latestCheckpoint = info.checkpointHeight;

// Get a specific checkpoint by sequence number. `checkpointId` is required (a oneof);
// the read mask defaults to `sequence_number,digest`, so request more fields as needed.
const { response } = await client.ledgerService.getCheckpoint({
	checkpointId: { oneofKind: 'sequenceNumber', sequenceNumber: latestCheckpoint },
});

// Get the current epoch (omit `epoch` for the current one). The system state,
// committee, and protocol config are NOT returned by default — you must request
// them via the read mask (the default mask is just `epoch`).
const { response: epoch } = await client.ledgerService.getEpoch({
	readMask: { paths: ['epoch', 'system_state', 'committee', 'protocol_config'] },
});
const systemState = epoch.epoch?.systemState;
const committee = epoch.epoch?.committee;
const protocolConfig = epoch.epoch?.protocolConfig;

// Get coin metadata and total supply in one call
const { response: coinInfo } = await client.stateService.getCoinInfo({
	coinType: '0x2::sui::SUI',
});
const metadata = coinInfo.metadata;
const totalSupply = coinInfo.treasury?.totalSupply;

// Get Move package information (includes all modules)
const { response: pkg } = await client.movePackageService.getPackage({
	packageId: '0x2',
});

// Get a specific Move datatype (struct or enum)
const { response: datatype } = await client.movePackageService.getDatatype({
	packageId: '0x2',
	moduleName: 'coin',
	name: 'Coin',
});

// Resolve SuiNS name
const { response: address } = await client.nameService.lookupName({
	name: 'example.sui',
});

const stream = client.subscriptionService.subscribeEvents({
	filter: {
		terms: [
			{
				literals: [
					{
						negated: false,
						predicate: {
							oneofKind: 'eventType',
							eventType: { eventType: '0x2::coin::CoinCreated' },
						},
					},
				],
			},
		],
	},
	readMask: { paths: ['event_type', 'contents', 'json', 'checkpoint', 'transaction_digest'] },
});

for await (const frame of stream.responses) {
	if (frame.event) {
		console.log(frame.event.eventType, frame.event.json);
	}
}

import { SuiGraphQLClient } from '@mysten/sui/graphql';

const graphqlClient = new SuiGraphQLClient({
	url: 'https://sui-mainnet.mystenlabs.com/graphql',
	network: 'mainnet',
});

const result = await graphqlClient.query({
	query: `
    query MultiGetTransactions($digests: [String!]!) {
      multiGetTransactionEffects(keys: $digests) {
        transaction {
          digest
          transactionBcs
        }
        status
        epoch { epochId }
      }
    }
  `,
	variables: {
		digests: ['digest1', 'digest2', 'digest3'],
	},
});

const result = await graphqlClient.query({
	query: `
    query GetObjectAtVersion($id: SuiAddress!, $version: UInt53!) {
      object(address: $id, version: $version) {
        address
        version
        digest
        asMoveObject {
          contents {
            type { repr }
            bcs
          }
        }
      }
    }
  `,
	variables: {
		id: '0x123...',
		version: 42,
	},
});

const result = await graphqlClient.query({
	query: `
    query GetCoinMetadata($coinType: String!) {
      coinMetadata(coinType: $coinType) {
        name
        symbol
        description
        decimals
        iconUrl
        supply
      }
    }
  `,
	variables: {
		coinType: '0x2::sui::SUI',
	},
});

const result = await graphqlClient.query({
	query: `
    query GetStakes($owner: SuiAddress!) {
      address(address: $owner) {
        stakedSuis {
          nodes {
            principal
            stakeActivationEpoch
            estimatedReward
            contents {
              bcs
            }
          }
        }
      }
    }
  `,
	variables: {
		owner: '0xabc...',
	},
});

// Transaction result access
- const status = result.effects?.status?.status;
+ const tx = result.Transaction ?? result.FailedTransaction;
+ const status = tx.effects.status.success;

// Include options
- { showEffects: true, showEvents: true }
+ { effects: true, events: true }

import { SuiGrpcClient } from '@mysten/sui/grpc';
import { deepbook } from '@mysten/deepbook-v3';
import { suins } from '@mysten/suins';

const client = new SuiGrpcClient({
	baseUrl: 'https://fullnode.mainnet.sui.io:443',
	network: 'mainnet',
}).$extend(deepbook({ address: myAddress }), suins());

// Use extended functionality
await client.deepbook.checkManagerBalance(manager, asset);
await client.suins.getName('0xabc...');