@meddleware/token-deployer-ui 0.0.9 → 0.0.10

package/src/config.ts

@@ -7,16 +7,16 @@ import type { AccessGateConfig } from './lib/accessGate.js'
 const env = (import.meta as unknown as { env?: Record<string, string | undefined> }).env ?? {}
 
 /**
- * Public JSON-RPC fullnode URLs per network (overridable via `VITE_RPC_*`).
+ * Public gRPC fullnode URLs per network (overridable via `VITE_RPC_*`).
  *
- * NOTE: the official testnet fullnode (`fullnode.testnet.sui.io`) now serves gRPC
- * only and returns 404 for JSON-RPC, so a JSON-RPC-capable endpoint is used for
- * testnet. Operators should set `VITE_RPC_*` to their preferred (often paid) RPC
- * for production to avoid public rate limits.
+ * These are **gRPC(-web)** endpoints for `SuiGrpcClient` — public fullnodes have
+ * deprecated JSON-RPC, so a JSON-RPC-only URL will not work here. Operators should
+ * set `VITE_RPC_*` to their preferred (often paid) gRPC endpoint for production to
+ * avoid public rate limits.
  */
 export const RPC_URLS: Record<Network, string> = {
   mainnet: env.VITE_RPC_MAINNET || 'https://fullnode.mainnet.sui.io:443',
-  testnet: env.VITE_RPC_TESTNET || 'https://sui-testnet-rpc.publicnode.com',
+  testnet: env.VITE_RPC_TESTNET || 'https://fullnode.testnet.sui.io:443',
   localnet: env.VITE_RPC_LOCALNET || 'http://127.0.0.1:9000',
 }
 
@@ -89,15 +89,12 @@ export function isOperatorRelayConfigured(network: WalrusNetwork): boolean {
 /**
  * gRPC fullnode URL for the Walrus icon-upload client (a `SuiGrpcClient`).
  *
- * IMPORTANT: this is a **gRPC** endpoint and is intentionally *separate* from
- * {@link RPC_URLS} (the JSON-RPC endpoints used by the deploy path). The two protocols
- * are not interchangeable — pointing the Walrus gRPC client at a JSON-RPC URL breaks it —
- * so this has its own `VITE_WALRUS_RPC_*` override rather than reusing `VITE_RPC_*`.
- * Defaults to the public gRPC fullnodes (rate-limited); set your own for production.
+ * Defaults to {@link RPC_URLS} (also gRPC); `VITE_WALRUS_RPC_*` overrides it only when
+ * Walrus traffic should use a different fullnode from the deploy path.
  */
 export const WALRUS_RPC_URLS: Record<WalrusNetwork, string> = {
-  testnet: env.VITE_WALRUS_RPC_TESTNET || 'https://fullnode.testnet.sui.io:443',
-  mainnet: env.VITE_WALRUS_RPC_MAINNET || 'https://fullnode.mainnet.sui.io:443',
+  testnet: env.VITE_WALRUS_RPC_TESTNET || RPC_URLS.testnet,
+  mainnet: env.VITE_WALRUS_RPC_MAINNET || RPC_URLS.mainnet,
 }
 
 /**

package/src/lib/accessGate.ts

@@ -30,27 +30,41 @@ export interface OwnedAccessNft {
   usesRemaining: number | null
 }
 
-/** Minimal structural subset of the JSON-RPC client used here. */
+/** Minimal structural subset of the core (gRPC) client used here. */
 export interface OwnedObjectsClient {
-  getOwnedObjects(params: {
-    owner: string
-    filter?: { StructType: string }
-    options?: { showContent?: boolean; showType?: boolean }
-  }): Promise<{ data: unknown[] }>
+  core: {
+    listOwnedObjects(params: {
+      owner: string
+      type?: string
+      include?: { json?: boolean }
+    }): Promise<{ objects: unknown[] }>
+  }
+}
+
+/**
+ * Unwrap a Move-struct field bag from a core `json` value. The gRPC/core API returns struct
+ * fields flat; the old JSON-RPC shape nested them under `.fields`. Tolerate both.
+ */
+function structFields(v: unknown): Record<string, any> | undefined {
+  if (!v || typeof v !== 'object') return undefined
+  const o = v as Record<string, any>
+  const nested = o.fields
+  return nested && typeof nested === 'object' ? (nested as Record<string, any>) : o
 }
 
 function parseUsesRemaining(variant: any): number | null {
   if (variant == null) return null
+  const tag: string | undefined = variant.variant ?? variant.type ?? variant.$kind
+  if (tag === 'UnlimitedPass') return null
   const fields = variant.fields ?? variant
   const ur = fields?.uses_remaining ?? fields?.SingleUse?.uses_remaining
   return ur != null ? Number(ur) : null
 }
 
-/** Parse a `getOwnedObjects` entry into an access NFT, or `null` if it isn't one. */
+/** Parse a `listOwnedObjects` entry into an access NFT, or `null` if it isn't one. */
 export function parseOwnedAccessNft(entry: any): OwnedAccessNft | null {
-  const obj = entry?.data ?? entry
-  const objectId: string | undefined = obj?.objectId
-  const inner = obj?.content?.fields?.data?.fields
+  const objectId: string | undefined = entry?.objectId
+  const inner = structFields(structFields(entry?.json)?.data)
   const gateId: string | undefined = inner?.gate_id ?? inner?.gateId
   if (!objectId || !gateId) return null
   return { objectId, gateId, usesRemaining: parseUsesRemaining(inner?.variant) }
@@ -63,12 +77,12 @@ export async function fetchAccessNfts(
   nftType: string,
   gateId?: string,
 ): Promise<OwnedAccessNft[]> {
-  const { data } = await client.getOwnedObjects({
+  const { objects } = await client.core.listOwnedObjects({
     owner,
-    filter: { StructType: nftType },
-    options: { showContent: true, showType: true },
+    type: nftType,
+    include: { json: true },
   })
-  const parsed = (data ?? [])
+  const parsed = (objects ?? [])
     .map(parseOwnedAccessNft)
     .filter((n): n is OwnedAccessNft => n !== null)
   return gateId ? parsed.filter((n) => n.gateId === gateId) : parsed

package/src/lib/deploy.ts

@@ -2,6 +2,7 @@
 // Decoupled from the wallet via an `Executor` so it is unit-testable.
 
 import type { Transaction } from '@mysten/sui/transactions'
+import type { SuiClientTypes } from '@mysten/sui/client'
 import { patchTemplateModule } from './template.js'
 import {
   buildPublishTransaction,
@@ -25,6 +26,41 @@ export interface SuiTxResult {
   effects?: { status?: { status?: string; error?: string } }
 }
 
+/** The core-API execution result {@link toSuiTxResult} consumes (effects + object types). */
+export type CoreExecutionResult = SuiClientTypes.TransactionResult<{
+  effects: true
+  objectTypes: true
+}>
+
+/**
+ * Map a core-API (gRPC) execution result onto {@link SuiTxResult}: created/mutated objects
+ * come from `effects.changedObjects` (types from the `objectTypes` map), and a newly written
+ * package becomes the `published` entry. Failed transactions are returned with a failure
+ * status (not thrown) so {@link deployToken}'s `assertSuccess` reports them uniformly.
+ */
+export function toSuiTxResult(res: CoreExecutionResult): SuiTxResult {
+  const tx = res.Transaction ?? res.FailedTransaction
+  const types = tx.objectTypes ?? {}
+  const objectChanges: NonNullable<SuiTxResult['objectChanges']> = []
+  for (const c of tx.effects?.changedObjects ?? []) {
+    if (c.outputState === 'PackageWrite') {
+      if (c.idOperation === 'Created') objectChanges.push({ type: 'published', packageId: c.objectId })
+    } else if (c.outputState === 'ObjectWrite') {
+      objectChanges.push({
+        type: c.idOperation === 'Created' ? 'created' : 'mutated',
+        objectId: c.objectId,
+        objectType: types[c.objectId],
+        version: c.outputVersion ?? undefined,
+        digest: c.outputDigest ?? undefined,
+      })
+    }
+  }
+  const status = tx.status.success
+    ? { status: 'success' }
+    : { status: 'failure', error: tx.status.error.message }
+  return { digest: tx.digest, objectChanges, effects: { status } }
+}
+
 export interface Executor {
   /** Sign with the wallet and execute; must request object changes + effects. */
   signAndExecute(tx: Transaction): Promise<SuiTxResult>

package/src/lib/deployExecutor.ts

@@ -1,23 +1,25 @@
 // Builds a deploy Executor using the wallet-adapter's shared signing capability
-// + SuiClient for execution (returns objectChanges required by extractPublishResult).
+// + the app's gRPC client for execution (returns the object changes required by
+// extractPublishResult).
 //
 // The wallet-adapter's own Executor only returns { digest } which is not sufficient
 // for the token deploy flow; we sign via the shared wallet connection but execute
-// via SuiClient so we can request showEffects + showObjectChanges.
+// via our own client so we can request effects + object types.
 
-import { SuiJsonRpcClient } from '@mysten/sui/jsonRpc'
+import { fromBase64 } from '@mysten/sui/utils'
 import { useWallet } from '@meddleware/wallet-adapter'
 import type { Transaction } from '@mysten/sui/transactions'
+import { toSuiTxResult } from './deploy.js'
 import type { SuiTxResult, Executor } from './deploy.js'
 import type { Network } from './types.js'
-import { RPC_URLS } from '../config.js'
+import { getReadClient } from './readClient.js'
 
 /**
  * Build a deploy Executor bound to the currently connected wallet (via the
- * wallet-adapter singleton) and the given network's RPC URL.
+ * wallet-adapter singleton) and the given network's gRPC client.
  *
  * The returned executor signs via `sui:signTransaction` and executes via
- * `SuiClient.executeTransactionBlock` with `showEffects + showObjectChanges`
+ * `executeTransaction` with `effects + objectTypes`, mapped by {@link toSuiTxResult}
  * so the caller can extract the published package ID, coin type, TreasuryCap, etc.
  */
 export async function buildDeployExecutor(network: Network): Promise<Executor> {
@@ -26,7 +28,7 @@ export async function buildDeployExecutor(network: Network): Promise<Executor> {
   const acct = account.value
   if (!wallet || !acct) throw new Error('Connect a wallet first.')
 
-  const suiClient = new SuiJsonRpcClient({ url: RPC_URLS[network], network })
+  const suiClient = getReadClient(network)
   const chain = `sui:${network}` as const
 
   const signFeature = wallet.features['sui:signTransaction'] as
@@ -47,12 +49,12 @@ export async function buildDeployExecutor(network: Network): Promise<Executor> {
         account: acct,
         chain,
       })
-      const res = await suiClient.executeTransactionBlock({
-        transactionBlock: bytes,
-        signature,
-        options: { showEffects: true, showObjectChanges: true },
+      const res = await suiClient.executeTransaction({
+        transaction: fromBase64(bytes),
+        signatures: [signature],
+        include: { effects: true, objectTypes: true },
       })
-      return res as unknown as SuiTxResult
+      return toSuiTxResult(res)
     },
     async waitForTransaction(digest: string): Promise<void> {
       await suiClient.waitForTransaction({ digest })

package/src/lib/generatePackage.ts

@@ -122,12 +122,12 @@ function renderMoveToml(cfg: TokenConfig): string {
 function renderSource(cfg: TokenConfig): string {
   let out = files['source.move']
 
-  // license header (lines 1-2)
+  // license header (lines 1-2) — always rewritten, whatever licence the template itself carries
   const lines = out.split('\n')
   if (isProprietary(cfg.license)) {
     lines[0] = '// SPDX-License-Identifier: UNLICENSED'
     lines[1] = '// All rights reserved. Proprietary and not licensed for redistribution.'
-  } else if (spdxId(cfg.license) !== 'CC0-1.0') {
+  } else {
     lines[0] = `// SPDX-License-Identifier: ${spdxId(cfg.license)}`
     lines[1] = `// Licensed under the ${spdxId(cfg.license)} license; see the LICENSE file.`
   }
@@ -157,18 +157,18 @@ function renderPublishScript(cfg: TokenConfig): string {
   return out
 }
 
+/** The template README's licence line, whatever licence the template itself ships with. */
+const TEMPLATE_LICENSE_LINE = /^(?:CC0 1\.0 Universal|BSD Zero Clause License).*$/m
+
 function renderReadme(cfg: TokenConfig): string {
-  let out = applyDocPlaceholders(files['README.md'], cfg)
+  const out = applyDocPlaceholders(files['README.md'], cfg)
   const licenseName = cfg.licenseName || spdxId(cfg.license)
-  if (isProprietary(cfg.license)) {
-    out = out.replace(
-      /^CC0 1\.0 Universal.*$/m,
-      'All rights reserved. This package is proprietary and not licensed for redistribution.',
-    )
-  } else if (spdxId(cfg.license) !== 'CC0-1.0') {
-    out = out.replace(/^CC0 1\.0 Universal.*$/m, `${licenseName} — see the LICENSE file.`)
-  }
-  return out
+  return out.replace(
+    TEMPLATE_LICENSE_LINE,
+    isProprietary(cfg.license)
+      ? 'All rights reserved. This package is proprietary and not licensed for redistribution.'
+      : `${licenseName} — see the LICENSE file.`,
+  )
 }
 
 /**

package/src/lib/licenses.ts

@@ -23,9 +23,9 @@ export const NO_LICENSE: SpdxLicense = {
   deprecated: false,
 }
 
-/** Ids surfaced first in the picker. CC0 is the project default. */
+/** Ids surfaced first in the picker. 0BSD is the project default; CC0 stays available. */
 export const POPULAR_LICENSE_IDS = [
-  'CC0-1.0',
+  '0BSD',
   'MIT',
   'Apache-2.0',
   'BSD-3-Clause',
@@ -37,9 +37,10 @@ export const POPULAR_LICENSE_IDS = [
   'MPL-2.0',
   'ISC',
   'Unlicense',
+  'CC0-1.0',
 ] as const
 
-export const DEFAULT_LICENSE_ID = 'CC0-1.0'
+export const DEFAULT_LICENSE_ID = '0BSD'
 
 type Fetcher = typeof fetch
 

package/src/lib/listMyTokens.ts

@@ -19,25 +19,21 @@ export interface DeployedToken {
 /** List the coins `owner` has deployed on `network` (via owned `TreasuryCap<T>` objects). */
 export async function listMyTokens(owner: string, network: Network): Promise<DeployedToken[]> {
   const client = getReadClient(network)
-  // The StructType filter without type params matches every TreasuryCap<T> instantiation.
-  const res = await client.getOwnedObjects({
-    owner,
-    filter: { StructType: '0x2::coin::TreasuryCap' },
-    options: { showType: true },
-  })
+  // A type filter without type params matches every TreasuryCap<T> instantiation.
+  const { objects } = await client.listOwnedObjects({ owner, type: '0x2::coin::TreasuryCap' })
   const seen = new Set<string>()
   const out: DeployedToken[] = []
-  for (const item of res.data ?? []) {
-    const data = item.data
-    const m = String(data?.type ?? '').match(/^0x2::coin::TreasuryCap<(.+)>$/)
-    if (!m || !data) continue
+  for (const obj of objects) {
+    // gRPC may render the framework address in long form (0x000…02).
+    const m = obj.type.match(/^0x0*2::coin::TreasuryCap<(.+)>$/)
+    if (!m) continue
     const coinType = m[1]
     if (seen.has(coinType)) continue
     seen.add(coinType)
     out.push({
       coinType,
       packageId: coinType.split('::')[0] ?? '',
-      treasuryCapId: data.objectId,
+      treasuryCapId: obj.objectId,
       label: coinType.split('::').pop() ?? coinType,
     })
   }

package/src/lib/readClient.ts

@@ -1,17 +1,25 @@
-// Cached SuiClient per network for read-only queries (getOwnedObjects, etc.).
-// Replaces getSuiClient from the deleted useSuiClient.ts composable.
-import { SuiJsonRpcClient } from '@mysten/sui/jsonRpc'
+// Cached gRPC client per network, shared by read-only queries (listOwnedObjects, etc.) and
+// the deploy executor. Public fullnodes have deprecated JSON-RPC, so this is a SuiGrpcClient.
+import { SuiGrpcClient } from '@mysten/sui/grpc'
 import type { Network } from './types.js'
 import { RPC_URLS } from '../config.js'
 
-const clients = new Map<Network, SuiJsonRpcClient>()
+const clients = new Map<Network, SuiGrpcClient>()
 
-/** Return a memoised {@link SuiJsonRpcClient} for the given network. */
-export function getReadClient(network: Network): SuiJsonRpcClient {
+/** Return a memoised {@link SuiGrpcClient} for the given network. */
+export function getReadClient(network: Network): SuiGrpcClient {
   let c = clients.get(network)
   if (!c) {
-    c = new SuiJsonRpcClient({ url: RPC_URLS[network], network })
+    c = new SuiGrpcClient({ network, baseUrl: RPC_URLS[network] })
     clients.set(network, c)
   }
   return c
 }
+
+/**
+ * Replace the client for `network` (E2E builds only — lets `main.ts` inject a stub client in
+ * place of the network, since gRPC-web responses are binary and cannot be faked via `fetch`).
+ */
+export function setReadClient(network: Network, client: SuiGrpcClient): void {
+  clients.set(network, client)
+}

package/src/lib/types.ts

@@ -41,7 +41,7 @@ export interface TokenConfig {
   /** Address that receives the caps + initial supply. Defaults to the connected wallet. */
   recipient: string
 
-  /** SPDX id (e.g. "MIT", "CC0-1.0") or "NONE" for proprietary. Affects the downloadable package only. */
+  /** SPDX id (e.g. "0BSD", "MIT") or "NONE" for proprietary. Affects the downloadable package only. */
   license: string
   /** Human-readable license name for the README (defaults to the SPDX id). */
   licenseName?: string

package/src/lib/walrus.ts

@@ -12,7 +12,7 @@
 
 import { SuiGrpcClient } from '@mysten/sui/grpc'
 import { walrus, blobIdFromInt } from '@mysten/walrus'
-import type { SuiJsonRpcClient } from '@mysten/sui/jsonRpc'
+import type { ClientWithCoreApi } from '@mysten/sui/client'
 import { WALRUS_RELAY_HOSTS, WALRUS_MAX_TIP_MIST, WALRUS_RPC_URLS } from '../config.js'
 
 export { ICON_EPOCHS } from './walrus-constants.js'
@@ -107,33 +107,44 @@ export interface OwnedBlob {
   certified: boolean
 }
 
+/**
+ * Unwrap a Move-struct field bag from a core `json` value. The gRPC/core API returns struct
+ * fields flat; the old JSON-RPC shape nested them under `.fields`. Tolerate both, since the
+ * SDK documents that the `json` shape may vary between API implementations.
+ */
+function structFields(v: unknown): Record<string, unknown> | undefined {
+  if (!v || typeof v !== 'object') return undefined
+  const o = v as Record<string, unknown>
+  const nested = o.fields
+  return nested && typeof nested === 'object' ? (nested as Record<string, unknown>) : o
+}
+
 /**
  * Return all Walrus blobs owned by `owner`. Uses `getBlobType()` for dynamic
  * package resolution so no hardcoded addresses are needed.
  */
 export async function fetchOwnedWalrusBlobs(
-  suiClient: SuiJsonRpcClient,
+  suiClient: ClientWithCoreApi,
   walrusClient: ReturnType<typeof createWalrusClient>,
   owner: string,
 ): Promise<OwnedBlob[]> {
   const blobType = await walrusClient.walrus.getBlobType()
-  const { data } = await suiClient.getOwnedObjects({
+  const { objects } = await suiClient.core.listOwnedObjects({
     owner,
-    filter: { StructType: blobType },
-    options: { showContent: true },
+    type: blobType,
+    include: { json: true },
   })
   const blobs: OwnedBlob[] = []
-  for (const item of data) {
-    if (!item.data) continue
-    const fields = (item.data.content as { fields?: Record<string, unknown> } | undefined)?.fields
+  for (const obj of objects) {
+    const fields = structFields(obj.json)
     if (!fields) continue
-    const storage = fields.storage as { fields?: { end_epoch?: unknown } } | undefined
+    const storage = structFields(fields.storage)
     try {
       blobs.push({
-        objectId: item.data.objectId,
+        objectId: obj.objectId,
         blobId: blobIdFromInt(BigInt(fields.blob_id as string)),
         size: Number(fields.size),
-        endEpoch: Number(storage?.fields?.end_epoch ?? 0),
+        endEpoch: Number(storage?.end_epoch ?? 0),
         certified: fields.certified_epoch !== null && fields.certified_epoch !== undefined,
       })
     } catch {

package/src/main.ts

@@ -8,7 +8,8 @@ import './component-styles.css'
 import { configureWasm } from './lib/template.js'
 // Static: readClient is already in the main chunk (IconPicker, WalrusBlobBrowser and listMyTokens
 // import it), so a dynamic import in the E2E block below could not split it out anyway.
-import { getReadClient } from './lib/readClient.js'
+import { getReadClient, setReadClient } from './lib/readClient.js'
+import type { SuiGrpcClient } from '@mysten/sui/grpc'
 import { useColorMode, useSeason } from '@meddleware/ui'
 
 // Apply the colour mode before mount so there is no theme flash. Defaults to
@@ -25,72 +26,54 @@ import wasmUrl from '@mysten/move-bytecode-template/web/move_bytecode_template_b
 // doesn't block initial page load.
 configureWasm(wasmUrl)
 
-// E2E-only: register mock wallet and expose getSuiClient for headless tests.
+// E2E-only: stub the Sui client, register a mock wallet and expose getSuiClient for headless tests.
 // Wrapped in async IIFE to ensure wallet is registered BEFORE app mounts (timing critical).
 // Tree-shaking removes this entire block from production when VITE_E2E !== '1'.
 ;(async () => {
   if (import.meta.env.VITE_E2E === '1') {
     const { getWallets } = await import('@mysten/wallet-standard')
 
-    // Mock fetch globally for RPC requests so Cypress intercepts are bypassed entirely
-    const originalFetch = globalThis.fetch
-    const publishDigest = '0x' + 'aa'.repeat(32)
+    // Stub gRPC client in place of the network (gRPC-web is binary, so it cannot be faked
+    // at the fetch layer). Returns a successful publish whose effects carry the created
+    // TreasuryCap/MetadataCap, and empty owned-object lists.
+    const publishDigest = 'E2E' + 'a'.repeat(41)
     const packageId = '0x' + 'bb'.repeat(32)
-    const treasureCapId = '0x' + 'cc'.repeat(32)
+    const treasuryCapId = '0x' + 'cc'.repeat(32)
     const metadataCapId = '0x' + 'dd'.repeat(32)
-
-    const mockRpcResponse = {
-      digest: publishDigest,
-      effects: {
-        status: { status: 'success' },
-        gasUsed: { computationCost: '1000', storageCost: '2000', storageRebate: '0' },
-      },
-      objectChanges: [
-        { type: 'published', packageId },
-        {
-          type: 'created',
-          objectType: `0x2::coin::TreasuryCap<${packageId}::mytoken::MYTOKEN>`,
-          objectId: treasureCapId,
+    const created = (objectId: string) => ({
+      objectId,
+      outputState: 'ObjectWrite',
+      idOperation: 'Created',
+      outputVersion: '1',
+      outputDigest: publishDigest,
+    })
+    const executed = {
+      $kind: 'Transaction',
+      Transaction: {
+        digest: publishDigest,
+        status: { success: true, error: null },
+        effects: {
+          changedObjects: [
+            { objectId: packageId, outputState: 'PackageWrite', idOperation: 'Created' },
+            created(treasuryCapId),
+            created(metadataCapId),
+          ],
         },
-        {
-          type: 'created',
-          objectType: `0x2::coin_registry::MetadataCap<${packageId}::mytoken::MYTOKEN>`,
-          objectId: metadataCapId,
+        objectTypes: {
+          [treasuryCapId]: `0x2::coin::TreasuryCap<${packageId}::mytoken::MYTOKEN>`,
+          [metadataCapId]: `0x2::coin_registry::MetadataCap<${packageId}::mytoken::MYTOKEN>`,
         },
-      ],
-      events: [],
-      transaction: null,
-      balanceChanges: null,
-    }
-
-    globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
-      const url = typeof input === 'string' ? input : input.toString()
-      const method = init?.method || 'GET'
-      const isRpcCall = (url.includes('fullnode') || url.includes('rpc')) && method === 'POST'
-
-      if (isRpcCall) {
-        const body = init?.body ? JSON.parse(String(init.body)) : {}
-        const rpcMethod = body.method
-
-        if (import.meta.env.VITE_E2E === '1') {
-          console.log('[E2E Fetch Mock]', rpcMethod, 'URL:', url)
-        }
-
-        const result =
-          rpcMethod === 'sui_executeTransactionBlock' || rpcMethod === 'sui_getTransactionBlock'
-            ? mockRpcResponse
-            : rpcMethod === 'suix_getCoins' || rpcMethod === 'suix_getBalance'
-              ? { data: [], nextCursor: null, hasNextPage: false }
-              : null
-
-        return new Response(JSON.stringify({ jsonrpc: '2.0', id: body.id || 1, result }), {
-          status: 200,
-          headers: { 'content-type': 'application/json' },
-        })
-      }
-
-      return originalFetch(input, init)
+      },
     }
+    const noObjects = async () => ({ objects: [], hasNextPage: false, cursor: null })
+    const stubClient = {
+      executeTransaction: async () => executed,
+      waitForTransaction: async () => executed,
+      listOwnedObjects: noObjects,
+      core: { listOwnedObjects: noObjects },
+    } as unknown as SuiGrpcClient
+    setReadClient('testnet', stubClient)
+    setReadClient('mainnet', stubClient)
 
     const E2E_ADDR = '0x' + 'a'.repeat(64)
     const E2E_PUB_KEY = new Uint8Array(32)