@0xobelisk/sui-cli 1.2.0-pre.119 → 1.2.0-pre.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xobelisk/sui-cli",
-  "version": "1.2.0-pre.119",
+  "version": "1.2.0-pre.120",
   "description": "Tookit for interacting with move eps framework",
   "keywords": [
     "sui",
@@ -47,8 +47,8 @@
     "yargs": "^17.7.1",
     "zod": "^3.22.3",
     "zod-validation-error": "^1.3.0",
-    "@0xobelisk/sui-client": "1.2.0-pre.119",
-    "@0xobelisk/sui-common": "1.2.0-pre.119"
+    "@0xobelisk/sui-client": "1.2.0-pre.120",
+    "@0xobelisk/sui-common": "1.2.0-pre.120"
   },
   "devDependencies": {
     "@types/cli-progress": "^3.11.5",

package/src/commands/build.ts

@@ -10,6 +10,7 @@ type Options = {
   'config-path': string;
   network: any;
   'dump-bytecode-as-base64'?: boolean;
+  'rpc-url'?: string;
 };
 
 /**
@@ -61,6 +62,10 @@ const commandModule: CommandModule<Options, Options> = {
         type: 'boolean',
         default: false,
         desc: 'Dump bytecode as base64'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
       }
     });
   },
@@ -68,7 +73,8 @@ const commandModule: CommandModule<Options, Options> = {
   async handler({
     'config-path': configPath,
     network,
-    'dump-bytecode-as-base64': dumpBytecodeAsBase64
+    'dump-bytecode-as-base64': dumpBytecodeAsBase64,
+    'rpc-url': rpcUrl
   }) {
     try {
       if (network == 'default') {
@@ -77,7 +83,7 @@ const commandModule: CommandModule<Options, Options> = {
       }
       console.log('🚀 Running move build');
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-      await switchEnv(network);
+      await switchEnv(network, rpcUrl);
 
       const projectPath = nodePath.join(process.cwd(), 'src', dubheConfig.name);
       const lintResults = lintSystemGuards(projectPath);

package/src/commands/checkBalance.ts

@@ -6,26 +6,34 @@ import { getDefaultNetwork } from '../utils';
 
 type Options = {
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet' | 'default';
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
   command: 'check-balance',
   describe: 'Check the balance of the account',
-  builder: {
-    network: {
-      type: 'string',
-      choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
-      desc: 'Network to check balance on',
-      default: 'default'
-    }
+  builder(yargs) {
+    return yargs.options({
+      network: {
+        type: 'string',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
+        desc: 'Network to check balance on',
+        default: 'default'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
+      }
+    }) as any;
   },
-  async handler({ network }) {
+  async handler({ network, 'rpc-url': rpcUrl }) {
     try {
       if (network == 'default') {
         network = await getDefaultNetwork();
         console.log(chalk.yellow(`Use default network: [${network}]`));
       }
-      await checkBalanceHandler(network);
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      await checkBalanceHandler(network, fullnodeUrls);
     } catch (error) {
       console.error('Error checking balance:', error);
       handlerExit(1);

package/src/commands/faucet.ts

@@ -7,6 +7,7 @@ import { handlerExit } from './shell';
 type Options = {
   network: any;
   recipient?: string;
+  'rpc-url'?: string;
 };
 
 const MAX_RETRIES = 60; // 60s timeout
@@ -30,14 +31,18 @@ const commandModule: CommandModule<Options, Options> = {
         type: 'string',
         alias: 'r',
         desc: 'Sui address to fund'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL for balance check (overrides the default for the selected network)'
       }
     });
   },
 
-  async handler({ network, recipient }) {
+  async handler({ network, recipient, 'rpc-url': rpcUrl }) {
     let faucet_address = '';
     if (recipient === undefined) {
-      const dubhe = initializeDubhe(network);
+      const dubhe = initializeDubhe({ network });
       faucet_address = dubhe.getAddress();
     } else {
       faucet_address = recipient;
@@ -108,7 +113,7 @@ const commandModule: CommandModule<Options, Options> = {
     process.stdout.write('\r' + ' '.repeat(50) + '\r');
 
     console.log('  └─ Checking balance...');
-    const client = new SuiClient({ url: getFullnodeUrl(network) });
+    const client = new SuiClient({ url: rpcUrl || getFullnodeUrl(network) });
     let params = {
       owner: faucet_address
     } as GetBalanceParams;

package/src/commands/info.ts

@@ -7,6 +7,7 @@ dotenv.config();
 
 type Options = {
   network: any;
+  'rpc-url'?: string;
 };
 
 const InfoCommand: CommandModule<Options, Options> = {
@@ -19,16 +20,21 @@ const InfoCommand: CommandModule<Options, Options> = {
         choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
         default: 'default',
         desc: 'Node network (mainnet/testnet/devnet/localnet)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
       }
     });
   },
-  handler: async ({ network }) => {
+  handler: async ({ network, 'rpc-url': rpcUrl }) => {
     try {
       if (network == 'default') {
         network = await getDefaultNetwork();
         console.log(chalk.yellow(`Use default network: [${network}]`));
       }
-      const dubhe = initializeDubhe({ network });
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      const dubhe = initializeDubhe({ network, fullnodeUrls });
       const keypair = dubhe.getSigner();
 
       console.log(chalk.blue('Account Information:'));

package/src/commands/loadMetadata.ts

@@ -10,6 +10,7 @@ type Options = {
   network: any;
   'config-path': string;
   'package-id'?: string;
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -34,18 +35,28 @@ const commandModule: CommandModule<Options, Options> = {
         type: 'string',
         desc: 'Package ID to load metadata for',
         optional: true
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
       }
     });
   },
 
-  async handler({ network, 'config-path': configPath, 'package-id': packageId }) {
+  async handler({
+    network,
+    'config-path': configPath,
+    'package-id': packageId,
+    'rpc-url': rpcUrl
+  }) {
     try {
       if (network == 'default') {
         network = await getDefaultNetwork();
         console.log(chalk.yellow(`Use default network: [${network}]`));
       }
       const dubheConfig = (await loadConfig(configPath)) as DubheConfig;
-      await loadMetadataHandler(dubheConfig, network, packageId);
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      await loadMetadataHandler(dubheConfig, network, packageId, fullnodeUrls);
     } catch (error: any) {
       logError(error);
       handlerExit(1);

package/src/commands/publish.ts

@@ -18,6 +18,7 @@ type Options = {
   'config-path': string;
   force: boolean;
   'gas-budget'?: number;
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -47,11 +48,21 @@ const commandModule: CommandModule<Options, Options> = {
         type: 'boolean',
         default: false,
         desc: 'Clear existing published state for this network before build (use when re-publishing or to fix PublishErrorNonZeroAddress)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
       }
     });
   },
 
-  async handler({ network, 'config-path': configPath, 'gas-budget': gasBudget, force }) {
+  async handler({
+    network,
+    'config-path': configPath,
+    'gas-budget': gasBudget,
+    force,
+    'rpc-url': rpcUrl
+  }) {
     try {
       if (network == 'default') {
         network = await getDefaultNetwork();
@@ -73,8 +84,9 @@ const commandModule: CommandModule<Options, Options> = {
         }
       }
 
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
       execSync(`pnpm dubhe convert-json --config-path ${configPath}`, { encoding: 'utf-8' });
-      await publishHandler(dubheConfig, network, force, gasBudget);
+      await publishHandler(dubheConfig, network, force, gasBudget, fullnodeUrls);
     } catch (error: any) {
       logError(error);
       handlerExit(1);

package/src/commands/shell.ts

@@ -20,6 +20,7 @@ export const handlerExit = (status: number = 0) => {
 
 type Options = {
   network: any;
+  'rpc-url'?: string;
 };
 
 const parseCommandNames = () => {
@@ -38,10 +39,14 @@ const ShellCommand: CommandModule<Options, Options> = {
         choices: ['mainnet', 'testnet', 'devnet', 'localnet', 'default'],
         default: 'default',
         desc: 'Node network (mainnet/testnet/devnet/localnet)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL injected into every sub-command (overrides the default for the selected network)'
       }
     });
   },
-  handler: async ({ network }) => {
+  handler: async ({ network, 'rpc-url': rpcUrl }) => {
     if (network == 'default') {
       network = await getDefaultNetwork();
       console.log(chalk.yellow(`Use default network: [${network}]`));
@@ -60,7 +65,9 @@ const ShellCommand: CommandModule<Options, Options> = {
     const rl = readline.createInterface({
       input: process.stdin,
       output: process.stdout,
-      prompt: `dubhe(${chalk.green(network)}) ${chalk.bold('>')} `,
+      prompt: `dubhe(${chalk.green(network)}${
+        rpcUrl ? chalk.gray('[custom-rpc]') : ''
+      }) ${chalk.bold('>')} `,
       completer: completer,
       historySize: 200
     });
@@ -134,9 +141,11 @@ const ShellCommand: CommandModule<Options, Options> = {
             }
             const userArgs = parts.slice(1);
             const hasNetworkFlag = userArgs.includes('--network') || userArgs.includes('-n');
+            const hasRpcUrlFlag = userArgs.includes('--rpc-url');
             const argv = yargsInstance.parseSync([
               commandName,
               ...(hasNetworkFlag ? [] : ['--network', network]),
+              ...(hasRpcUrlFlag || !rpcUrl ? [] : ['--rpc-url', rpcUrl]),
               ...userArgs
             ]);
             if (handler) {

package/src/commands/switchEnv.ts

@@ -4,21 +4,28 @@ import { handlerExit } from './shell';
 
 type Options = {
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet' | 'default';
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
   command: 'switch-env',
   describe: 'Switch environment',
   builder(yargs) {
-    return yargs.option('network', {
-      type: 'string',
-      choices: ['mainnet', 'testnet', 'devnet', 'localnet'] as const,
-      default: 'localnet',
-      desc: 'Switch to node network (mainnet/testnet/devnet/localnet)'
+    return yargs.options({
+      network: {
+        type: 'string',
+        choices: ['mainnet', 'testnet', 'devnet', 'localnet'] as const,
+        default: 'localnet',
+        desc: 'Switch to node network (mainnet/testnet/devnet/localnet)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
+      }
     }) as any;
   },
   async handler(argv: ArgumentsCamelCase<Options>) {
-    await switchEnv(argv.network as 'mainnet' | 'testnet' | 'devnet' | 'localnet');
+    await switchEnv(argv.network as 'mainnet' | 'testnet' | 'devnet' | 'localnet', argv['rpc-url']);
     handlerExit();
   }
 };

package/src/commands/upgrade.ts

@@ -11,6 +11,7 @@ type Options = {
   network: any;
   'config-path': string;
   'bump-version': boolean;
+  'rpc-url'?: string;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -35,11 +36,20 @@ const commandModule: CommandModule<Options, Options> = {
         type: 'boolean',
         default: false,
         desc: 'Force a version bump even when no new resources were added (use for breaking logic changes or security fixes that must invalidate old clients)'
+      },
+      'rpc-url': {
+        type: 'string',
+        desc: 'Custom RPC endpoint URL (overrides the default for the selected network)'
       }
     });
   },
 
-  async handler({ network, 'config-path': configPath, 'bump-version': bumpVersion }) {
+  async handler({
+    network,
+    'config-path': configPath,
+    'bump-version': bumpVersion,
+    'rpc-url': rpcUrl
+  }) {
     try {
       if (network == 'default') {
         network = await getDefaultNetwork();
@@ -61,7 +71,8 @@ const commandModule: CommandModule<Options, Options> = {
         }
       }
 
-      await upgradeHandler(dubheConfig, dubheConfig.name, network, bumpVersion);
+      const fullnodeUrls = rpcUrl ? [rpcUrl] : undefined;
+      await upgradeHandler(dubheConfig, dubheConfig.name, network, bumpVersion, fullnodeUrls);
     } catch (error: any) {
       logError(error);
       handlerExit(1);

package/src/utils/checkBalance.ts

@@ -4,10 +4,14 @@ import { initializeDubhe } from './utils';
 import { DubheCliError } from './errors';
 dotenv.config();
 
-export async function checkBalanceHandler(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet') {
+export async function checkBalanceHandler(
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  fullnodeUrls?: string[]
+) {
   try {
     const dubhe = initializeDubhe({
-      network
+      network,
+      fullnodeUrls
     });
 
     const balance = await dubhe.getBalance();

package/src/utils/metadataHandler.ts

@@ -4,13 +4,14 @@ import { getOldPackageId, saveMetadata } from './utils';
 export async function loadMetadataHandler(
   dubheConfig: DubheConfig,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-  packageId?: string
+  packageId?: string,
+  fullnodeUrls?: string[]
 ) {
   if (packageId) {
-    await saveMetadata(dubheConfig.name, network, packageId);
+    await saveMetadata(dubheConfig.name, network, packageId, fullnodeUrls);
   } else {
     const projectPath = `${process.cwd()}/src/${dubheConfig.name}`;
     const packageId = await getOldPackageId(projectPath, network);
-    await saveMetadata(dubheConfig.name, network, packageId);
+    await saveMetadata(dubheConfig.name, network, packageId, fullnodeUrls);
   }
 }

package/src/utils/publishHandler.ts

@@ -11,6 +11,7 @@ import {
   saveMetadata,
   getOriginalDubhePackageId,
   updatePublishedToml,
+  syncDubheFrameworkAddress,
   updateEphemeralPubFile,
   getEphemeralPubFilePath,
   getPublishedTomlEntry,
@@ -246,7 +247,8 @@ async function publishContract(
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
   projectPath: string,
   gasBudget?: number,
-  force?: boolean
+  force?: boolean,
+  fullnodeUrls?: string[]
 ) {
   console.log('\n🚀 Starting Contract Publication...');
   console.log(`  ├─ Project: ${projectPath}`);
@@ -259,6 +261,14 @@ async function publishContract(
   await removeEnvContent(`${projectPath}/Move.lock`, network);
   console.log(`  └─ Account: ${dubhe.getAddress()}`);
 
+  // Ensure src/dubhe/Published.toml references the canonical framework address
+  // for this network before building.  This is a no-op when the address is
+  // already current, and automatically corrects stale entries whenever the
+  // framework is redeployed on testnet/mainnet without a manual file update.
+  if (dubheConfig.name !== 'dubhe') {
+    syncDubheFrameworkAddress(process.cwd(), network, chainId);
+  }
+
   console.log('\n📦 Building Contract...');
   // For localnet: pass the ephemeral pubfile so the build system can resolve
   // the dubhe dependency that was just published in publishDubheFramework().
@@ -506,7 +516,7 @@ async function publishContract(
       dappStorageId || undefined
     );
 
-    await saveMetadata(dubheConfig.name, network, packageId);
+    await saveMetadata(dubheConfig.name, network, packageId, fullnodeUrls);
 
     // Insert package id to dubhe config
     let config = JSON.parse(fs.readFileSync(`${process.cwd()}/dubhe.config.json`, 'utf-8'));
@@ -717,12 +727,14 @@ export async function publishHandler(
   dubheConfig: DubheConfig,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
   force: boolean,
-  gasBudget?: number
+  gasBudget?: number,
+  fullnodeUrls?: string[]
 ) {
-  await switchEnv(network);
+  await switchEnv(network, fullnodeUrls?.[0]);
 
   const dubhe = initializeDubhe({
-    network
+    network,
+    fullnodeUrls
   });
 
   const path = process.cwd();
@@ -732,5 +744,5 @@ export async function publishHandler(
     await publishDubheFramework(dubhe, network);
   }
 
-  await publishContract(dubhe, dubheConfig, network, projectPath, gasBudget, force);
+  await publishContract(dubhe, dubheConfig, network, projectPath, gasBudget, force, fullnodeUrls);
 }

package/src/utils/upgradeHandler.ts

@@ -16,6 +16,7 @@ import {
   getDappStorageId,
   getOriginalDubhePackageId,
   updatePublishedToml,
+  syncDubheFrameworkAddress,
   clearPublishedTomlEntry,
   restorePublishedTomlEntry,
   readPublishedToml,
@@ -76,14 +77,15 @@ export async function upgradeHandler(
   config: DubheConfig,
   name: string,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-  bumpVersion: boolean = false
+  bumpVersion: boolean = false,
+  fullnodeUrls?: string[]
 ) {
-  await switchEnv(network);
+  await switchEnv(network, fullnodeUrls?.[0]);
 
   const path = process.cwd();
   const projectPath = `${path}/src/${name}`;
 
-  const dubhe = initializeDubhe({ network });
+  const dubhe = initializeDubhe({ network, fullnodeUrls });
 
   let oldVersion = Number(await getVersion(projectPath, network));
   let oldPackageId = await getOldPackageId(projectPath, network);
@@ -130,6 +132,15 @@ export async function upgradeHandler(
   const savedPublishedEntry =
     network !== 'localnet' ? clearPublishedTomlEntry(projectPath, network) : undefined;
 
+  // For testnet/mainnet: auto-sync src/dubhe/Published.toml to the canonical
+  // framework address from the SDK before building.  Prevents
+  // VMVerificationOrDeserializationError when the framework was redeployed
+  // since the Published.toml was last written.  Skip when upgrading dubhe itself.
+  if (name !== 'dubhe' && (network === 'testnet' || network === 'mainnet')) {
+    const chainId = await dubhe.suiInteractor.currentClient.getChainIdentifier();
+    syncDubheFrameworkAddress(path, network, chainId);
+  }
+
   // For localnet upgrades: refresh Pub.localnet.toml with dubhe's current address
   // so that the build can resolve the dubhe dependency.
   // Skip this step when upgrading dubhe itself — dubhe has no local dubhe dependency,

package/src/utils/utils.ts

@@ -250,13 +250,14 @@ export async function saveContractData(
 export async function saveMetadata(
   projectName: string,
   network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
-  packageId: string
+  packageId: string,
+  fullnodeUrls?: string[]
 ) {
   const path = process.cwd();
 
   // Save metadata files
   try {
-    const metadata = await loadMetadata(network, packageId);
+    const metadata = await loadMetadata(network, packageId, fullnodeUrls);
     if (metadata) {
       const metadataJson = JSON.stringify(metadata, null, 2);
 
@@ -396,6 +397,46 @@ export function getPublishedTomlEntry(
   return entries[network];
 }
 
+/**
+ * Syncs the Dubhe framework address in `src/dubhe/Published.toml` with the
+ * canonical package ID from the SDK's `getDefaultConfig` for the given network.
+ *
+ * This prevents `VMVerificationOrDeserializationError` during `publish` and
+ * `upgrade` when the framework has been redeployed on testnet/mainnet but the
+ * local `Published.toml` still references the old address.  The function is a
+ * no-op for localnet and devnet (no stable canonical address exists there).
+ *
+ * @param contractsRootDir - The contracts working directory (process.cwd() in CLI context)
+ * @param network          - Target network
+ * @param chainId          - Live chain identifier obtained from the node
+ */
+export function syncDubheFrameworkAddress(
+  contractsRootDir: string,
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  chainId: string
+): void {
+  if (network === 'localnet' || network === 'devnet') return;
+
+  const frameworkPackageId = getDefaultConfig(network as NetworkType).frameworkPackageId;
+  if (!frameworkPackageId) return;
+
+  const dubhePath = pathJoin(contractsRootDir, 'src', 'dubhe');
+  if (!fs.existsSync(dubhePath)) return;
+
+  const existing = getPublishedTomlEntry(dubhePath, network);
+  if (existing?.publishedAt === frameworkPackageId) return;
+
+  updatePublishedToml(dubhePath, network, chainId, frameworkPackageId, frameworkPackageId, 1);
+  console.log(
+    chalk.gray(
+      `  ├─ Auto-synced dubhe framework address for ${network}: ${frameworkPackageId.slice(
+        0,
+        10
+      )}...`
+    )
+  );
+}
+
 export function clearPublishedTomlEntry(
   packagePath: string,
   network: string
@@ -570,7 +611,8 @@ async function checkRpcAvailability(rpcUrl: string): Promise<boolean> {
 }
 
 export async function addEnv(
-  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet'
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  rpcUrl?: string
 ): Promise<void> {
   const rpcMap = {
     localnet: 'http://127.0.0.1:9000',
@@ -579,13 +621,13 @@ export async function addEnv(
     mainnet: 'https://fullnode.mainnet.sui.io:443/'
   };
 
-  const rpcUrl = rpcMap[network];
+  const resolvedRpcUrl = rpcUrl || rpcMap[network];
 
   // Check RPC availability first
-  const isRpcAvailable = await checkRpcAvailability(rpcUrl);
+  const isRpcAvailable = await checkRpcAvailability(resolvedRpcUrl);
   if (!isRpcAvailable) {
     throw new Error(
-      `RPC endpoint ${rpcUrl} is not available. Please check your network connection or try again later.`
+      `RPC endpoint ${resolvedRpcUrl} is not available. Please check your network connection or try again later.`
     );
   }
 
@@ -595,7 +637,7 @@ export async function addEnv(
 
     const suiProcess = spawn(
       'sui',
-      ['client', 'new-env', '--alias', network, '--rpc', rpcMap[network]],
+      ['client', 'new-env', '--alias', network, '--rpc', resolvedRpcUrl],
       {
         env: { ...process.env },
         stdio: 'pipe'
@@ -716,10 +758,13 @@ export async function getDefaultNetwork(): Promise<NetworkAlias> {
   return currentAlias as NetworkAlias;
 }
 
-export async function switchEnv(network: 'mainnet' | 'testnet' | 'devnet' | 'localnet') {
+export async function switchEnv(
+  network: 'mainnet' | 'testnet' | 'devnet' | 'localnet',
+  rpcUrl?: string
+) {
   try {
     // First, try to add the environment
-    await addEnv(network);
+    await addEnv(network, rpcUrl);
 
     // Then switch to the specified environment
     return new Promise<void>((resolve, reject) => {
@@ -793,18 +838,21 @@ export function loadKey(): string {
 export function initializeDubhe({
   network,
   packageId,
-  metadata
+  metadata,
+  fullnodeUrls
 }: {
   network: NetworkType;
   packageId?: string;
   metadata?: SuiMoveNormalizedModules;
+  fullnodeUrls?: string[];
 }): Dubhe {
   const privateKey = loadKey();
   return new Dubhe({
     networkType: network,
     secretKey: privateKey,
     packageId,
-    metadata
+    metadata,
+    fullnodeUrls
   });
 }