@joai/warps-adapter-solana 1.0.1 → 1.1.0

package/dist/index.mjs

@@ -9,8 +9,7 @@ import {
   WarpCache,
   WarpCacheKey
 } from "@joai/warps";
-import { Connection, PublicKey } from "@solana/web3.js";
-import { getMint } from "@solana/spl-token";
+import { Connection as Connection2, PublicKey as PublicKey2 } from "@solana/web3.js";
 
 // src/constants.ts
 var WarpSolanaConstants = {
@@ -72,6 +71,58 @@ var X402SolanaNetworkIdentifiers = {
 };
 var SupportedX402SolanaNetworks = [X402SolanaNetworkIdentifiers.Mainnet, X402SolanaNetworkIdentifiers.Devnet];
 
+// src/tokenProgram.ts
+import { PublicKey, SystemProgram, TransactionInstruction } from "@solana/web3.js";
+var MINT_SIZE = 82;
+var TOKEN_TRANSFER_INSTRUCTION = 3;
+var TOKEN_PROGRAM_ID = new PublicKey(WarpSolanaConstants.Programs.TokenProgram);
+var ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+var getAssociatedTokenAddress = async (mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) => getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve, programId, associatedTokenProgramId);
+var getAssociatedTokenAddressSync = (mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) => {
+  if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer())) {
+    throw new Error("Owner cannot be a PDA");
+  }
+  const [address] = PublicKey.findProgramAddressSync([owner.toBuffer(), programId.toBuffer(), mint.toBuffer()], associatedTokenProgramId);
+  return address;
+};
+var createAssociatedTokenAccountInstruction = (payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) => new TransactionInstruction({
+  keys: [
+    { pubkey: payer, isSigner: true, isWritable: true },
+    { pubkey: associatedToken, isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: false, isWritable: false },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: programId, isSigner: false, isWritable: false }
+  ],
+  programId: associatedTokenProgramId,
+  data: Buffer.alloc(0)
+});
+var createTransferInstruction = (source, destination, owner, amount, programId = TOKEN_PROGRAM_ID) => {
+  const data = Buffer.alloc(9);
+  data.writeUInt8(TOKEN_TRANSFER_INSTRUCTION, 0);
+  data.writeBigUInt64LE(BigInt(amount), 1);
+  return new TransactionInstruction({
+    keys: [
+      { pubkey: source, isSigner: false, isWritable: true },
+      { pubkey: destination, isSigner: false, isWritable: true },
+      { pubkey: owner, isSigner: true, isWritable: false }
+    ],
+    programId,
+    data
+  });
+};
+var getMint = async (connection, address, commitment, programId = TOKEN_PROGRAM_ID) => {
+  const info = await connection.getAccountInfo(address, commitment);
+  if (!info) throw new Error("Token mint account not found");
+  if (!info.owner.equals(programId)) throw new Error("Token mint account owner mismatch");
+  if (info.data.length < MINT_SIZE) throw new Error("Token mint account has invalid size");
+  return {
+    address,
+    decimals: info.data.readUInt8(44),
+    isInitialized: info.data.readUInt8(45) !== 0
+  };
+};
+
 // src/tokens.ts
 import { WarpChainName as WarpChainName4 } from "@joai/warps";
 
@@ -275,12 +326,12 @@ var WarpSolanaDataLoader = class {
     this.config = config;
     this.chain = chain;
     const providerConfig = getProviderConfig(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.connection = new Connection(providerConfig.url, "confirmed");
+    this.connection = new Connection2(providerConfig.url, "confirmed");
     this.cache = new WarpCache(config.env, config.cache);
   }
   async getAccount(address) {
     try {
-      const publicKey = new PublicKey(address);
+      const publicKey = new PublicKey2(address);
       const balance = await this.connection.getBalance(publicKey);
       return {
         chain: this.chain.name,
@@ -320,7 +371,7 @@ var WarpSolanaDataLoader = class {
         return this.chain.nativeToken;
       }
       const cacheKey = WarpCacheKey.Asset(this.config.env, this.chain.name, identifier);
-      const cachedAsset = this.cache.get(cacheKey);
+      const cachedAsset = await this.cache.get(cacheKey);
       if (cachedAsset) {
         return cachedAsset;
       }
@@ -347,7 +398,7 @@ var WarpSolanaDataLoader = class {
         decimals: metadata.decimals,
         logoUrl: metadata.logoUrl
       };
-      this.cache.set(cacheKey, asset, CacheTtl.OneHour);
+      await this.cache.set(cacheKey, asset, CacheTtl.OneHour);
       return asset;
     } catch (error) {
       return null;
@@ -378,9 +429,9 @@ var WarpSolanaDataLoader = class {
   }
   async getTokenBalances(address) {
     try {
-      const publicKey = new PublicKey(address);
+      const publicKey = new PublicKey2(address);
       const tokenAccounts = await this.connection.getParsedTokenAccountsByOwner(publicKey, {
-        programId: new PublicKey(WarpSolanaConstants.Programs.TokenProgram)
+        programId: new PublicKey2(WarpSolanaConstants.Programs.TokenProgram)
       });
       const env = this.config.env === "mainnet" ? "mainnet" : this.config.env === "devnet" ? "devnet" : "testnet";
       const knownTokens = getKnownTokensForChain(this.chain.name, env);
@@ -422,7 +473,7 @@ var WarpSolanaDataLoader = class {
   }
   async getTokenMetadata(tokenAddress) {
     try {
-      const mintPublicKey = new PublicKey(tokenAddress);
+      const mintPublicKey = new PublicKey2(tokenAddress);
       const mintInfo = await getMint(this.connection, mintPublicKey);
       return {
         name: "Unknown Token",
@@ -572,8 +623,7 @@ var WarpSolanaDataLoader = class {
 };
 
 // src/WarpSolanaExecutor.ts
-import { createAssociatedTokenAccountInstruction, createTransferInstruction, getAssociatedTokenAddress } from "@solana/spl-token";
-import { ComputeBudgetProgram, Connection as Connection3, MessageV0, PublicKey as PublicKey3, SystemProgram, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+import { ComputeBudgetProgram, Connection as Connection4, MessageV0, PublicKey as PublicKey4, SystemProgram as SystemProgram2, TransactionInstruction as TransactionInstruction2, VersionedTransaction } from "@solana/web3.js";
 import {
   applyOutputToMessages,
   extractResolvedInputValues as extractResolvedInputValues2,
@@ -594,14 +644,14 @@ import {
   WarpCache as WarpCache2,
   WarpCacheKey as WarpCacheKey2
 } from "@joai/warps";
-import { Connection as Connection2 } from "@solana/web3.js";
+import { Connection as Connection3 } from "@solana/web3.js";
 
 // src/WarpSolanaSerializer.ts
 import {
   WarpConstants,
   WarpSerializer
 } from "@joai/warps";
-import { PublicKey as PublicKey2 } from "@solana/web3.js";
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
 import bs58 from "bs58";
 var WarpSolanaSerializer = class {
   constructor() {
@@ -614,7 +664,7 @@ var WarpSolanaSerializer = class {
     if (typeof value === "string") {
       if (value.length >= 32 && value.length <= 44) {
         try {
-          const pubkey = new PublicKey2(value);
+          const pubkey = new PublicKey3(value);
           if (pubkey.toBase58() === value && /^[1-9A-HJ-NP-Za-km-z]+$/.test(value)) {
             return `address:${value}`;
           }
@@ -641,7 +691,7 @@ var WarpSolanaSerializer = class {
     if (typeof value === "boolean") {
       return `boolean:${value}`;
     }
-    if (value instanceof PublicKey2) {
+    if (value instanceof PublicKey3) {
       return `address:${value.toBase58()}`;
     }
     if (value instanceof Uint8Array) {
@@ -791,11 +841,11 @@ var WarpSolanaOutput = class {
     this.chain = chain;
     this.serializer = new WarpSolanaSerializer();
     const providerConfig = getProviderConfig2(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.connection = new Connection2(providerConfig.url, "confirmed");
+    this.connection = new Connection3(providerConfig.url, "confirmed");
     this.cache = new WarpCache2(config.env, config.cache);
   }
   async getActionExecution(warp, actionIndex, tx) {
-    const inputs = this.cache.get(WarpCacheKey2.WarpExecutable(this.config.env, warp.meta?.hash || "", actionIndex)) ?? [];
+    const inputs = await this.cache.get(WarpCacheKey2.WarpExecutable(this.config.env, warp.meta?.hash || "", actionIndex)) ?? [];
     const resolvedInputs = extractResolvedInputValues(inputs);
     if (!tx) {
       return this.createFailedExecution(warp, actionIndex, resolvedInputs);
@@ -967,7 +1017,7 @@ var WarpSolanaExecutor = class {
     this.chain = chain;
     this.serializer = new WarpSolanaSerializer();
     const providerConfig = getProviderConfig3(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.connection = new Connection3(providerConfig.url, "confirmed");
+    this.connection = new Connection4(providerConfig.url, "confirmed");
     this.output = new WarpSolanaOutput(config, this.chain);
   }
   async createTransaction(executable) {
@@ -996,14 +1046,14 @@ var WarpSolanaExecutor = class {
     }
     const instructions = [];
     if (executable.value > 0n) {
-      instructions.push(SystemProgram.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(executable.value) }));
+      instructions.push(SystemProgram2.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(executable.value) }));
     }
     if (executable.data) {
       const data = this.serializer.stringToTyped(executable.data);
       if (data && typeof data === "string") {
         const dataBuffer = Buffer.from(data, "base64");
         instructions.push(
-          new TransactionInstruction({
+          new TransactionInstruction2({
             keys: [
               { pubkey: fromPubkey, isSigner: true, isWritable: true },
               { pubkey: destinationPubkey, isSigner: false, isWritable: true }
@@ -1032,9 +1082,9 @@ var WarpSolanaExecutor = class {
     const abiAccounts = parsedAbi?.instructions?.[action.func]?.accounts ?? null;
     const accounts = await this.buildInstructionAccounts(action, executable, fromPubkey, programId, abiAccounts);
     await this.ensureATAs(abiAccounts, accounts, fromPubkey, instructions);
-    instructions.push(new TransactionInstruction({ keys: accounts, programId, data: instructionData }));
+    instructions.push(new TransactionInstruction2({ keys: accounts, programId, data: instructionData }));
     if (executable.value > 0n) {
-      instructions.push(SystemProgram.transfer({ fromPubkey, toPubkey: programId, lamports: Number(executable.value) }));
+      instructions.push(SystemProgram2.transfer({ fromPubkey, toPubkey: programId, lamports: Number(executable.value) }));
     }
     return this.setTransactionDefaults(instructions, fromPubkey);
   }
@@ -1057,7 +1107,7 @@ var WarpSolanaExecutor = class {
         if (match) {
           const mintAddress = match[1];
           try {
-            const mintPubkey = new PublicKey3(mintAddress);
+            const mintPubkey = new PublicKey4(mintAddress);
             const expectedAta = await getAssociatedTokenAddress(mintPubkey, fromPubkey);
             const ataKey = expectedAta.toBase58();
             if (!createdATAs.has(ataKey)) {
@@ -1078,8 +1128,8 @@ var WarpSolanaExecutor = class {
           const mintAddress = match[1];
           const receiverAddress = match[2];
           try {
-            const mintPubkey = new PublicKey3(mintAddress);
-            const receiverPubkey = new PublicKey3(receiverAddress);
+            const mintPubkey = new PublicKey4(mintAddress);
+            const receiverPubkey = new PublicKey4(receiverAddress);
             const expectedAta = await getAssociatedTokenAddress(mintPubkey, receiverPubkey);
             const ataKey = expectedAta.toBase58();
             if (!createdATAs.has(ataKey)) {
@@ -1163,7 +1213,7 @@ var WarpSolanaExecutor = class {
         buffers.push(Buffer.from(String(arg), "utf8"));
       } else if (def.type === "publicKey" || def.type === "pubkey") {
         try {
-          const pubkey = new PublicKey3(arg);
+          const pubkey = new PublicKey4(arg);
           buffers.push(Buffer.from(pubkey.toBuffer()));
         } catch {
           buffers.push(Buffer.from(String(arg), "utf8"));
@@ -1244,7 +1294,7 @@ var WarpSolanaExecutor = class {
     if (accountInput.input.as?.startsWith("USER_ATA:") || accountInput.input.as?.startsWith("RECEIVER_ATA:")) {
       return await this.resolveAccountPubkey(`{{${accountInput.input.as}}}`, fromPubkey);
     }
-    return new PublicKey3(address);
+    return new PublicKey4(address);
   }
   interpolateAccountAddress(address, resolvedInputs) {
     if (!address.includes("{{")) return address;
@@ -1301,8 +1351,8 @@ var WarpSolanaExecutor = class {
     if (nativeTokenTransfers.length === 1 && splTokenTransfers.length === 0) {
       const transfer = nativeTokenTransfers[0];
       if (transfer.amount <= 0n) throw new Error("WarpSolanaExecutor: Native token transfer amount must be positive");
-      const fromPubkey = new PublicKey3(userWallet);
-      return this.setTransactionDefaults([SystemProgram.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(transfer.amount) })], fromPubkey);
+      const fromPubkey = new PublicKey4(userWallet);
+      return this.setTransactionDefaults([SystemProgram2.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(transfer.amount) })], fromPubkey);
     }
     if (nativeTokenTransfers.length === 0 && splTokenTransfers.length === 1) {
       return this.createSingleTokenTransfer(executable, splTokenTransfers[0], userWallet, destinationPubkey);
@@ -1311,8 +1361,8 @@ var WarpSolanaExecutor = class {
     throw new Error("WarpSolanaExecutor: Invalid transfer configuration");
   }
   async createSingleTokenTransfer(executable, transfer, userWallet, destinationPubkey) {
-    const mintAddress = new PublicKey3(transfer.identifier);
-    const fromPubkey = new PublicKey3(userWallet);
+    const mintAddress = new PublicKey4(transfer.identifier);
+    const fromPubkey = new PublicKey4(userWallet);
     const sourceTokenAccount = await getAssociatedTokenAddress(mintAddress, fromPubkey);
     const destinationTokenAccount = await getAssociatedTokenAddress(mintAddress, destinationPubkey);
     if (!await this.connection.getAccountInfo(sourceTokenAccount)) {
@@ -1330,7 +1380,7 @@ var WarpSolanaExecutor = class {
     if (action.type !== "query") throw new Error(`WarpSolanaExecutor: Invalid action type for executeQuery: ${action.type}`);
     if (!action.func) throw new Error("WarpSolanaExecutor: Query action must have a function name");
     if (!executable.destination) throw new Error("WarpSolanaExecutor: Query address is required");
-    const queryAddress = new PublicKey3(executable.destination);
+    const queryAddress = new PublicKey4(executable.destination);
     const nativeArgs = executable.args.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
     let decodedResult = [];
     let isSuccess = true;
@@ -1398,7 +1448,7 @@ var WarpSolanaExecutor = class {
   }
   toPublicKey(address, errorMsg) {
     try {
-      return new PublicKey3(address);
+      return new PublicKey4(address);
     } catch {
       throw new Error(`WarpSolanaExecutor: ${errorMsg}`);
     }
@@ -1447,7 +1497,7 @@ var WarpSolanaExecutor = class {
       if (!mintAddress || mintAddress.includes("{{")) {
         throw new Error(`Invalid USER_ATA placeholder: ${address}. Mint address must be resolved first.`);
       }
-      const mintPubkey = new PublicKey3(mintAddress);
+      const mintPubkey = new PublicKey4(mintAddress);
       return await getAssociatedTokenAddress(mintPubkey, fromPubkey);
     }
     if (address.startsWith("{{RECEIVER_ATA:") && address.endsWith("}}")) {
@@ -1461,12 +1511,12 @@ var WarpSolanaExecutor = class {
         }
         if (mintAddress.includes(":")) mintAddress = mintAddress.split(":")[1];
         if (receiverAddress.includes(":")) receiverAddress = receiverAddress.split(":")[1];
-        const mintPubkey = new PublicKey3(mintAddress);
-        const receiverPubkey = new PublicKey3(receiverAddress);
+        const mintPubkey = new PublicKey4(mintAddress);
+        const receiverPubkey = new PublicKey4(receiverAddress);
         return await getAssociatedTokenAddress(mintPubkey, receiverPubkey);
       }
     }
-    return new PublicKey3(address);
+    return new PublicKey4(address);
   }
   determineAccountFlags(accountDef, pubkey, fromPubkey) {
     const accountMeta = typeof accountDef === "object" ? accountDef : {};
@@ -1637,7 +1687,7 @@ import {
   initializeWalletCache
 } from "@joai/warps";
 import { createKeyPairSignerFromBytes } from "@solana/kit";
-import { Connection as Connection4, Transaction as Transaction3, VersionedTransaction as VersionedTransaction4 } from "@solana/web3.js";
+import { Connection as Connection5, Transaction as Transaction3, VersionedTransaction as VersionedTransaction4 } from "@solana/web3.js";
 import { registerExactSvmScheme } from "@x402/svm/exact/client";
 
 // src/providers/MnemonicWalletProvider.ts
@@ -1650,6 +1700,7 @@ import {
   getWarpWalletPrivateKeyFromConfig,
   normalizeAndValidateMnemonic,
   normalizeMnemonic,
+  removeWarpWalletFromConfig,
   setWarpWalletInConfig,
   validateMnemonicLength
 } from "@joai/warps";
@@ -1772,6 +1823,9 @@ var _MnemonicWalletProvider = class _MnemonicWalletProvider {
       mnemonic
     };
   }
+  async delete(externalId) {
+    removeWarpWalletFromConfig(this.config, this.chain.name);
+  }
   getKeypair() {
     if (this.keypair) return this.keypair;
     const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
@@ -1790,6 +1844,7 @@ import {
   getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig4,
   getWarpWalletMnemonicFromConfig as getWarpWalletMnemonicFromConfig2,
   getWarpWalletPrivateKeyFromConfig as getWarpWalletPrivateKeyFromConfig2,
+  removeWarpWalletFromConfig as removeWarpWalletFromConfig2,
   setWarpWalletInConfig as setWarpWalletInConfig2
 } from "@joai/warps";
 import bs583 from "bs58";
@@ -1897,6 +1952,9 @@ var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
       mnemonic: null
     };
   }
+  async delete(externalId) {
+    removeWarpWalletFromConfig2(this.config, this.chain.name);
+  }
   getKeypair() {
     if (this.keypair) return this.keypair;
     const privateKey = getWarpWalletPrivateKeyFromConfig2(this.config, this.chain.name);
@@ -1924,7 +1982,7 @@ _PrivateKeyWalletProvider.PROVIDER_NAME = "privateKey";
 var PrivateKeyWalletProvider = _PrivateKeyWalletProvider;
 
 // src/providers/ReadOnlyWalletProvider.ts
-import { getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig5 } from "@joai/warps";
+import { getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig5, removeWarpWalletFromConfig as removeWarpWalletFromConfig3 } from "@joai/warps";
 var ReadOnlyWalletProvider = class {
   constructor(config, chain) {
     this.config = config;
@@ -1960,6 +2018,9 @@ var ReadOnlyWalletProvider = class {
     const address = getWarpWalletAddressFromConfig5(this.config, this.chain.name);
     throw new Error(`Wallet can not be used for signing: ${address}`);
   }
+  async delete(externalId) {
+    removeWarpWalletFromConfig3(this.config, this.chain.name);
+  }
 };
 
 // src/WarpSolanaWallet.ts
@@ -1970,7 +2031,7 @@ var WarpSolanaWallet = class {
     this.cachedAddress = null;
     this.cachedPublicKey = null;
     const providerConfig = getProviderConfig4(config, chain.name, config.env, chain.defaultApiUrl);
-    this.connection = new Connection4(providerConfig.url, "confirmed");
+    this.connection = new Connection5(providerConfig.url, "confirmed");
     this.walletProvider = this.createProvider();
     this.initializeCache();
   }
@@ -2023,6 +2084,10 @@ var WarpSolanaWallet = class {
     const walletProvider = this.createProviderForOperation(provider);
     return await walletProvider.generate();
   }
+  async delete(provider, externalId) {
+    const walletProvider = this.createProviderForOperation(provider);
+    await walletProvider.delete(externalId);
+  }
   getAddress() {
     return this.cachedAddress;
   }
@@ -2071,29 +2136,51 @@ var WarpSolanaWallet = class {
     throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${provider}`);
   }
   resolveTransaction(tx) {
-    if (tx instanceof VersionedTransaction4) {
-      if (tx.version === void 0 || tx.version === "legacy") {
-        throw new Error("Transaction must be a VersionedTransaction (v0), not legacy");
-      }
-      return tx;
-    }
+    const directVersionedTransaction = this.asVersionedTransaction(tx);
+    if (directVersionedTransaction) return directVersionedTransaction;
     if (tx instanceof Transaction3) {
       throw new Error("Legacy Transaction format is not supported. All transactions must use VersionedTransaction (v0).");
     }
-    if (tx.transaction instanceof VersionedTransaction4) {
-      if (tx.transaction.version === void 0 || tx.transaction.version === "legacy") {
-        throw new Error("Transaction must be a VersionedTransaction (v0), not legacy");
-      }
-      return tx.transaction;
-    }
-    if (tx.transaction instanceof Transaction3) {
+    const nestedTransaction = tx.transaction;
+    const nestedVersionedTransaction = this.asVersionedTransaction(nestedTransaction);
+    if (nestedVersionedTransaction) return nestedVersionedTransaction;
+    if (nestedTransaction instanceof Transaction3) {
       throw new Error("Legacy Transaction format is not supported. All transactions must use VersionedTransaction (v0).");
     }
-    if (!tx.transaction) {
+    const serializedTransaction = this.toSerializedTransactionBytes(nestedTransaction);
+    if (serializedTransaction) {
+      try {
+        return this.asVersionedTransactionOrThrow(VersionedTransaction4.deserialize(serializedTransaction));
+      } catch {
+        throw new Error("Invalid serialized transaction format. Expected a VersionedTransaction payload.");
+      }
+    }
+    if (!nestedTransaction) {
       throw new Error("Transaction must be signed before sending");
     }
     throw new Error("Invalid transaction format - only VersionedTransaction is supported");
   }
+  asVersionedTransaction(tx) {
+    if (!(tx instanceof VersionedTransaction4)) return null;
+    return this.asVersionedTransactionOrThrow(tx);
+  }
+  asVersionedTransactionOrThrow(tx) {
+    if (tx.version === void 0 || tx.version === "legacy") {
+      throw new Error("Transaction must be a VersionedTransaction (v0), not legacy");
+    }
+    return tx;
+  }
+  toSerializedTransactionBytes(value) {
+    if (value instanceof Uint8Array) return value;
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) return new Uint8Array(value);
+    if (Array.isArray(value) && value.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+      return Uint8Array.from(value);
+    }
+    if (typeof value === "string" && value.trim() !== "") {
+      return Uint8Array.from(Buffer.from(value.trim(), "base64"));
+    }
+    return null;
+  }
   async shouldSkipPreflight(transaction) {
     if (!transaction.signatures || transaction.signatures.length === 0 || !transaction.signatures.some((sig) => sig.some((b) => b !== 0))) {
       return false;