surfman 0.1.2 → 0.1.4

package/dist/index.js

@@ -24,12 +24,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_commander39 = require("commander");
-var import_chalk2 = __toESM(require("chalk"));
+var import_commander57 = require("commander");
+var import_chalk7 = __toESM(require("chalk"));
 
 // src/commands/cheatcodes/time-travel.ts
 var import_commander = require("commander");
-var import_surfman_sdk = require("surfman-sdk");
+var import_sdk = require("@surfman/sdk");
 
 // src/utils/logger.ts
 var import_chalk = __toESM(require("chalk"));
@@ -45,7 +45,7 @@ var logger = {
 function createTimeTravelCommand() {
   const command = new import_commander.Command("time-travel").description("Time travel to a specific epoch, slot, or timestamp").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--epoch <number>", "Absolute epoch number").option("--slot <number>", "Absolute slot number").option("--timestamp <number>", "Absolute timestamp (microseconds)").option("--relative <time>", "Relative time (e.g., +1d, +1w, +12h, +30m)").action(async (options) => {
     try {
-      const client = new import_surfman_sdk.Surfman(options.rpc);
+      const client = new import_sdk.Surfman(options.rpc);
       let config = {};
       if (options.epoch) {
         config.absoluteEpoch = parseInt(options.epoch);
@@ -95,11 +95,11 @@ function createTimeTravelCommand() {
 
 // src/commands/cheatcodes/set-account.ts
 var import_commander2 = require("commander");
-var import_surfman_sdk2 = require("surfman-sdk");
+var import_sdk2 = require("@surfman/sdk");
 function createSetAccountCommand() {
   const command = new import_commander2.Command("set-account").description("Modify account data, lamports, owner, etc.").requiredOption("--pubkey <address>", "Account public key").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--data <hex>", "Account data (hex string)").option("--lamports <amount>", "Account lamports").option("--owner <address>", "Account owner").option("--executable", "Mark account as executable").option("--rent-epoch <epoch>", "Rent epoch").action(async (options) => {
     try {
-      const client = new import_surfman_sdk2.Surfman(options.rpc);
+      const client = new import_sdk2.Surfman(options.rpc);
       const update = {};
       if (options.data) {
         update.data = options.data;
@@ -136,11 +136,11 @@ function createSetAccountCommand() {
 
 // src/commands/cheatcodes/set-program-authority.ts
 var import_commander3 = require("commander");
-var import_surfman_sdk3 = require("surfman-sdk");
+var import_sdk3 = require("@surfman/sdk");
 function createSetProgramAuthorityCommand() {
   const command = new import_commander3.Command("set-program-authority").description("Set or remove program upgrade authority").requiredOption("--program-id <address>", "Program ID").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--new-authority <address>", "New authority address").option("--remove-authority", "Remove authority (make program immutable)").action(async (options) => {
     try {
-      const client = new import_surfman_sdk3.Surfman(options.rpc);
+      const client = new import_sdk3.Surfman(options.rpc);
       let newAuthority;
       if (options.removeAuthority) {
         newAuthority = null;
@@ -171,11 +171,11 @@ function createSetProgramAuthorityCommand() {
 
 // src/commands/cheatcodes/pause-clock.ts
 var import_commander4 = require("commander");
-var import_surfman_sdk4 = require("surfman-sdk");
+var import_sdk4 = require("@surfman/sdk");
 function createPauseClockCommand() {
   const command = new import_commander4.Command("pause-clock").description("Pause the Surfnet clock (freeze time progression)").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
     try {
-      const client = new import_surfman_sdk4.Surfman(options.rpc);
+      const client = new import_sdk4.Surfman(options.rpc);
       const result = await client.cheatcodes.pauseClock();
       logger.success("Clock paused successfully!");
       logger.log(`  Absolute Slot: ${result.absoluteSlot}`);
@@ -195,11 +195,11 @@ function createPauseClockCommand() {
 
 // src/commands/cheatcodes/resume-clock.ts
 var import_commander5 = require("commander");
-var import_surfman_sdk5 = require("surfman-sdk");
+var import_sdk5 = require("@surfman/sdk");
 function createResumeClockCommand() {
   const command = new import_commander5.Command("resume-clock").description("Resume the Surfnet clock (restart time progression)").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
     try {
-      const client = new import_surfman_sdk5.Surfman(options.rpc);
+      const client = new import_sdk5.Surfman(options.rpc);
       const result = await client.cheatcodes.resumeClock();
       logger.success("Clock resumed successfully!");
       logger.log(`  Absolute Slot: ${result.absoluteSlot}`);
@@ -219,11 +219,11 @@ function createResumeClockCommand() {
 
 // src/commands/cheatcodes/get-local-signatures.ts
 var import_commander6 = require("commander");
-var import_surfman_sdk6 = require("surfman-sdk");
+var import_sdk6 = require("@surfman/sdk");
 function createGetLocalSignaturesCommand() {
   const command = new import_commander6.Command("get-local-signatures").description("Get recent local transaction signatures").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--limit <number>", "Maximum number of signatures to return", "50").action(async (options) => {
     try {
-      const client = new import_surfman_sdk6.Surfman(options.rpc);
+      const client = new import_sdk6.Surfman(options.rpc);
       const limit = parseInt(options.limit);
       const signatures = await client.cheatcodes.getLocalSignatures(limit);
       logger.success(`Retrieved ${signatures.length} signature(s):`);
@@ -248,14 +248,14 @@ ${index + 1}. Signature: ${sig.signature}`);
 
 // src/commands/cheatcodes/set-token-account.ts
 var import_commander7 = require("commander");
-var import_surfman_sdk7 = require("surfman-sdk");
+var import_sdk7 = require("@surfman/sdk");
 function createSetTokenAccountCommand() {
   const command = new import_commander7.Command("set-token-account").description("Set or update token account properties").requiredOption("--owner <address>", "Token account owner address").requiredOption("--mint <address>", "Token mint address").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--amount <number>", "Token amount").option("--delegate <address>", 'Delegate address (use "none" to clear)').option("--state <state>", "Account state (initialized, frozen, etc.)").option("--delegated-amount <number>", "Delegated amount").option(
     "--close-authority <address>",
     'Close authority address (use "none" to clear)'
   ).option("--token-program <address>", "Token program address").action(async (options) => {
     try {
-      const client = new import_surfman_sdk7.Surfman(options.rpc);
+      const client = new import_sdk7.Surfman(options.rpc);
       const update = {};
       if (options.amount) {
         update.amount = parseInt(options.amount);
@@ -309,7 +309,7 @@ function createSetTokenAccountCommand() {
 
 // src/commands/cheatcodes/reset-account.ts
 var import_commander8 = require("commander");
-var import_surfman_sdk8 = require("surfman-sdk");
+var import_sdk8 = require("@surfman/sdk");
 function createResetAccountCommand() {
   const command = new import_commander8.Command("reset-account").description("Reset an account to its initial state").requiredOption("--pubkey <address>", "Account public key").option("--rpc <url>", "RPC URL", "http://localhost:8899").option(
     "--include-owned",
@@ -317,7 +317,7 @@ function createResetAccountCommand() {
     false
   ).action(async (options) => {
     try {
-      const client = new import_surfman_sdk8.Surfman(options.rpc);
+      const client = new import_sdk8.Surfman(options.rpc);
       const config = options.includeOwned ? { includeOwnedAccounts: true } : void 0;
       await client.cheatcodes.resetAccount(options.pubkey, config);
       logger.success(`Account ${options.pubkey} reset successfully!`);
@@ -334,7 +334,7 @@ function createResetAccountCommand() {
 
 // src/commands/cheatcodes/reset-network.ts
 var import_commander9 = require("commander");
-var import_surfman_sdk9 = require("surfman-sdk");
+var import_sdk9 = require("@surfman/sdk");
 function createResetNetworkCommand() {
   const command = new import_commander9.Command("reset-network").description("Reset the entire Surfnet network to initial state").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--confirm", "Confirm network reset (required)", false).action(async (options) => {
     try {
@@ -347,7 +347,7 @@ function createResetNetworkCommand() {
         );
         process.exit(1);
       }
-      const client = new import_surfman_sdk9.Surfman(options.rpc);
+      const client = new import_sdk9.Surfman(options.rpc);
       logger.warn("Resetting network...");
       await client.cheatcodes.resetNetwork();
       logger.success("Network reset successfully!");
@@ -362,11 +362,11 @@ function createResetNetworkCommand() {
 
 // src/commands/network/get-latest-blockhash.ts
 var import_commander10 = require("commander");
-var import_surfman_sdk10 = require("surfman-sdk");
+var import_sdk10 = require("@surfman/sdk");
 function createGetLatestBlockhashCommand() {
   const command = new import_commander10.Command("get-latest-blockhash").description("Get the latest blockhash").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk10.Surfman(options.rpc);
+      const client = new import_sdk10.Surfman(options.rpc);
       const config = options.commitment ? { commitment: options.commitment } : void 0;
       const result = await client.network.getLatestBlockhash(config);
       logger.success("Latest blockhash retrieved:");
@@ -384,11 +384,11 @@ function createGetLatestBlockhashCommand() {
 
 // src/commands/network/get-block.ts
 var import_commander11 = require("commander");
-var import_surfman_sdk11 = require("surfman-sdk");
+var import_sdk11 = require("@surfman/sdk");
 function createGetBlockCommand() {
   const command = new import_commander11.Command("get-block").description("Get block information by slot").requiredOption("--slot <number>", "Slot number").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--encoding <type>", "Encoding type", "json").option("--rewards", "Include rewards", false).action(async (options) => {
     try {
-      const client = new import_surfman_sdk11.Surfman(options.rpc);
+      const client = new import_sdk11.Surfman(options.rpc);
       const slot = parseInt(options.slot);
       const config = {
         encoding: options.encoding,
@@ -424,11 +424,11 @@ function createGetBlockCommand() {
 
 // src/commands/network/get-transaction.ts
 var import_commander12 = require("commander");
-var import_surfman_sdk12 = require("surfman-sdk");
+var import_sdk12 = require("@surfman/sdk");
 function createGetTransactionCommand() {
   const command = new import_commander12.Command("get-transaction").description("Get transaction details by signature").requiredOption("--signature <sig>", "Transaction signature").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--encoding <type>", "Encoding type", "json").action(async (options) => {
     try {
-      const client = new import_surfman_sdk12.Surfman(options.rpc);
+      const client = new import_sdk12.Surfman(options.rpc);
       const config = {
         encoding: options.encoding
       };
@@ -465,11 +465,11 @@ function createGetTransactionCommand() {
 
 // src/commands/network/send-transaction.ts
 var import_commander13 = require("commander");
-var import_surfman_sdk13 = require("surfman-sdk");
+var import_sdk13 = require("@surfman/sdk");
 function createSendTransactionCommand() {
   const command = new import_commander13.Command("send-transaction").description("Send a signed transaction").requiredOption("--transaction <data>", "Base64 encoded transaction").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--skip-preflight", "Skip preflight checks", false).option("--encoding <type>", "Encoding type", "base64").action(async (options) => {
     try {
-      const client = new import_surfman_sdk13.Surfman(options.rpc);
+      const client = new import_sdk13.Surfman(options.rpc);
       const config = {
         skipPreflight: options.skipPreflight,
         encoding: options.encoding
@@ -492,11 +492,11 @@ function createSendTransactionCommand() {
 
 // src/commands/network/get-cluster-nodes.ts
 var import_commander14 = require("commander");
-var import_surfman_sdk14 = require("surfman-sdk");
+var import_sdk14 = require("@surfman/sdk");
 function createGetClusterNodesCommand() {
   const command = new import_commander14.Command("get-cluster-nodes").description("Get information about cluster nodes").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
     try {
-      const client = new import_surfman_sdk14.Surfman(options.rpc);
+      const client = new import_sdk14.Surfman(options.rpc);
       const nodes = await client.network.getClusterNodes();
       logger.success(`Found ${nodes.length} cluster node(s):`);
       nodes.forEach((node, index) => {
@@ -519,11 +519,11 @@ ${index + 1}. ${node.pubkey}`);
 
 // src/commands/network/request-airdrop.ts
 var import_commander15 = require("commander");
-var import_surfman_sdk15 = require("surfman-sdk");
+var import_sdk15 = require("@surfman/sdk");
 function createRequestAirdropCommand() {
   const command = new import_commander15.Command("request-airdrop").description("Request an airdrop of lamports").requiredOption("--pubkey <address>", "Public key to airdrop to").requiredOption("--lamports <amount>", "Amount in lamports").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk15.Surfman(options.rpc);
+      const client = new import_sdk15.Surfman(options.rpc);
       const lamports = parseInt(options.lamports);
       const config = options.commitment ? { commitment: options.commitment } : void 0;
       const signature = await client.network.requestAirdrop(
@@ -547,11 +547,11 @@ function createRequestAirdropCommand() {
 
 // src/commands/network/get-blocks.ts
 var import_commander16 = require("commander");
-var import_surfman_sdk16 = require("surfman-sdk");
+var import_sdk16 = require("@surfman/sdk");
 function createGetBlocksCommand() {
   const command = new import_commander16.Command("get-blocks").description("Get list of confirmed blocks between two slots").requiredOption("--start-slot <number>", "Start slot (inclusive)").option("--end-slot <number>", "End slot (exclusive)").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk16.Surfman(options.rpc);
+      const client = new import_sdk16.Surfman(options.rpc);
       const startSlot = parseInt(options.startSlot);
       const endSlot = options.endSlot ? parseInt(options.endSlot) : void 0;
       const config = options.commitment ? { commitment: options.commitment } : void 0;
@@ -576,11 +576,11 @@ function createGetBlocksCommand() {
 
 // src/commands/network/get-signatures-for-address.ts
 var import_commander17 = require("commander");
-var import_surfman_sdk17 = require("surfman-sdk");
+var import_sdk17 = require("@surfman/sdk");
 function createGetSignaturesForAddressCommand() {
   const command = new import_commander17.Command("get-signatures-for-address").description("Get confirmed signatures for transactions involving an address").requiredOption("--address <pubkey>", "Account address").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--limit <number>", "Maximum number of signatures", "10").option("--before <signature>", "Start searching backwards from this signature").option("--until <signature>", "Search until this signature").action(async (options) => {
     try {
-      const client = new import_surfman_sdk17.Surfman(options.rpc);
+      const client = new import_sdk17.Surfman(options.rpc);
       const config = {
         limit: parseInt(options.limit)
       };
@@ -617,11 +617,11 @@ ${index + 1}. ${sig.signature}`);
 
 // src/commands/network/is-blockhash-valid.ts
 var import_commander18 = require("commander");
-var import_surfman_sdk18 = require("surfman-sdk");
+var import_sdk18 = require("@surfman/sdk");
 function createIsBlockhashValidCommand() {
   const command = new import_commander18.Command("is-blockhash-valid").description("Check if a blockhash is still valid").requiredOption("--blockhash <hash>", "Blockhash to check").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk18.Surfman(options.rpc);
+      const client = new import_sdk18.Surfman(options.rpc);
       const config = options.commitment ? { commitment: options.commitment } : void 0;
       const isValid = await client.network.isBlockhashValid(
         options.blockhash,
@@ -644,11 +644,11 @@ function createIsBlockhashValidCommand() {
 
 // src/commands/network/get-fee-for-message.ts
 var import_commander19 = require("commander");
-var import_surfman_sdk19 = require("surfman-sdk");
+var import_sdk19 = require("@surfman/sdk");
 function createGetFeeForMessageCommand() {
   const command = new import_commander19.Command("get-fee-for-message").description("Get the fee required for a message").requiredOption("--message <data>", "Base64 encoded message").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk19.Surfman(options.rpc);
+      const client = new import_sdk19.Surfman(options.rpc);
       const config = options.commitment ? { commitment: options.commitment } : void 0;
       const fee = await client.network.getFeeForMessage(
         options.message,
@@ -670,11 +670,11 @@ function createGetFeeForMessageCommand() {
 
 // src/commands/network/get-recent-prioritization-fees.ts
 var import_commander20 = require("commander");
-var import_surfman_sdk20 = require("surfman-sdk");
+var import_sdk20 = require("@surfman/sdk");
 function createGetRecentPrioritizationFeesCommand() {
   const command = new import_commander20.Command("get-recent-prioritization-fees").description("Get recent prioritization fees").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--addresses <addresses...>", "Account addresses to filter by").action(async (options) => {
     try {
-      const client = new import_surfman_sdk20.Surfman(options.rpc);
+      const client = new import_sdk20.Surfman(options.rpc);
       const fees = await client.network.getRecentPrioritizationFees(
         options.addresses
       );
@@ -708,11 +708,11 @@ Recent samples (newest first):`);
 
 // src/commands/network/get-block-time.ts
 var import_commander21 = require("commander");
-var import_surfman_sdk21 = require("surfman-sdk");
+var import_sdk21 = require("@surfman/sdk");
 function createGetBlockTimeCommand() {
   const command = new import_commander21.Command("get-block-time").description("Get estimated production time of a block").requiredOption("--slot <number>", "Slot number").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
     try {
-      const client = new import_surfman_sdk21.Surfman(options.rpc);
+      const client = new import_sdk21.Surfman(options.rpc);
       const slot = parseInt(options.slot);
       const blockTime = await client.network.getBlockTime(slot);
       if (blockTime !== null) {
@@ -734,11 +734,11 @@ function createGetBlockTimeCommand() {
 
 // src/commands/network/get-blocks-with-limit.ts
 var import_commander22 = require("commander");
-var import_surfman_sdk22 = require("surfman-sdk");
+var import_sdk22 = require("@surfman/sdk");
 function createGetBlocksWithLimitCommand() {
   const command = new import_commander22.Command("get-blocks-with-limit").description("Get confirmed blocks starting at a slot with a limit").requiredOption("--start-slot <number>", "Start slot (inclusive)").requiredOption("--limit <number>", "Maximum number of blocks").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk22.Surfman(options.rpc);
+      const client = new import_sdk22.Surfman(options.rpc);
       const startSlot = parseInt(options.startSlot);
       const limit = parseInt(options.limit);
       const config = options.commitment ? { commitment: options.commitment } : void 0;
@@ -767,11 +767,11 @@ function createGetBlocksWithLimitCommand() {
 
 // src/commands/network/get-first-available-block.ts
 var import_commander23 = require("commander");
-var import_surfman_sdk23 = require("surfman-sdk");
+var import_sdk23 = require("@surfman/sdk");
 function createGetFirstAvailableBlockCommand() {
   const command = new import_commander23.Command("get-first-available-block").description("Get the slot of the lowest confirmed block").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
     try {
-      const client = new import_surfman_sdk23.Surfman(options.rpc);
+      const client = new import_sdk23.Surfman(options.rpc);
       const slot = await client.network.getFirstAvailableBlock();
       logger.success(`First available block:`);
       logger.log(`  Slot: ${slot}`);
@@ -787,11 +787,11 @@ function createGetFirstAvailableBlockCommand() {
 
 // src/commands/network/minimum-ledger-slot.ts
 var import_commander24 = require("commander");
-var import_surfman_sdk24 = require("surfman-sdk");
+var import_sdk24 = require("@surfman/sdk");
 function createMinimumLedgerSlotCommand() {
   const command = new import_commander24.Command("minimum-ledger-slot").description("Get the minimum slot that the node has information about").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
     try {
-      const client = new import_surfman_sdk24.Surfman(options.rpc);
+      const client = new import_sdk24.Surfman(options.rpc);
       const slot = await client.network.minimumLedgerSlot();
       logger.success(`Minimum ledger slot:`);
       logger.log(`  Slot: ${slot}`);
@@ -807,11 +807,11 @@ function createMinimumLedgerSlotCommand() {
 
 // src/commands/network/get-signature-statuses.ts
 var import_commander25 = require("commander");
-var import_surfman_sdk25 = require("surfman-sdk");
+var import_sdk25 = require("@surfman/sdk");
 function createGetSignatureStatusesCommand() {
   const command = new import_commander25.Command("get-signature-statuses").description("Get the statuses of a list of signatures").requiredOption("--signatures <sigs...>", "Transaction signatures").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--search-history", "Search transaction history", false).action(async (options) => {
     try {
-      const client = new import_surfman_sdk25.Surfman(options.rpc);
+      const client = new import_sdk25.Surfman(options.rpc);
       const config = options.searchHistory ? { searchTransactionHistory: true } : void 0;
       const statuses = await client.network.getSignatureStatuses(
         options.signatures,
@@ -848,11 +848,11 @@ ${index + 1}. ${sig}`);
 
 // src/commands/network/simulate-transaction.ts
 var import_commander26 = require("commander");
-var import_surfman_sdk26 = require("surfman-sdk");
+var import_sdk26 = require("@surfman/sdk");
 function createSimulateTransactionCommand() {
   const command = new import_commander26.Command("simulate-transaction").description("Simulate a transaction without committing it").requiredOption("--transaction <data>", "Base64 encoded transaction").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--sig-verify", "Enable signature verification", true).option("--commitment <level>", "Commitment level").option("--encoding <type>", "Encoding type", "base64").action(async (options) => {
     try {
-      const client = new import_surfman_sdk26.Surfman(options.rpc);
+      const client = new import_sdk26.Surfman(options.rpc);
       const config = {
         sigVerify: options.sigVerify,
         encoding: options.encoding
@@ -898,11 +898,11 @@ Return data: ${JSON.stringify(result.returnData)}`);
 
 // src/commands/network/get-recent-performance-samples.ts
 var import_commander27 = require("commander");
-var import_surfman_sdk27 = require("surfman-sdk");
+var import_sdk27 = require("@surfman/sdk");
 function createGetRecentPerformanceSamplesCommand() {
   const command = new import_commander27.Command("get-recent-performance-samples").description("Get recent performance samples").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--limit <number>", "Maximum number of samples", "10").action(async (options) => {
     try {
-      const client = new import_surfman_sdk27.Surfman(options.rpc);
+      const client = new import_sdk27.Surfman(options.rpc);
       const limit = parseInt(options.limit);
       const samples = await client.network.getRecentPerformanceSamples(limit);
       logger.success(`Retrieved ${samples.length} performance sample(s):`);
@@ -930,13 +930,115 @@ ${index + 1}. Slot ${sample.slot}`);
   return command;
 }
 
-// src/commands/accounts/get-account-info.ts
+// src/commands/network/get-inflation-reward.ts
 var import_commander28 = require("commander");
-var import_surfman_sdk28 = require("surfman-sdk");
+var import_sdk28 = require("@surfman/sdk");
+var import_chalk2 = __toESM(require("chalk"));
+function createGetInflationRewardCommand() {
+  const command = new import_commander28.Command("get-inflation-reward").description("Get inflation rewards for a list of addresses").requiredOption("--addresses <addresses>", "Comma-separated list of addresses").option("--epoch <epoch>", "Epoch to query (default: current epoch)", parseInt).option("--commitment <level>", "Commitment level (processed, confirmed, finalized)").option("--rpc <url>", "RPC endpoint URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk28.Surfman(options.rpc);
+      const addresses = options.addresses.split(",").map((addr) => addr.trim());
+      const config = {};
+      if (options.epoch !== void 0) config.epoch = options.epoch;
+      if (options.commitment) config.commitment = options.commitment;
+      const rewards = await client.network.getInflationReward(
+        addresses,
+        Object.keys(config).length > 0 ? config : void 0
+      );
+      console.log(import_chalk2.default.cyan("\n\u{1F4CA} Inflation Rewards:\n"));
+      rewards.forEach((reward, index) => {
+        console.log(import_chalk2.default.bold(`Address ${index + 1}: ${addresses[index]}`));
+        if (reward) {
+          console.log(`  Epoch: ${import_chalk2.default.yellow(reward.epoch)}`);
+          console.log(`  Effective Slot: ${import_chalk2.default.yellow(reward.effectiveSlot)}`);
+          console.log(`  Amount: ${import_chalk2.default.green(reward.amount)} lamports`);
+          console.log(`  Post Balance: ${import_chalk2.default.green(reward.postBalance)} lamports`);
+          if (reward.commission !== null && reward.commission !== void 0) {
+            console.log(`  Commission: ${import_chalk2.default.yellow(reward.commission)}%`);
+          }
+        } else {
+          console.log(import_chalk2.default.gray("  No reward received"));
+        }
+        console.log();
+      });
+    } catch (error) {
+      console.error(import_chalk2.default.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/network/get-max-retransmit-slot.ts
+var import_commander29 = require("commander");
+var import_sdk29 = require("@surfman/sdk");
+var import_chalk3 = __toESM(require("chalk"));
+function createGetMaxRetransmitSlotCommand() {
+  const command = new import_commander29.Command("get-max-retransmit-slot").description("Get maximum retransmit slot").option("--rpc <url>", "RPC endpoint URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk29.Surfman(options.rpc);
+      const slot = await client.network.getMaxRetransmitSlot();
+      console.log(import_chalk3.default.cyan("\n\u{1F4E1} Max Retransmit Slot:\n"));
+      console.log(import_chalk3.default.bold("Slot:"), import_chalk3.default.yellow(slot));
+    } catch (error) {
+      console.error(import_chalk3.default.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/network/get-max-shred-insert-slot.ts
+var import_commander30 = require("commander");
+var import_sdk30 = require("@surfman/sdk");
+var import_chalk4 = __toESM(require("chalk"));
+function createGetMaxShredInsertSlotCommand() {
+  const command = new import_commander30.Command("get-max-shred-insert-slot").description("Get maximum shred insert slot").option("--rpc <url>", "RPC endpoint URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk30.Surfman(options.rpc);
+      const slot = await client.network.getMaxShredInsertSlot();
+      console.log(import_chalk4.default.cyan("\n\u{1F4E5} Max Shred Insert Slot:\n"));
+      console.log(import_chalk4.default.bold("Slot:"), import_chalk4.default.yellow(slot));
+    } catch (error) {
+      console.error(import_chalk4.default.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/network/get-stake-minimum-delegation.ts
+var import_commander31 = require("commander");
+var import_sdk31 = require("@surfman/sdk");
+var import_chalk5 = __toESM(require("chalk"));
+function createGetStakeMinimumDelegationCommand() {
+  const command = new import_commander31.Command("get-stake-minimum-delegation").description("Get minimum stake delegation amount").option("--commitment <level>", "Commitment level (processed, confirmed, finalized)").option("--rpc <url>", "RPC endpoint URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk31.Surfman(options.rpc);
+      const config = {};
+      if (options.commitment) config.commitment = options.commitment;
+      const lamports = await client.network.getStakeMinimumDelegation(
+        Object.keys(config).length > 0 ? config : void 0
+      );
+      console.log(import_chalk5.default.cyan("\n\u{1F4B0} Stake Minimum Delegation:\n"));
+      console.log(import_chalk5.default.bold("Lamports:"), import_chalk5.default.yellow(lamports));
+      console.log(import_chalk5.default.bold("SOL:"), import_chalk5.default.yellow((lamports / 1e9).toFixed(9)));
+    } catch (error) {
+      console.error(import_chalk5.default.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/accounts/get-account-info.ts
+var import_commander32 = require("commander");
+var import_sdk32 = require("@surfman/sdk");
 function createGetAccountInfoCommand() {
-  const command = new import_commander28.Command("get-account-info").description("Get detailed information about an account").requiredOption("--pubkey <address>", "Account public key").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--encoding <type>", "Data encoding", "base64").option("--commitment <level>", "Commitment level").action(async (options) => {
+  const command = new import_commander32.Command("get-account-info").description("Get detailed information about an account").requiredOption("--pubkey <address>", "Account public key").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--encoding <type>", "Data encoding", "base64").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk28.Surfman(options.rpc);
+      const client = new import_sdk32.Surfman(options.rpc);
       const config = {
         encoding: options.encoding
       };
@@ -973,12 +1075,12 @@ function createGetAccountInfoCommand() {
 }
 
 // src/commands/accounts/get-multiple-accounts.ts
-var import_commander29 = require("commander");
-var import_surfman_sdk29 = require("surfman-sdk");
+var import_commander33 = require("commander");
+var import_sdk33 = require("@surfman/sdk");
 function createGetMultipleAccountsCommand() {
-  const command = new import_commander29.Command("get-multiple-accounts").description("Get information for multiple accounts").requiredOption("--pubkeys <addresses...>", "Account public keys").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--encoding <type>", "Data encoding", "base64").option("--commitment <level>", "Commitment level").action(async (options) => {
+  const command = new import_commander33.Command("get-multiple-accounts").description("Get information for multiple accounts").requiredOption("--pubkeys <addresses...>", "Account public keys").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--encoding <type>", "Data encoding", "base64").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk29.Surfman(options.rpc);
+      const client = new import_sdk33.Surfman(options.rpc);
       const config = {
         encoding: options.encoding
       };
@@ -1013,12 +1115,12 @@ ${index + 1}. ${pubkey}`);
 }
 
 // src/commands/accounts/get-block-commitment.ts
-var import_commander30 = require("commander");
-var import_surfman_sdk30 = require("surfman-sdk");
+var import_commander34 = require("commander");
+var import_sdk34 = require("@surfman/sdk");
 function createGetBlockCommitmentCommand() {
-  const command = new import_commander30.Command("get-block-commitment").description("Get commitment information for a block").requiredOption("--slot <number>", "Block slot number").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+  const command = new import_commander34.Command("get-block-commitment").description("Get commitment information for a block").requiredOption("--slot <number>", "Block slot number").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
     try {
-      const client = new import_surfman_sdk30.Surfman(options.rpc);
+      const client = new import_sdk34.Surfman(options.rpc);
       const slot = parseInt(options.slot);
       const commitment = await client.accounts.getBlockCommitment(slot);
       logger.success(`Block commitment for slot ${slot}:`);
@@ -1047,12 +1149,12 @@ function createGetBlockCommitmentCommand() {
 }
 
 // src/commands/accounts/get-token-account-balance.ts
-var import_commander31 = require("commander");
-var import_surfman_sdk31 = require("surfman-sdk");
+var import_commander35 = require("commander");
+var import_sdk35 = require("@surfman/sdk");
 function createGetTokenAccountBalanceCommand() {
-  const command = new import_commander31.Command("get-token-account-balance").description("Get token balance of a token account").requiredOption("--pubkey <address>", "Token account public key").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
+  const command = new import_commander35.Command("get-token-account-balance").description("Get token balance of a token account").requiredOption("--pubkey <address>", "Token account public key").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk31.Surfman(options.rpc);
+      const client = new import_sdk35.Surfman(options.rpc);
       const config = options.commitment ? { commitment: options.commitment } : void 0;
       const balance = await client.accounts.getTokenAccountBalance(
         options.pubkey,
@@ -1078,12 +1180,12 @@ function createGetTokenAccountBalanceCommand() {
 }
 
 // src/commands/accounts/get-token-supply.ts
-var import_commander32 = require("commander");
-var import_surfman_sdk32 = require("surfman-sdk");
+var import_commander36 = require("commander");
+var import_sdk36 = require("@surfman/sdk");
 function createGetTokenSupplyCommand() {
-  const command = new import_commander32.Command("get-token-supply").description("Get total supply of a token").requiredOption("--mint <address>", "Token mint address").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
+  const command = new import_commander36.Command("get-token-supply").description("Get total supply of a token").requiredOption("--mint <address>", "Token mint address").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk32.Surfman(options.rpc);
+      const client = new import_sdk36.Surfman(options.rpc);
       const config = options.commitment ? { commitment: options.commitment } : void 0;
       const supply = await client.accounts.getTokenSupply(
         options.mint,
@@ -1105,12 +1207,12 @@ function createGetTokenSupplyCommand() {
 }
 
 // src/commands/scan/get-program-accounts.ts
-var import_commander33 = require("commander");
-var import_surfman_sdk33 = require("surfman-sdk");
+var import_commander37 = require("commander");
+var import_sdk37 = require("@surfman/sdk");
 function createGetProgramAccountsCommand() {
-  const command = new import_commander33.Command("get-program-accounts").description("Get all accounts owned by a program").requiredOption("--program-id <address>", "Program public key").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--encoding <type>", "Data encoding", "base64").option("--with-context", "Include context in response", false).option("--data-size <number>", "Filter by data size").action(async (options) => {
+  const command = new import_commander37.Command("get-program-accounts").description("Get all accounts owned by a program").requiredOption("--program-id <address>", "Program public key").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--encoding <type>", "Data encoding", "base64").option("--with-context", "Include context in response", false).option("--data-size <number>", "Filter by data size").action(async (options) => {
     try {
-      const client = new import_surfman_sdk33.Surfman(options.rpc);
+      const client = new import_sdk37.Surfman(options.rpc);
       const config = {
         encoding: options.encoding,
         withContext: options.withContext
@@ -1146,12 +1248,12 @@ ${index + 1}. ${acc.pubkey}`);
 }
 
 // src/commands/scan/get-largest-accounts.ts
-var import_commander34 = require("commander");
-var import_surfman_sdk34 = require("surfman-sdk");
+var import_commander38 = require("commander");
+var import_sdk38 = require("@surfman/sdk");
 function createGetLargestAccountsCommand() {
-  const command = new import_commander34.Command("get-largest-accounts").description("Get the 20 largest accounts by lamport balance").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--filter <type>", "Filter type (circulating/nonCirculating)").option("--commitment <level>", "Commitment level").action(async (options) => {
+  const command = new import_commander38.Command("get-largest-accounts").description("Get the 20 largest accounts by lamport balance").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--filter <type>", "Filter type (circulating/nonCirculating)").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk34.Surfman(options.rpc);
+      const client = new import_sdk38.Surfman(options.rpc);
       const config = {};
       if (options.filter) {
         config.filter = options.filter;
@@ -1180,12 +1282,12 @@ function createGetLargestAccountsCommand() {
 }
 
 // src/commands/scan/get-supply.ts
-var import_commander35 = require("commander");
-var import_surfman_sdk35 = require("surfman-sdk");
+var import_commander39 = require("commander");
+var import_sdk39 = require("@surfman/sdk");
 function createGetSupplyCommand() {
-  const command = new import_commander35.Command("get-supply").description("Get current supply information").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--exclude-accounts", "Exclude non-circulating accounts list", false).option("--commitment <level>", "Commitment level").action(async (options) => {
+  const command = new import_commander39.Command("get-supply").description("Get current supply information").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--exclude-accounts", "Exclude non-circulating accounts list", false).option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk35.Surfman(options.rpc);
+      const client = new import_sdk39.Surfman(options.rpc);
       const config = {
         excludeNonCirculatingAccountsList: options.excludeAccounts
       };
@@ -1213,12 +1315,12 @@ function createGetSupplyCommand() {
 }
 
 // src/commands/scan/get-token-largest-accounts.ts
-var import_commander36 = require("commander");
-var import_surfman_sdk36 = require("surfman-sdk");
+var import_commander40 = require("commander");
+var import_sdk40 = require("@surfman/sdk");
 function createGetTokenLargestAccountsCommand() {
-  const command = new import_commander36.Command("get-token-largest-accounts").description("Get largest holders of a specific token").requiredOption("--mint <address>", "Token mint address").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
+  const command = new import_commander40.Command("get-token-largest-accounts").description("Get largest holders of a specific token").requiredOption("--mint <address>", "Token mint address").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--commitment <level>", "Commitment level").action(async (options) => {
     try {
-      const client = new import_surfman_sdk36.Surfman(options.rpc);
+      const client = new import_sdk40.Surfman(options.rpc);
       const config = options.commitment ? { commitment: options.commitment } : void 0;
       const accounts = await client.scan.getTokenLargestAccounts(
         options.mint,
@@ -1242,12 +1344,12 @@ ${index + 1}. ${acc.address}`);
 }
 
 // src/commands/scan/get-token-accounts-by-owner.ts
-var import_commander37 = require("commander");
-var import_surfman_sdk37 = require("surfman-sdk");
+var import_commander41 = require("commander");
+var import_sdk41 = require("@surfman/sdk");
 function createGetTokenAccountsByOwnerCommand() {
-  const command = new import_commander37.Command("get-token-accounts-by-owner").description("Get all token accounts owned by an address").requiredOption("--owner <address>", "Owner wallet address").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--mint <address>", "Filter by token mint").option("--program-id <address>", "Filter by program ID").option("--encoding <type>", "Data encoding", "jsonParsed").action(async (options) => {
+  const command = new import_commander41.Command("get-token-accounts-by-owner").description("Get all token accounts owned by an address").requiredOption("--owner <address>", "Owner wallet address").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--mint <address>", "Filter by token mint").option("--program-id <address>", "Filter by program ID").option("--encoding <type>", "Data encoding", "jsonParsed").action(async (options) => {
     try {
-      const client = new import_surfman_sdk37.Surfman(options.rpc);
+      const client = new import_sdk41.Surfman(options.rpc);
       if (!options.mint && !options.programId) {
         logger.error("Must specify either --mint or --program-id filter");
         process.exit(1);
@@ -1279,12 +1381,12 @@ ${index + 1}. ${acc.pubkey}`);
 }
 
 // src/commands/scan/get-token-accounts-by-delegate.ts
-var import_commander38 = require("commander");
-var import_surfman_sdk38 = require("surfman-sdk");
+var import_commander42 = require("commander");
+var import_sdk42 = require("@surfman/sdk");
 function createGetTokenAccountsByDelegateCommand() {
-  const command = new import_commander38.Command("get-token-accounts-by-delegate").description("Get token accounts delegated to an address").requiredOption("--delegate <address>", "Delegate address").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--mint <address>", "Filter by token mint").option("--program-id <address>", "Filter by program ID").option("--encoding <type>", "Data encoding", "jsonParsed").action(async (options) => {
+  const command = new import_commander42.Command("get-token-accounts-by-delegate").description("Get token accounts delegated to an address").requiredOption("--delegate <address>", "Delegate address").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--mint <address>", "Filter by token mint").option("--program-id <address>", "Filter by program ID").option("--encoding <type>", "Data encoding", "jsonParsed").action(async (options) => {
     try {
-      const client = new import_surfman_sdk38.Surfman(options.rpc);
+      const client = new import_sdk42.Surfman(options.rpc);
       if (!options.mint && !options.programId) {
         logger.error("Must specify either --mint or --program-id filter");
         process.exit(1);
@@ -1315,79 +1417,635 @@ ${index + 1}. ${acc.pubkey}`);
   return command;
 }
 
+// src/commands/cheatcodes/clone-program-account.ts
+var import_commander43 = require("commander");
+var import_sdk43 = require("@surfman/sdk");
+function createCloneProgramAccountCommand() {
+  const command = new import_commander43.Command("clone-program-account").description("Clone a program account from one program ID to another").requiredOption("--source <address>", "Source program ID").requiredOption("--destination <address>", "Destination program ID").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk43.Surfman(options.rpc);
+      await client.cheatcodes.cloneProgramAccount(
+        options.source,
+        options.destination
+      );
+      logger.success(`Program cloned successfully!`);
+      logger.log(`Source: ${options.source}`);
+      logger.log(`Destination: ${options.destination}`);
+    } catch (error) {
+      logger.error(`Failed to clone program account: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/profile-transaction.ts
+var import_commander44 = require("commander");
+var import_sdk44 = require("@surfman/sdk");
+function createProfileTransactionCommand() {
+  const command = new import_commander44.Command("profile-transaction").description("Profile a transaction to estimate compute units").requiredOption("--transaction <base64>", "Base64 encoded transaction data").option("--tag <tag>", "Optional tag for the transaction").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--depth <depth>", "Profile depth (full or shallow)", "full").action(async (options) => {
+    try {
+      const client = new import_sdk44.Surfman(options.rpc);
+      const config = {
+        depth: options.depth
+      };
+      const result = await client.cheatcodes.profileTransaction(
+        options.transaction,
+        options.tag,
+        config
+      );
+      logger.success("Transaction profiled successfully!");
+      logger.log("\nProfile Result:");
+      logger.log(`  UUID: ${result.uuid}`);
+      if (result.signature) {
+        logger.log(`  Signature: ${result.signature}`);
+      }
+      logger.log(`  Slot: ${result.slot}`);
+      if (result.tag) {
+        logger.log(`  Tag: ${result.tag}`);
+      }
+      if (result.computeUnitsConsumed) {
+        logger.log(`  Compute Units: ${result.computeUnitsConsumed}`);
+      }
+      if (result.err) {
+        logger.log(`  Error: ${JSON.stringify(result.err, null, 2)}`);
+      }
+      if (result.logs && result.logs.length > 0) {
+        logger.log("\nLogs:");
+        result.logs.forEach((log) => logger.log(`  ${log}`));
+      }
+    } catch (error) {
+      logger.error(`Failed to profile transaction: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/get-profile-results-by-tag.ts
+var import_commander45 = require("commander");
+var import_sdk45 = require("@surfman/sdk");
+function createGetProfileResultsByTagCommand() {
+  const command = new import_commander45.Command("get-profile-results-by-tag").description("Get all profiling results for a given tag").requiredOption("--tag <tag>", "Tag to retrieve profiling results for").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--depth <depth>", "Profile depth (full or shallow)", "shallow").action(async (options) => {
+    try {
+      const client = new import_sdk45.Surfman(options.rpc);
+      const config = {
+        depth: options.depth
+      };
+      const results = await client.cheatcodes.getProfileResultsByTag(
+        options.tag,
+        config
+      );
+      if (!results || results.length === 0) {
+        logger.log(`No profile results found for tag: ${options.tag}`);
+        return;
+      }
+      logger.success(`Found ${results.length} profile result(s) for tag: ${options.tag}
+`);
+      results.forEach((result, index) => {
+        logger.log(`Profile ${index + 1}:`);
+        logger.log(`  UUID: ${result.uuid}`);
+        if (result.signature) {
+          logger.log(`  Signature: ${result.signature}`);
+        }
+        logger.log(`  Slot: ${result.slot}`);
+        if (result.computeUnitsConsumed) {
+          logger.log(`  Compute Units: ${result.computeUnitsConsumed}`);
+        }
+        if (result.err) {
+          logger.log(`  Error: ${JSON.stringify(result.err)}`);
+        }
+        logger.log("");
+      });
+    } catch (error) {
+      logger.error(`Failed to get profile results: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/set-supply.ts
+var import_commander46 = require("commander");
+var import_sdk46 = require("@surfman/sdk");
+function createSetSupplyCommand() {
+  const command = new import_commander46.Command("set-supply").description("Set or update network supply information").option("--total <lamports>", "Total supply in lamports").option("--circulating <lamports>", "Circulating supply in lamports").option("--non-circulating <lamports>", "Non-circulating supply in lamports").option("--non-circulating-accounts <accounts...>", "List of non-circulating account addresses").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk46.Surfman(options.rpc);
+      const update = {};
+      if (options.total) {
+        update.total = parseInt(options.total);
+      }
+      if (options.circulating) {
+        update.circulating = parseInt(options.circulating);
+      }
+      if (options.nonCirculating) {
+        update.nonCirculating = parseInt(options.nonCirculating);
+      }
+      if (options.nonCirculatingAccounts) {
+        update.nonCirculatingAccounts = options.nonCirculatingAccounts;
+      }
+      if (Object.keys(update).length === 0) {
+        logger.error("No supply fields specified. Use --total, --circulating, etc.");
+        process.exit(1);
+      }
+      await client.cheatcodes.setSupply(update);
+      logger.success("Supply updated successfully!");
+      logger.log("Updated fields:");
+      Object.entries(update).forEach(([key, value]) => {
+        logger.log(`  ${key}: ${value}`);
+      });
+    } catch (error) {
+      logger.error(`Failed to set supply: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/get-transaction-profile.ts
+var import_commander47 = require("commander");
+var import_sdk47 = require("@surfman/sdk");
+function createGetTransactionProfileCommand() {
+  const command = new import_commander47.Command("get-transaction-profile").description("Get transaction profile by signature or UUID").requiredOption("--id <signatureOrUuid>", "Transaction signature or UUID").option("--type <type>", "ID type (signature or uuid)", "signature").option("--rpc <url>", "RPC URL", "http://localhost:8899").option("--depth <depth>", "Profile depth (full or shallow)", "full").action(async (options) => {
+    try {
+      const client = new import_sdk47.Surfman(options.rpc);
+      const config = {
+        depth: options.depth
+      };
+      const signatureOrUuid = options.type === "uuid" ? { Uuid: options.id } : { Signature: options.id };
+      const result = await client.cheatcodes.getTransactionProfile(
+        signatureOrUuid,
+        config
+      );
+      if (!result) {
+        logger.log(`No profile found for ${options.type}: ${options.id}`);
+        return;
+      }
+      logger.success("Profile found!");
+      logger.log("\nProfile Result:");
+      logger.log(`  UUID: ${result.uuid}`);
+      if (result.signature) {
+        logger.log(`  Signature: ${result.signature}`);
+      }
+      logger.log(`  Slot: ${result.slot}`);
+      if (result.tag) {
+        logger.log(`  Tag: ${result.tag}`);
+      }
+      if (result.computeUnitsConsumed) {
+        logger.log(`  Compute Units: ${result.computeUnitsConsumed}`);
+      }
+      if (result.err) {
+        logger.log(`  Error: ${JSON.stringify(result.err, null, 2)}`);
+      }
+      if (result.logs && result.logs.length > 0) {
+        logger.log("\nLogs:");
+        result.logs.forEach((log) => logger.log(`  ${log}`));
+      }
+    } catch (error) {
+      logger.error(`Failed to get transaction profile: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/register-idl.ts
+var import_commander48 = require("commander");
+var import_sdk48 = require("@surfman/sdk");
+var import_fs = require("fs");
+function createRegisterIdlCommand() {
+  const command = new import_commander48.Command("register-idl").description("Register an IDL for a program").requiredOption("--idl-file <path>", "Path to IDL JSON file").option("--slot <slot>", "Slot at which to register the IDL").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk48.Surfman(options.rpc);
+      const idlContent = (0, import_fs.readFileSync)(options.idlFile, "utf-8");
+      const idl = JSON.parse(idlContent);
+      const slot = options.slot ? parseInt(options.slot) : void 0;
+      await client.cheatcodes.registerIdl(idl, slot);
+      logger.success("IDL registered successfully!");
+      logger.log(`  Program: ${idl.address}`);
+      logger.log(`  Name: ${idl.metadata.name}`);
+      logger.log(`  Version: ${idl.metadata.version}`);
+      if (slot) {
+        logger.log(`  Slot: ${slot}`);
+      }
+    } catch (error) {
+      logger.error(`Failed to register IDL: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/get-idl.ts
+var import_commander49 = require("commander");
+var import_sdk49 = require("@surfman/sdk");
+function createGetIdlCommand() {
+  const command = new import_commander49.Command("get-idl").description("Get the registered IDL for a program").requiredOption("--program-id <address>", "Program ID").option("--slot <slot>", "Slot at which to query the IDL").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk49.Surfman(options.rpc);
+      const slot = options.slot ? parseInt(options.slot) : void 0;
+      const idl = await client.cheatcodes.getIdl(options.programId, slot);
+      if (!idl) {
+        logger.log(`No IDL found for program: ${options.programId}`);
+        return;
+      }
+      logger.success("IDL found!");
+      logger.log("\nIDL:");
+      logger.log(JSON.stringify(idl, null, 2));
+    } catch (error) {
+      logger.error(`Failed to get IDL: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/export-snapshot.ts
+var import_commander50 = require("commander");
+var import_sdk50 = require("@surfman/sdk");
+var import_fs2 = require("fs");
+function createExportSnapshotCommand() {
+  const command = new import_commander50.Command("export-snapshot").description("Export a snapshot of all accounts").option("--output <path>", "Output file path", "snapshot.json").option("--include-parsed", "Include parsed account data").option("--include-programs", "Include program accounts").option("--include-accounts <accounts...>", "Specific accounts to include").option("--exclude-accounts <accounts...>", "Specific accounts to exclude").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk50.Surfman(options.rpc);
+      const config = {};
+      if (options.includeParsed) {
+        config.includeParsedAccounts = true;
+      }
+      if (options.includePrograms || options.includeAccounts || options.excludeAccounts) {
+        config.filter = {};
+        if (options.includePrograms) {
+          config.filter.includeProgramAccounts = true;
+        }
+        if (options.includeAccounts) {
+          config.filter.includeAccounts = options.includeAccounts;
+        }
+        if (options.excludeAccounts) {
+          config.filter.excludeAccounts = options.excludeAccounts;
+        }
+      }
+      const snapshot = await client.cheatcodes.exportSnapshot(config);
+      (0, import_fs2.writeFileSync)(options.output, JSON.stringify(snapshot, null, 2));
+      const accountCount = Object.keys(snapshot).length;
+      logger.success(`Snapshot exported successfully!`);
+      logger.log(`  Accounts: ${accountCount}`);
+      logger.log(`  Output: ${options.output}`);
+    } catch (error) {
+      logger.error(`Failed to export snapshot: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/stream-account.ts
+var import_commander51 = require("commander");
+var import_sdk51 = require("@surfman/sdk");
+function createStreamAccountCommand() {
+  const command = new import_commander51.Command("stream-account").description("Stream an account from the data source").requiredOption("--pubkey <address>", "Account public key").option("--include-owned", "Include owned accounts").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk51.Surfman(options.rpc);
+      const config = options.includeOwned ? { includeOwnedAccounts: true } : void 0;
+      await client.cheatcodes.streamAccount(options.pubkey, config);
+      logger.success(`Account streaming initiated!`);
+      logger.log(`  Account: ${options.pubkey}`);
+      if (options.includeOwned) {
+        logger.log(`  Include owned accounts: true`);
+      }
+    } catch (error) {
+      logger.error(`Failed to stream account: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/get-streamed-accounts.ts
+var import_commander52 = require("commander");
+var import_sdk52 = require("@surfman/sdk");
+function createGetStreamedAccountsCommand() {
+  const command = new import_commander52.Command("get-streamed-accounts").description("Get all streamed accounts").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk52.Surfman(options.rpc);
+      const result = await client.cheatcodes.getStreamedAccounts();
+      if (!result.accounts || result.accounts.length === 0) {
+        logger.log("No streamed accounts found.");
+        return;
+      }
+      logger.success(`Found ${result.accounts.length} streamed account(s):
+`);
+      result.accounts.forEach((account, index) => {
+        logger.log(`${index + 1}. ${account}`);
+      });
+    } catch (error) {
+      logger.error(`Failed to get streamed accounts: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/get-surfnet-info.ts
+var import_commander53 = require("commander");
+var import_sdk53 = require("@surfman/sdk");
+function createGetSurfnetInfoCommand() {
+  const command = new import_commander53.Command("get-surfnet-info").description("Get Surfnet network information").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk53.Surfman(options.rpc);
+      const info = await client.cheatcodes.getSurfnetInfo();
+      logger.success("Surfnet Info:\n");
+      logger.log("Runbook Executions:");
+      if (info.runbookExecutions.length === 0) {
+        logger.log("  No runbook executions found.");
+      } else {
+        info.runbookExecutions.forEach((execution, index) => {
+          logger.log(`
+${index + 1}. Runbook: ${execution.runbookId}`);
+          logger.log(`   Started At: ${new Date(execution.startedAt * 1e3).toISOString()}`);
+          if (execution.completedAt) {
+            logger.log(`   Completed At: ${new Date(execution.completedAt * 1e3).toISOString()}`);
+          } else {
+            logger.log(`   Status: Running`);
+          }
+        });
+      }
+    } catch (error) {
+      logger.error(`Failed to get Surfnet info: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/write-program.ts
+var import_commander54 = require("commander");
+var import_sdk54 = require("@surfman/sdk");
+var import_fs3 = require("fs");
+function createWriteProgramCommand() {
+  const command = new import_commander54.Command("write-program").description("Write program data at a specified offset").requiredOption("--program-id <address>", "Program ID").option("--data <hex>", "Hex-encoded program data").option("--data-file <path>", "Path to binary file containing program data").option("--offset <offset>", "Byte offset at which to write data", "0").option("--authority <address>", "Program authority").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk54.Surfman(options.rpc);
+      let dataHex;
+      if (options.data) {
+        dataHex = options.data;
+      } else if (options.dataFile) {
+        const buffer = (0, import_fs3.readFileSync)(options.dataFile);
+        dataHex = buffer.toString("hex");
+      } else {
+        logger.error("Either --data or --data-file must be specified");
+        process.exit(1);
+      }
+      const offset = parseInt(options.offset);
+      const authority = options.authority || void 0;
+      await client.cheatcodes.writeProgram(
+        options.programId,
+        dataHex,
+        offset,
+        authority
+      );
+      logger.success("Program data written successfully!");
+      logger.log(`  Program ID: ${options.programId}`);
+      logger.log(`  Offset: ${offset}`);
+      logger.log(`  Data length: ${dataHex.length / 2} bytes`);
+      if (authority) {
+        logger.log(`  Authority: ${authority}`);
+      }
+    } catch (error) {
+      logger.error(`Failed to write program: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/cheatcodes/register-scenario.ts
+var import_commander55 = require("commander");
+var import_sdk55 = require("@surfman/sdk");
+var import_fs4 = require("fs");
+function createRegisterScenarioCommand() {
+  const command = new import_commander55.Command("register-scenario").description("Register a scenario with account overrides").requiredOption("--scenario-file <path>", "Path to scenario JSON file").option("--slot <slot>", "Base slot for relative slot offsets").option("--rpc <url>", "RPC URL", "http://localhost:8899").action(async (options) => {
+    try {
+      const client = new import_sdk55.Surfman(options.rpc);
+      const scenarioContent = (0, import_fs4.readFileSync)(options.scenarioFile, "utf-8");
+      const scenario = JSON.parse(scenarioContent);
+      const slot = options.slot ? parseInt(options.slot) : void 0;
+      await client.cheatcodes.registerScenario(scenario, slot);
+      logger.success("Scenario registered successfully!");
+      logger.log(`  ID: ${scenario.id}`);
+      logger.log(`  Name: ${scenario.name}`);
+      logger.log(`  Overrides: ${scenario.overrides.length}`);
+      if (scenario.tags && scenario.tags.length > 0) {
+        logger.log(`  Tags: ${scenario.tags.join(", ")}`);
+      }
+      if (slot) {
+        logger.log(`  Base Slot: ${slot}`);
+      }
+    } catch (error) {
+      logger.error(`Failed to register scenario: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/ui.ts
+var import_commander56 = require("commander");
+var import_chalk6 = __toESM(require("chalk"));
+
+// src/server/index.ts
+var import_express = __toESM(require("express"));
+var import_cors = __toESM(require("cors"));
+var import_path = __toESM(require("path"));
+var import_ws = require("ws");
+var import_http = require("http");
+var import_sdk56 = require("@surfman/sdk");
+async function startWebServer(options) {
+  const app = (0, import_express.default)();
+  const server = (0, import_http.createServer)(app);
+  const wss = new import_ws.WebSocketServer({ server });
+  app.use((0, import_cors.default)());
+  app.use(import_express.default.json());
+  const client = new import_sdk56.Surfman(options.rpcUrl);
+  app.post("/api/rpc", async (req, res) => {
+    try {
+      const { method, params } = req.body;
+      const result = await client.request(method, params);
+      res.json({ result });
+    } catch (error) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+  app.get("/api/health", (req, res) => {
+    res.json({ status: "ok", rpcUrl: options.rpcUrl });
+  });
+  const staticPath = import_path.default.join(__dirname, "../../static");
+  app.use(import_express.default.static(staticPath));
+  app.get("*", (req, res) => {
+    res.sendFile(import_path.default.join(staticPath, "index.html"));
+  });
+  wss.on("connection", (ws) => {
+    console.log("WebSocket client connected");
+    ws.on("message", async (message) => {
+      try {
+        const request = JSON.parse(message.toString());
+        const result = await client.request(request.method, request.params);
+        ws.send(JSON.stringify({ id: request.id, result }));
+      } catch (error) {
+        ws.send(JSON.stringify({ error: error.message }));
+      }
+    });
+    ws.on("close", () => {
+      console.log("WebSocket client disconnected");
+    });
+  });
+  return new Promise((resolve) => {
+    server.listen(options.port, () => {
+      resolve();
+    });
+  });
+}
+
+// src/commands/ui.ts
+var import_child_process = require("child_process");
+function createUiCommand() {
+  const command = new import_commander56.Command("ui").description("Start Surfman Web UI").option("-p, --port <port>", "Port to run the web server on", "3000").option("--rpc <url>", "RPC endpoint URL", "http://localhost:8899").option("--no-open", "Do not automatically open browser").action(async (options) => {
+    const port = parseInt(options.port);
+    const rpcUrl = options.rpc;
+    const shouldOpen = options.open !== false;
+    console.log(import_chalk6.default.cyan("\n\u{1F30A} Starting Surfman Web UI...\n"));
+    console.log(import_chalk6.default.gray(`  Port: ${import_chalk6.default.white(port)}`));
+    console.log(import_chalk6.default.gray(`  RPC:  ${import_chalk6.default.white(rpcUrl)}`));
+    console.log();
+    try {
+      await startWebServer({
+        port,
+        rpcUrl,
+        openBrowser: shouldOpen
+      });
+      const url = `http://localhost:${port}`;
+      console.log(import_chalk6.default.green("\u2713 Web UI started successfully!\n"));
+      console.log(import_chalk6.default.bold("  Local:   ") + import_chalk6.default.cyan(url));
+      console.log();
+      console.log(import_chalk6.default.gray("  Press Ctrl+C to stop\n"));
+      if (shouldOpen) {
+        const command2 = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        (0, import_child_process.exec)(`${command2} ${url}`);
+      }
+      process.on("SIGINT", () => {
+        console.log(import_chalk6.default.yellow("\n\n\u{1F44B} Shutting down Surfman Web UI...\n"));
+        process.exit(0);
+      });
+    } catch (error) {
+      console.error(import_chalk6.default.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
 // src/index.ts
-var program = new import_commander39.Command();
+var program = new import_commander57.Command();
 var isFullHelp = process.argv.includes("--help");
 var isShortHelp = process.argv.includes("-h");
 if (isFullHelp) {
-  console.log(import_chalk2.default.bold.cyan("\n\u{1F30A} Surfman CLI - Complete Command List\n"));
-  console.log(import_chalk2.default.bold.yellow("\u{1F4E6} Account Queries (5 commands):\n"));
-  console.log(`  ${import_chalk2.default.yellow("get-account-info")}             Get detailed account information`);
-  console.log(`  ${import_chalk2.default.yellow("get-multiple-accounts")}        Batch query multiple accounts`);
-  console.log(`  ${import_chalk2.default.yellow("get-token-account-balance")}    Get token account balance`);
-  console.log(`  ${import_chalk2.default.yellow("get-token-supply")}             Get total token supply`);
-  console.log(`  ${import_chalk2.default.yellow("get-block-commitment")}         Get block commitment data
+  console.log(import_chalk7.default.bold.cyan("\n\u{1F30A} Surfman CLI - Complete Command List\n"));
+  console.log(import_chalk7.default.bold.yellow("\u{1F4E6} Account Queries (5 commands):\n"));
+  console.log(`  ${import_chalk7.default.yellow("get-account-info")}             Get detailed account information`);
+  console.log(`  ${import_chalk7.default.yellow("get-multiple-accounts")}        Batch query multiple accounts`);
+  console.log(`  ${import_chalk7.default.yellow("get-token-account-balance")}    Get token account balance`);
+  console.log(`  ${import_chalk7.default.yellow("get-token-supply")}             Get total token supply`);
+  console.log(`  ${import_chalk7.default.yellow("get-block-commitment")}         Get block commitment data
+`);
+  console.log(import_chalk7.default.bold.blue("\u{1F310} Network Operations (22 commands):\n"));
+  console.log(import_chalk7.default.dim("  Block Queries:"));
+  console.log(`  ${import_chalk7.default.blue("get-latest-blockhash")}         Get the latest blockhash`);
+  console.log(`  ${import_chalk7.default.blue("get-block")}                     Get block information by slot`);
+  console.log(`  ${import_chalk7.default.blue("get-block-time")}                Get block production time`);
+  console.log(`  ${import_chalk7.default.blue("get-blocks")}                    Get list of confirmed blocks`);
+  console.log(`  ${import_chalk7.default.blue("get-blocks-with-limit")}         Get blocks with limit`);
+  console.log(`  ${import_chalk7.default.blue("get-first-available-block")}     Get first available block`);
+  console.log(`  ${import_chalk7.default.blue("minimum-ledger-slot")}           Get minimum ledger slot`);
+  console.log(`  ${import_chalk7.default.blue("get-max-retransmit-slot")}       Get max retransmit slot`);
+  console.log(`  ${import_chalk7.default.blue("get-max-shred-insert-slot")}     Get max shred insert slot
+`);
+  console.log(import_chalk7.default.dim("  Transaction Operations:"));
+  console.log(`  ${import_chalk7.default.blue("get-transaction")}               Get transaction details`);
+  console.log(`  ${import_chalk7.default.blue("get-signature-statuses")}        Get signature statuses`);
+  console.log(`  ${import_chalk7.default.blue("get-signatures-for-address")}    Get address transaction history`);
+  console.log(`  ${import_chalk7.default.blue("send-transaction")}              Send a signed transaction`);
+  console.log(`  ${import_chalk7.default.blue("simulate-transaction")}          Simulate transaction execution
+`);
+  console.log(import_chalk7.default.dim("  Network Info & Fees:"));
+  console.log(`  ${import_chalk7.default.blue("is-blockhash-valid")}            Check if blockhash is valid`);
+  console.log(`  ${import_chalk7.default.blue("get-fee-for-message")}           Get fee for a message`);
+  console.log(`  ${import_chalk7.default.blue("get-recent-prioritization-fees")} Get recent priority fees`);
+  console.log(`  ${import_chalk7.default.blue("get-cluster-nodes")}             Get cluster node information`);
+  console.log(`  ${import_chalk7.default.blue("get-recent-performance-samples")} Get performance samples`);
+  console.log(`  ${import_chalk7.default.blue("request-airdrop")}               Request lamports airdrop`);
+  console.log(`  ${import_chalk7.default.blue("get-inflation-reward")}          Get inflation rewards`);
+  console.log(`  ${import_chalk7.default.blue("get-stake-minimum-delegation")}  Get min stake delegation
+`);
+  console.log(import_chalk7.default.bold.magenta("\u{1F527} Testing & Development (22 commands):\n"));
+  console.log(import_chalk7.default.dim("  Time Control:"));
+  console.log(`  ${import_chalk7.default.magenta("time-travel")}                  Time travel to epoch/slot/timestamp`);
+  console.log(`  ${import_chalk7.default.magenta("pause-clock")}                  Pause the network clock`);
+  console.log(`  ${import_chalk7.default.magenta("resume-clock")}                 Resume the network clock
 `);
-  console.log(import_chalk2.default.bold.blue("\u{1F310} Network Operations (18 commands):\n"));
-  console.log(import_chalk2.default.dim("  Block Queries:"));
-  console.log(`  ${import_chalk2.default.blue("get-latest-blockhash")}         Get the latest blockhash`);
-  console.log(`  ${import_chalk2.default.blue("get-block")}                     Get block information by slot`);
-  console.log(`  ${import_chalk2.default.blue("get-block-time")}                Get block production time`);
-  console.log(`  ${import_chalk2.default.blue("get-blocks")}                    Get list of confirmed blocks`);
-  console.log(`  ${import_chalk2.default.blue("get-blocks-with-limit")}         Get blocks with limit`);
-  console.log(`  ${import_chalk2.default.blue("get-first-available-block")}     Get first available block`);
-  console.log(`  ${import_chalk2.default.blue("minimum-ledger-slot")}           Get minimum ledger slot
+  console.log(import_chalk7.default.bold.cyan("\u{1F4BB} Web Interface (1 command):\n"));
+  console.log(`  ${import_chalk7.default.cyan("ui")}                             Start Windows 95-style Web UI
 `);
-  console.log(import_chalk2.default.dim("  Transaction Operations:"));
-  console.log(`  ${import_chalk2.default.blue("get-transaction")}               Get transaction details`);
-  console.log(`  ${import_chalk2.default.blue("get-signature-statuses")}        Get signature statuses`);
-  console.log(`  ${import_chalk2.default.blue("get-signatures-for-address")}    Get address transaction history`);
-  console.log(`  ${import_chalk2.default.blue("send-transaction")}              Send a signed transaction`);
-  console.log(`  ${import_chalk2.default.blue("simulate-transaction")}          Simulate transaction execution
+  console.log(import_chalk7.default.dim("  Account Manipulation:"));
+  console.log(`  ${import_chalk7.default.magenta("set-account")}                  Modify account data/lamports/owner`);
+  console.log(`  ${import_chalk7.default.magenta("set-token-account")}            Update token account properties`);
+  console.log(`  ${import_chalk7.default.magenta("reset-account")}                Reset account to initial state`);
+  console.log(`  ${import_chalk7.default.magenta("stream-account")}               Stream account from data source`);
+  console.log(`  ${import_chalk7.default.magenta("get-streamed-accounts")}        Get all streamed accounts
 `);
-  console.log(import_chalk2.default.dim("  Network Info & Fees:"));
-  console.log(`  ${import_chalk2.default.blue("is-blockhash-valid")}            Check if blockhash is valid`);
-  console.log(`  ${import_chalk2.default.blue("get-fee-for-message")}           Get fee for a message`);
-  console.log(`  ${import_chalk2.default.blue("get-recent-prioritization-fees")} Get recent priority fees`);
-  console.log(`  ${import_chalk2.default.blue("get-cluster-nodes")}             Get cluster node information`);
-  console.log(`  ${import_chalk2.default.blue("get-recent-performance-samples")} Get performance samples`);
-  console.log(`  ${import_chalk2.default.blue("request-airdrop")}               Request lamports airdrop
+  console.log(import_chalk7.default.dim("  Program Management:"));
+  console.log(`  ${import_chalk7.default.magenta("clone-program-account")}        Clone program to another address`);
+  console.log(`  ${import_chalk7.default.magenta("set-program-authority")}        Set/remove program authority`);
+  console.log(`  ${import_chalk7.default.magenta("write-program")}                Write program data in chunks
 `);
-  console.log(import_chalk2.default.bold.magenta("\u{1F527} Testing & Development (9 commands):\n"));
-  console.log(import_chalk2.default.dim("  Time Control:"));
-  console.log(`  ${import_chalk2.default.magenta("time-travel")}                  Time travel to epoch/slot/timestamp`);
-  console.log(`  ${import_chalk2.default.magenta("pause-clock")}                  Pause the network clock`);
-  console.log(`  ${import_chalk2.default.magenta("resume-clock")}                 Resume the network clock
+  console.log(import_chalk7.default.dim("  Transaction Profiling:"));
+  console.log(`  ${import_chalk7.default.magenta("profile-transaction")}          Profile transaction compute units`);
+  console.log(`  ${import_chalk7.default.magenta("get-transaction-profile")}      Get profile by signature/UUID`);
+  console.log(`  ${import_chalk7.default.magenta("get-profile-results-by-tag")}   Get all profiles for a tag
 `);
-  console.log(import_chalk2.default.dim("  Account Manipulation:"));
-  console.log(`  ${import_chalk2.default.magenta("set-account")}                  Modify account data/lamports/owner`);
-  console.log(`  ${import_chalk2.default.magenta("set-token-account")}            Update token account properties`);
-  console.log(`  ${import_chalk2.default.magenta("reset-account")}                Reset account to initial state
+  console.log(import_chalk7.default.dim("  IDL Management:"));
+  console.log(`  ${import_chalk7.default.magenta("register-idl")}                 Register program IDL`);
+  console.log(`  ${import_chalk7.default.magenta("get-idl")}                      Get registered program IDL
 `);
-  console.log(import_chalk2.default.dim("  Network Management:"));
-  console.log(`  ${import_chalk2.default.magenta("reset-network")}                Reset entire network state`);
-  console.log(`  ${import_chalk2.default.magenta("get-local-signatures")}         Get recent local signatures`);
-  console.log(`  ${import_chalk2.default.magenta("set-program-authority")}        Set/remove program authority
+  console.log(import_chalk7.default.dim("  Snapshots & Scenarios:"));
+  console.log(`  ${import_chalk7.default.magenta("export-snapshot")}              Export account snapshots`);
+  console.log(`  ${import_chalk7.default.magenta("register-scenario")}            Register test scenarios
 `);
-  console.log(import_chalk2.default.bold.green("\u{1F4CA} Scan & Analytics (6 commands):\n"));
-  console.log(import_chalk2.default.dim("  Batch Queries:"));
-  console.log(`  ${import_chalk2.default.green("get-program-accounts")}          Get all accounts owned by a program`);
-  console.log(`  ${import_chalk2.default.green("get-largest-accounts")}          Get top 20 accounts by balance`);
-  console.log(`  ${import_chalk2.default.green("get-supply")}                    Get network supply information
+  console.log(import_chalk7.default.dim("  Network Management:"));
+  console.log(`  ${import_chalk7.default.magenta("reset-network")}                Reset entire network state`);
+  console.log(`  ${import_chalk7.default.magenta("get-local-signatures")}         Get recent local signatures`);
+  console.log(`  ${import_chalk7.default.magenta("set-supply")}                   Set network supply info`);
+  console.log(`  ${import_chalk7.default.magenta("get-surfnet-info")}             Get Surfnet network info
 `);
-  console.log(import_chalk2.default.dim("  Token Distribution:"));
-  console.log(`  ${import_chalk2.default.green("get-token-largest-accounts")}    Get largest token holders`);
-  console.log(`  ${import_chalk2.default.green("get-token-accounts-by-owner")}   Get token accounts by owner`);
-  console.log(`  ${import_chalk2.default.green("get-token-accounts-by-delegate")} Get delegated token accounts
+  console.log(import_chalk7.default.bold.green("\u{1F4CA} Scan & Analytics (6 commands):\n"));
+  console.log(import_chalk7.default.dim("  Batch Queries:"));
+  console.log(`  ${import_chalk7.default.green("get-program-accounts")}          Get all accounts owned by a program`);
+  console.log(`  ${import_chalk7.default.green("get-largest-accounts")}          Get top 20 accounts by balance`);
+  console.log(`  ${import_chalk7.default.green("get-supply")}                    Get network supply information
 `);
-  console.log(import_chalk2.default.bold.cyan("\u{1F4CA} Summary:\n"));
-  console.log(`  Total Commands: ${import_chalk2.default.bold("38")}`);
-  console.log(`  Account Queries: ${import_chalk2.default.yellow("5")}`);
-  console.log(`  Network Operations: ${import_chalk2.default.blue("18")}`);
-  console.log(`  Testing & Development: ${import_chalk2.default.magenta("9")}`);
-  console.log(`  Scan & Analytics: ${import_chalk2.default.green("6")}
+  console.log(import_chalk7.default.dim("  Token Distribution:"));
+  console.log(`  ${import_chalk7.default.green("get-token-largest-accounts")}    Get largest token holders`);
+  console.log(`  ${import_chalk7.default.green("get-token-accounts-by-owner")}   Get token accounts by owner`);
+  console.log(`  ${import_chalk7.default.green("get-token-accounts-by-delegate")} Get delegated token accounts
 `);
-  console.log(import_chalk2.default.gray("\u{1F4A1} Use ") + import_chalk2.default.cyan("surfman <command> --help") + import_chalk2.default.gray(" for detailed options\n"));
+  console.log(import_chalk7.default.bold.cyan("\u{1F4CA} Summary:\n"));
+  console.log(`  Total Commands: ${import_chalk7.default.bold("56")}`);
+  console.log(`  Account Queries: ${import_chalk7.default.yellow("5")}`);
+  console.log(`  Network Operations: ${import_chalk7.default.blue("22")}`);
+  console.log(`  Testing & Development: ${import_chalk7.default.magenta("22")}`);
+  console.log(`  Scan & Analytics: ${import_chalk7.default.green("6")}`);
+  console.log(`  Web Interface: ${import_chalk7.default.cyan("1")}
+`);
+  console.log(import_chalk7.default.gray("\u{1F4A1} Use ") + import_chalk7.default.cyan("surfman <command> --help") + import_chalk7.default.gray(" for detailed options\n"));
   process.exit(0);
 }
 program.name("surfman").description("CLI tool for SurfPool RPC API interaction").version("0.1.0");
@@ -1396,100 +2054,117 @@ program.configureHelp({
     const termWidth = helper.padWidth(cmd, helper);
     const helpWidth = helper.helpWidth || 80;
     let output = "";
-    output += import_chalk2.default.bold.cyan("\n\u{1F30A} Surfman CLI\n\n");
-    output += import_chalk2.default.gray("CLI tool for SurfPool RPC API interaction\n\n");
-    output += import_chalk2.default.bold("Usage:\n");
-    output += `  $ surfman ${import_chalk2.default.yellow("<command>")} ${import_chalk2.default.gray("[options]")}
+    output += import_chalk7.default.bold.cyan("\n\u{1F30A} Surfman CLI\n\n");
+    output += import_chalk7.default.gray("CLI tool for SurfPool RPC API interaction\n\n");
+    output += import_chalk7.default.bold("Usage:\n");
+    output += `  $ surfman ${import_chalk7.default.yellow("<command>")} ${import_chalk7.default.gray("[options]")}
 
 `;
-    output += import_chalk2.default.bold("Options:\n");
-    output += `  -V, --version    ${import_chalk2.default.gray("Output the version number")}
+    output += import_chalk7.default.bold("Options:\n");
+    output += `  -V, --version    ${import_chalk7.default.gray("Output the version number")}
 `;
-    output += `  -h               ${import_chalk2.default.gray("Display frequently used commands (quick view)")}
+    output += `  -h               ${import_chalk7.default.gray("Display frequently used commands (quick view)")}
 `;
-    output += `  --help           ${import_chalk2.default.gray("Display all commands grouped by module")}
+    output += `  --help           ${import_chalk7.default.gray("Display all commands grouped by module")}
 
 `;
-    output += import_chalk2.default.bold.green("\u2B50 Frequently Used:\n");
-    output += `  ${import_chalk2.default.cyan("get-account-info")}             ${import_chalk2.default.gray("Get account information")}
+    output += import_chalk7.default.bold.green("\u2B50 Frequently Used:\n");
+    output += `  ${import_chalk7.default.cyan("get-account-info")}             ${import_chalk7.default.gray("Get account information")}
 `;
-    output += `  ${import_chalk2.default.cyan("get-latest-blockhash")}         ${import_chalk2.default.gray("Get latest blockhash")}
+    output += `  ${import_chalk7.default.cyan("get-latest-blockhash")}         ${import_chalk7.default.gray("Get latest blockhash")}
 `;
-    output += `  ${import_chalk2.default.cyan("send-transaction")}             ${import_chalk2.default.gray("Send a transaction")}
+    output += `  ${import_chalk7.default.cyan("send-transaction")}             ${import_chalk7.default.gray("Send a transaction")}
 `;
-    output += `  ${import_chalk2.default.cyan("request-airdrop")}              ${import_chalk2.default.gray("Request SOL airdrop")}
+    output += `  ${import_chalk7.default.cyan("request-airdrop")}              ${import_chalk7.default.gray("Request SOL airdrop")}
 `;
-    output += `  ${import_chalk2.default.cyan("time-travel")}                  ${import_chalk2.default.gray("Time travel for testing")}
+    output += `  ${import_chalk7.default.cyan("time-travel")}                  ${import_chalk7.default.gray("Time travel for testing")}
 
 `;
-    output += import_chalk2.default.bold.yellow("\u{1F4E6} Account Queries:\n");
-    output += `  ${import_chalk2.default.yellow("get-account-info")}             Get detailed account information
+    output += import_chalk7.default.bold.yellow("\u{1F4E6} Account Queries:\n");
+    output += `  ${import_chalk7.default.yellow("get-account-info")}             Get detailed account information
 `;
-    output += `  ${import_chalk2.default.yellow("get-multiple-accounts")}        Batch query multiple accounts
+    output += `  ${import_chalk7.default.yellow("get-multiple-accounts")}        Batch query multiple accounts
 `;
-    output += `  ${import_chalk2.default.yellow("get-token-account-balance")}    Get token account balance
+    output += `  ${import_chalk7.default.yellow("get-token-account-balance")}    Get token account balance
 `;
-    output += `  ${import_chalk2.default.yellow("get-token-supply")}             Get total token supply
+    output += `  ${import_chalk7.default.yellow("get-token-supply")}             Get total token supply
 `;
-    output += `  ${import_chalk2.default.yellow("get-block-commitment")}         Get block commitment data
+    output += `  ${import_chalk7.default.yellow("get-block-commitment")}         Get block commitment data
 
 `;
-    output += import_chalk2.default.bold.blue("\u{1F310} Network Operations:\n");
-    output += `  ${import_chalk2.default.blue("get-latest-blockhash")}         Get the latest blockhash
+    output += import_chalk7.default.bold.blue("\u{1F310} Network Operations:\n");
+    output += `  ${import_chalk7.default.blue("get-latest-blockhash")}         Get the latest blockhash
 `;
-    output += `  ${import_chalk2.default.blue("get-block")}                     Get block by slot
+    output += `  ${import_chalk7.default.blue("get-block")}                     Get block by slot
 `;
-    output += `  ${import_chalk2.default.blue("get-transaction")}               Get transaction details
+    output += `  ${import_chalk7.default.blue("get-transaction")}               Get transaction details
 `;
-    output += `  ${import_chalk2.default.blue("send-transaction")}              Send a signed transaction
+    output += `  ${import_chalk7.default.blue("send-transaction")}              Send a signed transaction
 `;
-    output += `  ${import_chalk2.default.blue("simulate-transaction")}          Simulate transaction execution
+    output += `  ${import_chalk7.default.blue("simulate-transaction")}          Simulate transaction execution
 `;
-    output += `  ${import_chalk2.default.blue("get-signatures-for-address")}    Get address transaction history
+    output += `  ${import_chalk7.default.blue("get-signatures-for-address")}    Get address transaction history
 `;
-    output += `  ${import_chalk2.default.blue("request-airdrop")}               Request lamports airdrop
+    output += `  ${import_chalk7.default.blue("request-airdrop")}               Request lamports airdrop
 `;
-    output += `  ${import_chalk2.default.blue("get-cluster-nodes")}             Get cluster node info
+    output += `  ${import_chalk7.default.blue("get-cluster-nodes")}             Get cluster node info
 
 `;
-    output += import_chalk2.default.bold.magenta("\u{1F527} Testing & Development:\n");
-    output += `  ${import_chalk2.default.magenta("time-travel")}                  Time travel to epoch/slot
+    output += import_chalk7.default.bold.magenta("\u{1F527} Testing & Development(Cheatcodes):\n");
+    output += `  ${import_chalk7.default.magenta("time-travel")}                  Time travel to epoch/slot
+`;
+    output += `  ${import_chalk7.default.magenta("pause-clock")}                  Pause network clock
 `;
-    output += `  ${import_chalk2.default.magenta("pause-clock")}                  Pause network clock
+    output += `  ${import_chalk7.default.magenta("resume-clock")}                 Resume network clock
 `;
-    output += `  ${import_chalk2.default.magenta("resume-clock")}                 Resume network clock
+    output += `  ${import_chalk7.default.magenta("set-account")}                  Modify account data
 `;
-    output += `  ${import_chalk2.default.magenta("set-account")}                  Modify account data
+    output += `  ${import_chalk7.default.magenta("set-token-account")}            Update token account
 `;
-    output += `  ${import_chalk2.default.magenta("set-token-account")}            Update token account
+    output += `  ${import_chalk7.default.magenta("reset-account")}                Reset account state
 `;
-    output += `  ${import_chalk2.default.magenta("reset-account")}                Reset account state
+    output += `  ${import_chalk7.default.magenta("reset-network")}                Reset entire network
 `;
-    output += `  ${import_chalk2.default.magenta("reset-network")}                Reset entire network
+    output += `  ${import_chalk7.default.magenta("set-program-authority")}        Set program authority
+
 `;
-    output += `  ${import_chalk2.default.magenta("set-program-authority")}        Set program authority
+    output += import_chalk7.default.bold.cyan("\u{1F4BB} Web Interface:\n");
+    output += `  ${import_chalk7.default.cyan("ui")}                             Start Windows 95-style Web UI
 
 `;
-    output += import_chalk2.default.bold.gray("\u{1F4CB} Additional Commands:\n");
-    output += import_chalk2.default.gray("  get-blocks, get-block-time, is-blockhash-valid,\n");
-    output += import_chalk2.default.gray("  get-fee-for-message, get-signature-statuses,\n");
-    output += import_chalk2.default.gray("  get-recent-prioritization-fees, and more...\n\n");
-    output += import_chalk2.default.gray("\u{1F4A1} Tips:\n");
-    output += import_chalk2.default.gray("   Use ") + import_chalk2.default.cyan("surfman --help") + import_chalk2.default.gray(" to see all 38 commands grouped by module\n");
-    output += import_chalk2.default.gray("   Use ") + import_chalk2.default.cyan("surfman <command> --help") + import_chalk2.default.gray(" for detailed command options\n");
-    output += import_chalk2.default.gray("\u{1F4D6} Documentation: ") + import_chalk2.default.cyan("https://github.com/your-repo/surfman\n");
+    output += import_chalk7.default.bold.gray("\u{1F4CB} Additional Commands:\n");
+    output += import_chalk7.default.gray("  get-blocks, get-block-time, is-blockhash-valid,\n");
+    output += import_chalk7.default.gray("  get-fee-for-message, get-signature-statuses,\n");
+    output += import_chalk7.default.gray("  get-recent-prioritization-fees, and more...\n\n");
+    output += import_chalk7.default.gray("\u{1F4A1} Tips:\n");
+    output += import_chalk7.default.gray("   Use ") + import_chalk7.default.cyan("surfman --help") + import_chalk7.default.gray(" to see all 56 commands grouped by module\n");
+    output += import_chalk7.default.gray("   Use ") + import_chalk7.default.cyan("surfman <command> --help") + import_chalk7.default.gray(" for detailed command options\n");
+    output += import_chalk7.default.gray("\u{1F4D6} Documentation: ") + import_chalk7.default.cyan("https://github.com/ennea8/surfman\n");
     return output;
   }
 });
 program.addCommand(createTimeTravelCommand());
-program.addCommand(createSetAccountCommand());
-program.addCommand(createSetProgramAuthorityCommand());
 program.addCommand(createPauseClockCommand());
 program.addCommand(createResumeClockCommand());
-program.addCommand(createGetLocalSignaturesCommand());
+program.addCommand(createSetAccountCommand());
 program.addCommand(createSetTokenAccountCommand());
 program.addCommand(createResetAccountCommand());
+program.addCommand(createStreamAccountCommand());
+program.addCommand(createGetStreamedAccountsCommand());
+program.addCommand(createCloneProgramAccountCommand());
+program.addCommand(createSetProgramAuthorityCommand());
+program.addCommand(createWriteProgramCommand());
+program.addCommand(createProfileTransactionCommand());
+program.addCommand(createGetTransactionProfileCommand());
+program.addCommand(createGetProfileResultsByTagCommand());
+program.addCommand(createRegisterIdlCommand());
+program.addCommand(createGetIdlCommand());
+program.addCommand(createExportSnapshotCommand());
+program.addCommand(createRegisterScenarioCommand());
 program.addCommand(createResetNetworkCommand());
+program.addCommand(createGetLocalSignaturesCommand());
+program.addCommand(createSetSupplyCommand());
+program.addCommand(createGetSurfnetInfoCommand());
 program.addCommand(createGetLatestBlockhashCommand());
 program.addCommand(createGetBlockCommand());
 program.addCommand(createGetTransactionCommand());
@@ -1508,6 +2183,10 @@ program.addCommand(createMinimumLedgerSlotCommand());
 program.addCommand(createGetSignatureStatusesCommand());
 program.addCommand(createSimulateTransactionCommand());
 program.addCommand(createGetRecentPerformanceSamplesCommand());
+program.addCommand(createGetInflationRewardCommand());
+program.addCommand(createGetMaxRetransmitSlotCommand());
+program.addCommand(createGetMaxShredInsertSlotCommand());
+program.addCommand(createGetStakeMinimumDelegationCommand());
 program.addCommand(createGetAccountInfoCommand());
 program.addCommand(createGetMultipleAccountsCommand());
 program.addCommand(createGetBlockCommitmentCommand());
@@ -1519,5 +2198,6 @@ program.addCommand(createGetSupplyCommand());
 program.addCommand(createGetTokenLargestAccountsCommand());
 program.addCommand(createGetTokenAccountsByOwnerCommand());
 program.addCommand(createGetTokenAccountsByDelegateCommand());
+program.addCommand(createUiCommand());
 program.parse();
 //# sourceMappingURL=index.js.map