{"version":3,"sources":["../src/core/debug.ts","../src/core/base64-bytes-to.ts","../src/core/base64-from-transaction.ts","../src/core/base64-to-transaction.ts","../src/core/const.ts","../src/core/create-codama-config.ts","../src/core/rpc.ts","../src/core/explorer.ts","../src/core/send-and-confirm-transaction-with-signers.ts","../src/core/simulate-transaction.ts","../src/core/create-solana-client.ts","../src/core/create-transaction.ts","../src/core/get-oldest-signature.ts","../src/core/get-signature-from-bytes.ts","../src/core/insert-reference-key.ts","../src/core/keypairs-base58.ts","../src/core/keypairs-extractable.ts","../src/programs/compute-budget/utils.ts","../src/core/prepare-transaction.ts","../src/core/rent.ts","../src/core/utils.ts","../src/core/verify-signature.ts"],"names":["getBase64Encoder","getBase64EncodedWireTransaction","partiallySignTransactionMessageWithSigners","err","pipe","setTransactionMessageLifetimeUsingBlockhash","getBase58Decoder","SolanaError","createSignerFromKeyPair","COMPUTE_BUDGET_PROGRAM_ADDRESS","getSetComputeUnitLimitInstruction","appendTransactionMessageInstruction","assertIsTransactionMessageWithBlockhashLifetime","isTransactionSigner","getBase58Encoder"],"mappings":"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","file":"index.browser.mjs","sourcesContent":["/**\n *\n */\n\ntype LogLevel = \"debug\" | \"info\" | \"warn\" | \"error\";\n\nconst GILL_LOG_LEVELS: Record<LogLevel, number> = {\n  debug: 0,\n  info: 1,\n  warn: 2,\n  error: 3,\n};\n\ndeclare global {\n  /**\n   * Whether or not to enable debug mode. When enabled, default log level of `info`\n   */\n  var __GILL_DEBUG__: boolean | undefined;\n  /**\n   * Set the a desired level of logs to be output in the application\n   *\n   * - Default: `info`\n   * - Options: `debug` | `info` | `warn` | `error`\n   */\n  var __GILL_DEBUG_LEVEL__: LogLevel | undefined;\n}\n\nconst getMinLogLevel = (): LogLevel =>\n  (process.env.GILL_DEBUG_LEVEL as LogLevel) ||\n  global.__GILL_DEBUG_LEVEL__ ||\n  (typeof window !== \"undefined\" && (window as any).__GILL_DEBUG_LEVEL__) ||\n  \"info\";\n\n/**\n * Check if the `gill` debug logger is enabled or not\n */\nexport const isDebugEnabled = (): boolean =>\n  Boolean(\n    process.env.GILL_DEBUG_LEVEL ||\n      global.__GILL_DEBUG_LEVEL__ ||\n      process.env.GILL_DEBUG === \"true\" ||\n      process.env.GILL_DEBUG === \"1\" ||\n      global.__GILL_DEBUG__ === true ||\n      (typeof window !== \"undefined\" && (window as any).__GILL_DEBUG__ === true),\n  );\n\n/**\n * Log debug messages based on the desired application's logging level.\n *\n * @param message - the message contents to be logged\n * @param level - default: `info` (see: {@link GILL_LOG_LEVELS})\n * @param prefix - default: `[GILL]`\n *\n * To enable gill's debug logger, set any of the following to `true`:\n * - `process.env.GILL_DEBUG`\n * - `global.__GILL_DEBUG__`\n * - `window.__GILL_DEBUG__`\n *\n * To set a desired level of logs to be output in the application, set the value of one of the following:\n * - `process.env.GILL_DEBUG_LEVEL`\n * - `global.__GILL_DEBUG_LEVEL__`\n * - `window.__GILL_DEBUG_LEVEL__`\n */\nexport function debug(message: unknown, level: LogLevel = \"info\", prefix: string = \"[GILL]\") {\n  if (!isDebugEnabled()) return;\n\n  if (GILL_LOG_LEVELS[level] < GILL_LOG_LEVELS[getMinLogLevel()]) return;\n\n  const formattedMessage = typeof message === \"string\" ? message : JSON.stringify(message, null, 2);\n\n  switch (level) {\n    case \"debug\":\n      console.log(prefix, formattedMessage);\n      break;\n    case \"info\":\n      console.info(prefix, formattedMessage);\n      break;\n    case \"warn\":\n      console.warn(prefix, formattedMessage);\n      break;\n    case \"error\":\n      console.error(prefix, formattedMessage);\n      break;\n  }\n}\n","import type { Address, Signature } from \"@solana/kit\";\nimport { assertIsAddress, assertIsSignature, getBase58Decoder, getBase64Encoder } from \"@solana/kit\";\n\n/**\n * Takes a base64 encoded string of a byte array, parses, then asserts it as an {@link Address}\n */\nexport function base64BytesToAddress(base64Bytes: string): Address {\n  const maybeAddress = getBase58Decoder().decode(getBase64Encoder().encode(base64Bytes));\n  assertIsAddress(maybeAddress);\n  return maybeAddress;\n}\n\n/**\n * Takes a base64 encoded string of a byte array, parses, then asserts it as an {@link Signature}\n */\nexport function base64BytesToSignature(base64Bytes: string): Signature {\n  const maybeSignature = getBase58Decoder().decode(getBase64Encoder().encode(base64Bytes));\n  assertIsSignature(maybeSignature);\n  return maybeSignature;\n}\n\n/**\n * Takes a base64 encoded string of a byte array, parses, then returns as a utf8 string\n */\nexport function base64BytesToString(base64Bytes: string): string {\n  return new TextDecoder().decode(getBase64Encoder().encode(base64Bytes));\n}\n","import { getBase64Encoder, getTransactionDecoder, type Transaction } from \"@solana/kit\";\nimport type { transactionToBase64, transactionToBase64WithSigners } from \"./base64-to-transaction\";\n\n/**\n * Convert a base64 encoded transaction string into compiled transaction\n *\n * Use {@link transactionToBase64} or {@link transactionToBase64WithSigners} to create the base64 encoded transaction string\n */\nexport function transactionFromBase64(base64EncodedTransaction: string): Transaction {\n  return getTransactionDecoder().decode(getBase64Encoder().encode(base64EncodedTransaction));\n}\n","import type {\n  Base64EncodedWireTransaction,\n  TransactionMessage,\n  TransactionMessageWithFeePayer,\n  Transaction,\n} from \"@solana/kit\";\nimport {\n  compileTransaction,\n  getBase64EncodedWireTransaction,\n  partiallySignTransactionMessageWithSigners,\n  pipe,\n} from \"@solana/kit\";\n\n/**\n * Compile a transaction to a base64 string\n *\n * Note: This will NOT attempt to sign the transaction,\n * so it will be missing `signatures` from any of the attached Signers\n *\n * Use {@link transactionToBase64WithSignatures} sign and base64 encode\n */\nexport function transactionToBase64(\n  tx: (TransactionMessage & TransactionMessageWithFeePayer) | Transaction,\n): Base64EncodedWireTransaction {\n  if (\"messageBytes\" in tx) return pipe(tx, getBase64EncodedWireTransaction);\n  else return pipe(tx, compileTransaction, getBase64EncodedWireTransaction);\n}\n\n/**\n * Compile a transaction to a base64 string and sign it with all attached Signers\n *\n * See also {@link partiallySignTransactionMessageWithSigners}\n */\nexport async function transactionToBase64WithSigners(\n  tx: (TransactionMessage & TransactionMessageWithFeePayer) | Transaction,\n): Promise<Base64EncodedWireTransaction> {\n  if (\"messageBytes\" in tx) return transactionToBase64(tx);\n  else return transactionToBase64(await partiallySignTransactionMessageWithSigners(tx));\n}\n","/** 1 billion lamports per SOL */\nexport const LAMPORTS_PER_SOL = 1_000_000_000;\n\n/**\n * Genesis hash for Solana network clusters\n */\nexport const GENESIS_HASH = {\n  mainnet: \"5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d\",\n  devnet: \"EtWTRABZaYq6iMfeYKouRu166VU2xqa1wcaWoxPkrZBG\",\n  testnet: \"4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY\",\n};\n","/**\n * Codama dependency map to utilize gill imports\n */\nexport const GILL_EXTERNAL_MODULE_MAP: Record<string, string> = {\n  solanaAccounts: \"gill\",\n  solanaAddresses: \"gill\",\n  solanaCodecsCore: \"gill\",\n  solanaCodecsDataStructures: \"gill\",\n  solanaCodecsNumbers: \"gill\",\n  solanaCodecsStrings: \"gill\",\n  solanaErrors: \"gill\",\n  solanaInstructions: \"gill\",\n  solanaOptions: \"gill\",\n  solanaPrograms: \"gill\",\n  solanaRpcTypes: \"gill\",\n  solanaSigners: \"gill\",\n};\n\n/**\n * Create a Codama CLI configuration to generate a program client from an IDL.\n * Normally saved to `codama.js`.\n *\n * @example\n * ```ts\n * import { createCodamaConfig } from \"gill\";\n *\n * export default createCodamaConfig({\n *  idl: \"program/idl.json\",\n *  clientJs: \"clients/js/src/generated\",\n *  // clientRust: \"clients/rust/src/generated\",\n * });\n * ```\n */\nexport function createCodamaConfig({\n  idl,\n  clientJs,\n  clientRust,\n  dependencyMap = GILL_EXTERNAL_MODULE_MAP,\n}: {\n  idl: string;\n  clientJs: string;\n  clientRust?: string;\n  dependencyMap?: Record<string, string>;\n}) {\n  return {\n    idl,\n    scripts: {\n      js: {\n        args: [clientJs, { dependencyMap }],\n        from: \"@codama/renderers-js\",\n      },\n      ...(clientRust && {\n        rust: {\n          from: \"@codama/renderers-rust\",\n          args: [\n            clientRust,\n            {\n              crateFolder: \"clients/rust\",\n              formatCode: true,\n            },\n          ],\n        },\n      }),\n    },\n  };\n}\n","import type { DevnetUrl, MainnetUrl, TestnetUrl } from \"@solana/kit\";\nimport type { LocalnetUrl, ModifiedClusterUrl, SolanaClusterMoniker } from \"../types/rpc\";\n\nexport function localnet(putativeString: string): LocalnetUrl {\n  return putativeString as LocalnetUrl;\n}\n\n/**\n * Get a public Solana RPC endpoint for a cluster based on its moniker\n *\n * Note: These RPC URLs are rate limited and not suitable for production applications.\n */\nexport function getPublicSolanaRpcUrl(\n  cluster: SolanaClusterMoniker | \"mainnet-beta\" | \"localhost\",\n): ModifiedClusterUrl {\n  switch (cluster) {\n    case \"devnet\":\n      return \"https://api.devnet.solana.com\" as DevnetUrl;\n    case \"testnet\":\n      return \"https://api.testnet.solana.com\" as TestnetUrl;\n    case \"mainnet-beta\":\n    case \"mainnet\":\n      return \"https://api.mainnet-beta.solana.com\" as MainnetUrl;\n    case \"localnet\":\n    case \"localhost\":\n      return \"http://127.0.0.1:8899\" as LocalnetUrl;\n    default:\n      throw new Error(\"Invalid cluster moniker\");\n  }\n}\n","import type { GetExplorerLinkArgs } from \"../types\";\n\n/**\n * Craft a Solana Explorer link on any cluster\n */\nexport function getExplorerLink(props: GetExplorerLinkArgs = {}): string {\n  let url = new URL(\"https://explorer.solana.com\");\n\n  // default to mainnet / mainnet-beta\n  if (!props.cluster || props.cluster == \"mainnet\") props.cluster = \"mainnet-beta\";\n\n  if (\"address\" in props) {\n    url.pathname = `/address/${props.address}`;\n  } else if (\"transaction\" in props) {\n    url.pathname = `/tx/${props.transaction}`;\n  } else if (\"block\" in props) {\n    url.pathname = `/block/${props.block}`;\n  }\n\n  if (props.cluster !== \"mainnet-beta\") {\n    if (props.cluster === \"localnet\" || props.cluster === \"localhost\") {\n      // localnet technically isn't a cluster, so requires special handling\n      url.searchParams.set(\"cluster\", \"custom\");\n      url.searchParams.set(\"customUrl\", \"http://localhost:8899\");\n    } else {\n      url.searchParams.set(\"cluster\", props.cluster);\n    }\n  }\n\n  return url.toString();\n}\n","import type {\n  BaseTransactionMessage,\n  FullySignedTransaction,\n  GetEpochInfoApi,\n  GetLatestBlockhashApi,\n  GetSignatureStatusesApi,\n  Rpc,\n  RpcSubscriptions,\n  SendTransactionApi,\n  Signature,\n  SignatureNotificationsApi,\n  SlotNotificationsApi,\n  Transaction,\n  TransactionMessage,\n  TransactionMessageWithFeePayer,\n  TransactionWithLifetime,\n} from \"@solana/kit\";\nimport {\n  assertIsFullySignedTransaction,\n  assertIsSendableTransaction,\n  assertIsTransactionMessageWithBlockhashLifetime,\n  assertIsTransactionWithBlockhashLifetime,\n  assertIsTransactionWithinSizeLimit,\n  Commitment,\n  getBase64EncodedWireTransaction,\n  getSignatureFromTransaction,\n  sendAndConfirmTransactionFactory,\n  setTransactionMessageLifetimeUsingBlockhash,\n  signTransactionMessageWithSigners,\n} from \"@solana/kit\";\nimport { type waitForRecentTransactionConfirmation } from \"@solana/transaction-confirmation\";\nimport { debug } from \"./debug\";\nimport { getExplorerLink } from \"./explorer\";\n\ninterface SendAndConfirmTransactionWithBlockhashLifetimeConfig extends SendTransactionConfigWithoutEncoding {\n  confirmRecentTransaction: (\n    config: Omit<\n      Parameters<typeof waitForRecentTransactionConfirmation>[0],\n      \"getBlockHeightExceedencePromise\" | \"getRecentSignatureConfirmationPromise\"\n    >,\n  ) => Promise<void>;\n  abortSignal?: AbortSignal;\n  commitment: Commitment;\n}\n\ntype SendTransactionConfigWithoutEncoding = Omit<\n  NonNullable<Parameters<SendTransactionApi[\"sendTransaction\"]>[1]>,\n  \"encoding\"\n>;\n\ntype SendableTransaction =\n  | (TransactionMessage & TransactionMessageWithFeePayer)\n  | (FullySignedTransaction & TransactionWithLifetime)\n  | (BaseTransactionMessage & TransactionMessageWithFeePayer);\n\nexport type SendAndConfirmTransactionWithSignersFunction = (\n  transaction: SendableTransaction,\n  config?: Omit<\n    SendAndConfirmTransactionWithBlockhashLifetimeConfig,\n    \"confirmRecentTransaction\" | \"rpc\" | \"transaction\"\n  >,\n) => Promise<Signature>;\n\ntype SendAndConfirmTransactionWithSignersFactoryConfig<TCluster> = {\n  rpc: Rpc<GetEpochInfoApi & GetSignatureStatusesApi & SendTransactionApi & GetLatestBlockhashApi> & {\n    \"~cluster\"?: TCluster;\n  };\n  rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi> & {\n    \"~cluster\"?: TCluster;\n  };\n};\n\nexport function sendAndConfirmTransactionWithSignersFactory({\n  rpc,\n  rpcSubscriptions,\n}: SendAndConfirmTransactionWithSignersFactoryConfig<\"devnet\">): SendAndConfirmTransactionWithSignersFunction;\nexport function sendAndConfirmTransactionWithSignersFactory({\n  rpc,\n  rpcSubscriptions,\n}: SendAndConfirmTransactionWithSignersFactoryConfig<\"testnet\">): SendAndConfirmTransactionWithSignersFunction;\nexport function sendAndConfirmTransactionWithSignersFactory({\n  rpc,\n  rpcSubscriptions,\n}: SendAndConfirmTransactionWithSignersFactoryConfig<\"mainnet\">): SendAndConfirmTransactionWithSignersFunction;\nexport function sendAndConfirmTransactionWithSignersFactory({\n  rpc,\n  rpcSubscriptions,\n}: SendAndConfirmTransactionWithSignersFactoryConfig<\"localnet\">): SendAndConfirmTransactionWithSignersFunction;\nexport function sendAndConfirmTransactionWithSignersFactory<\n  TCluster extends \"devnet\" | \"mainnet\" | \"testnet\" | \"localnet\" | undefined = undefined,\n>({\n  rpc,\n  rpcSubscriptions,\n}: SendAndConfirmTransactionWithSignersFactoryConfig<TCluster>): SendAndConfirmTransactionWithSignersFunction {\n  // @ts-ignore - TODO(FIXME)\n  const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });\n  return async function sendAndConfirmTransactionWithSigners(transaction, config = { commitment: \"confirmed\" }) {\n    let signedTransaction: (Transaction & FullySignedTransaction) | undefined;\n\n    if (\"messageBytes\" in transaction === false) {\n      if (\"lifetimeConstraint\" in transaction === false) {\n        const { value: latestBlockhash } = await rpc.getLatestBlockhash().send({ abortSignal: config.abortSignal });\n        transaction = setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, transaction);\n        assertIsTransactionMessageWithBlockhashLifetime(transaction);\n      }\n\n      // Ensure the transaction has fee payer\n      if (\"feePayer\" in transaction === false) {\n        throw new Error(\"Transaction must have a fee payer\");\n      }\n\n      // Sign the transaction and ensure it has all required properties\n      signedTransaction = await signTransactionMessageWithSigners(transaction);\n    }\n\n    // If the signing branch didn't run above, `signedTx` will be undefined.\n    // Use an explicit undefined check (instead of a truthy check) to avoid\n    // accidental falsy value edge-cases and then assign the provided\n    // `transaction` as a fully-signed transaction.\n    if (!signedTransaction) {\n      // Cast via unknown to acknowledge the developer intent: if the\n      // caller passed a fully-signed transaction, treat it as such.\n      signedTransaction = transaction as unknown as Transaction & FullySignedTransaction;\n    }\n\n    assertIsTransactionWithBlockhashLifetime(signedTransaction);\n    assertIsTransactionWithinSizeLimit(signedTransaction);\n    assertIsFullySignedTransaction(signedTransaction);\n    assertIsSendableTransaction(signedTransaction);\n\n    debug(`Sending transaction: ${getExplorerLink({ transaction: getSignatureFromTransaction(signedTransaction) })}`);\n    debug(`Transaction as base64: ${getBase64EncodedWireTransaction(signedTransaction)}`, \"debug\");\n\n    await sendAndConfirmTransaction(signedTransaction, config);\n    return getSignatureFromTransaction(signedTransaction);\n  };\n}\n","import type {\n  TransactionMessage,\n  TransactionMessageWithFeePayer,\n  Rpc,\n  SimulateTransactionApi,\n  Transaction,\n} from \"@solana/kit\";\nimport { getBase64EncodedWireTransaction, partiallySignTransactionMessageWithSigners } from \"@solana/kit\";\nimport type { Simplify } from \"./../types/index\";\n\nexport type SimulateTransactionFunction = (\n  transaction: Transaction | (TransactionMessage & TransactionMessageWithFeePayer),\n  config?: Simplify<Omit<Parameters<SimulateTransactionApi[\"simulateTransaction\"]>[1], \"encoding\" | \"sigVerify\">>,\n) => Promise<ReturnType<SimulateTransactionApi[\"simulateTransaction\"]>>;\n\ntype SimulateTransactionFactoryConfig<TCluster> = {\n  rpc: Rpc<SimulateTransactionApi> & {\n    \"~cluster\"?: TCluster;\n  };\n};\n\nexport function simulateTransactionFactory({\n  rpc,\n}: SimulateTransactionFactoryConfig<\"devnet\">): SimulateTransactionFunction;\nexport function simulateTransactionFactory({\n  rpc,\n}: SimulateTransactionFactoryConfig<\"testnet\">): SimulateTransactionFunction;\nexport function simulateTransactionFactory({\n  rpc,\n}: SimulateTransactionFactoryConfig<\"mainnet\">): SimulateTransactionFunction;\nexport function simulateTransactionFactory({\n  rpc,\n}: SimulateTransactionFactoryConfig<\"localnet\">): SimulateTransactionFunction;\nexport function simulateTransactionFactory<\n  TCluster extends \"devnet\" | \"mainnet\" | \"testnet\" | \"localnet\" | void = void,\n>({ rpc }: SimulateTransactionFactoryConfig<TCluster>): SimulateTransactionFunction {\n  return async function simulateTransaction(transaction, config) {\n    if (\"messageBytes\" in transaction == false) {\n      transaction = await partiallySignTransactionMessageWithSigners(transaction);\n    }\n\n    return rpc\n      .simulateTransaction(getBase64EncodedWireTransaction(transaction), {\n        replaceRecentBlockhash: true,\n        // innerInstructions: true,\n        ...config,\n        sigVerify: false,\n        encoding: \"base64\",\n      })\n      .send();\n  };\n}\n","import type { DevnetUrl, MainnetUrl, TestnetUrl } from \"@solana/kit\";\nimport { createSolanaRpc, createSolanaRpcSubscriptions } from \"@solana/kit\";\n\nimport type { CreateSolanaClientArgs, LocalnetUrl, ModifiedClusterUrl, SolanaClient } from \"../types/rpc\";\nimport { getPublicSolanaRpcUrl } from \"./rpc\";\nimport { sendAndConfirmTransactionWithSignersFactory } from \"./send-and-confirm-transaction-with-signers\";\nimport { simulateTransactionFactory } from \"./simulate-transaction\";\n\n/**\n * Create a Solana `rpc` and `rpcSubscriptions` client\n */\nexport function createSolanaClient(\n  props: Omit<CreateSolanaClientArgs<MainnetUrl | \"mainnet\">, \"urlOrMoniker\"> & {\n    urlOrMoniker: \"mainnet\";\n  },\n): SolanaClient<MainnetUrl>;\nexport function createSolanaClient(\n  props: Omit<CreateSolanaClientArgs<DevnetUrl | \"devnet\">, \"urlOrMoniker\"> & {\n    urlOrMoniker: \"devnet\";\n  },\n): SolanaClient<DevnetUrl>;\nexport function createSolanaClient(\n  props: Omit<CreateSolanaClientArgs<TestnetUrl | \"testnet\">, \"urlOrMoniker\"> & {\n    urlOrMoniker: \"testnet\";\n  },\n): SolanaClient<TestnetUrl>;\nexport function createSolanaClient(\n  props: Omit<CreateSolanaClientArgs<LocalnetUrl | \"localnet\">, \"urlOrMoniker\"> & {\n    urlOrMoniker: \"localnet\";\n  },\n): SolanaClient<LocalnetUrl>;\nexport function createSolanaClient<TClusterUrl extends ModifiedClusterUrl>(\n  props: CreateSolanaClientArgs<TClusterUrl>,\n): SolanaClient<TClusterUrl>;\nexport function createSolanaClient<TCluster extends ModifiedClusterUrl>({\n  urlOrMoniker,\n  rpcConfig,\n  rpcSubscriptionsConfig,\n}: CreateSolanaClientArgs<TCluster>) {\n  if (!urlOrMoniker) throw new Error(\"Cluster url or moniker is required\");\n  if (urlOrMoniker instanceof URL == false) {\n    try {\n      urlOrMoniker = new URL(urlOrMoniker.toString());\n    } catch (err) {\n      try {\n        urlOrMoniker = new URL(getPublicSolanaRpcUrl(urlOrMoniker.toString() as any));\n      } catch (err) {\n        throw new Error(\"Invalid URL or cluster moniker\");\n      }\n    }\n  }\n\n  if (!urlOrMoniker.protocol.match(/^https?/i)) {\n    throw new Error(\"Unsupported protocol. Only HTTP and HTTPS are supported\");\n  }\n\n  if (rpcConfig?.port) {\n    urlOrMoniker.port = rpcConfig.port.toString();\n  }\n\n  const rpc = createSolanaRpc<TCluster>(urlOrMoniker.toString() as TCluster, rpcConfig);\n\n  urlOrMoniker.protocol = urlOrMoniker.protocol.replace(\"http\", \"ws\");\n\n  if (rpcSubscriptionsConfig?.port) {\n    urlOrMoniker.port = rpcSubscriptionsConfig.port.toString();\n  } else if (urlOrMoniker.hostname == \"localhost\" || urlOrMoniker.hostname.startsWith(\"127\")) {\n    urlOrMoniker.port = \"8900\";\n  }\n\n  const rpcSubscriptions = createSolanaRpcSubscriptions<TCluster>(\n    urlOrMoniker.toString() as TCluster,\n    rpcSubscriptionsConfig,\n  );\n\n  return {\n    rpc,\n    rpcSubscriptions,\n    sendAndConfirmTransaction: sendAndConfirmTransactionWithSignersFactory({\n      // @ts-ignore - TODO(FIXME:nick)\n      rpc,\n      // @ts-ignore - TODO(FIXME:nick)\n      rpcSubscriptions,\n    }),\n    // @ts-ignore\n    simulateTransaction: simulateTransactionFactory({ rpc }),\n    urlOrMoniker: urlOrMoniker.toString() as TCluster,\n  };\n}\n","import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction } from \"@solana-program/compute-budget\";\nimport type {\n  Address,\n  TransactionMessageWithBlockhashLifetime,\n  TransactionMessageWithFeePayer,\n  TransactionMessageWithFeePayerSigner,\n  TransactionSigner,\n  TransactionVersion,\n} from \"@solana/kit\";\nimport {\n  appendTransactionMessageInstruction,\n  appendTransactionMessageInstructions,\n  createTransactionMessage,\n  isTransactionSigner,\n  pipe,\n  setTransactionMessageFeePayer,\n  setTransactionMessageFeePayerSigner,\n  setTransactionMessageLifetimeUsingBlockhash,\n} from \"@solana/kit\";\nimport type { Simplify } from \"../types\";\nimport type { CreateTransactionInput, FullTransaction } from \"../types/transactions\";\n\n/**\n * Simple interface for creating a Solana transaction\n */\nexport function createTransaction<TVersion extends TransactionVersion | \"auto\", TFeePayer extends TransactionSigner>(\n  props: CreateTransactionInput<TVersion, TFeePayer>,\n): FullTransaction<TVersion extends \"auto\" ? TransactionVersion : TVersion, TransactionMessageWithFeePayerSigner>;\nexport function createTransaction<TVersion extends TransactionVersion | \"auto\", TFeePayer extends Address>(\n  props: CreateTransactionInput<TVersion, TFeePayer>,\n): FullTransaction<TVersion extends \"auto\" ? TransactionVersion : TVersion, TransactionMessageWithFeePayer>;\nexport function createTransaction<\n  TVersion extends TransactionVersion | \"auto\",\n  TFeePayer extends TransactionSigner,\n  TLifetimeConstraint extends TransactionMessageWithBlockhashLifetime[\"lifetimeConstraint\"],\n>(\n  props: CreateTransactionInput<TVersion, TFeePayer, TLifetimeConstraint>,\n): Simplify<\n  FullTransaction<\n    TVersion extends \"auto\" ? TransactionVersion : TVersion,\n    TransactionMessageWithFeePayerSigner,\n    TransactionMessageWithBlockhashLifetime\n  >\n>;\nexport function createTransaction<\n  TVersion extends TransactionVersion | \"auto\",\n  TFeePayer extends Address,\n  TLifetimeConstraint extends TransactionMessageWithBlockhashLifetime[\"lifetimeConstraint\"],\n>(\n  props: CreateTransactionInput<TVersion, TFeePayer, TLifetimeConstraint>,\n): Simplify<\n  FullTransaction<\n    TVersion extends \"auto\" ? TransactionVersion : TVersion,\n    TransactionMessageWithFeePayer,\n    TransactionMessageWithBlockhashLifetime\n  >\n>;\nexport function createTransaction<\n  TVersion extends TransactionVersion | \"auto\",\n  TFeePayer extends Address | TransactionSigner,\n  TLifetimeConstraint extends TransactionMessageWithBlockhashLifetime[\"lifetimeConstraint\"],\n>(\n  props: CreateTransactionInput<TVersion, TFeePayer, TLifetimeConstraint>,\n): Simplify<\n  FullTransaction<\n    TVersion extends \"auto\" ? TransactionVersion : TVersion,\n    TransactionMessageWithFeePayer,\n    TransactionMessageWithBlockhashLifetime\n  >\n>;\nexport function createTransaction<\n  TVersion extends TransactionVersion | \"auto\",\n  TFeePayer extends Address | TransactionSigner,\n>({\n  version,\n  feePayer,\n  instructions,\n  latestBlockhash,\n  computeUnitLimit,\n  computeUnitPrice,\n}: CreateTransactionInput<TVersion, TFeePayer>): FullTransaction<\n  TVersion extends \"auto\" ? TransactionVersion : TVersion,\n  TransactionMessageWithFeePayer | TransactionMessageWithFeePayerSigner\n> {\n  return pipe(\n    // Auto-select version: if any provided instruction appears to use an Address Lookup Table (ALT),\n    // choose `0`. Otherwise default to `legacy`. If the caller explicitly provides `version`, use it.\n    (() => {\n      let selectedVersion: TransactionVersion;\n\n      if (version === undefined || version === \"auto\") {\n        selectedVersion = instructions.some(\n          (ix) =>\n            (\"addressTableLookup\" in ix && ix.addressTableLookup != null) ||\n            (\"addressTableLookups\" in ix && Array.isArray(ix.addressTableLookups) && ix.addressTableLookups.length > 0),\n        )\n          ? 0\n          : \"legacy\";\n      } else {\n        selectedVersion = version;\n      }\n\n      return createTransactionMessage({ version: selectedVersion });\n    })(),\n    (tx) => {\n      const withLifetime = latestBlockhash ? setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx) : tx;\n      if (typeof feePayer !== \"string\" && \"address\" in feePayer && isTransactionSigner(feePayer)) {\n        return setTransactionMessageFeePayerSigner(feePayer, withLifetime);\n      } else return setTransactionMessageFeePayer(feePayer, withLifetime);\n    },\n    (tx) => {\n      const withComputeLimit =\n        typeof computeUnitLimit !== \"undefined\"\n          ? appendTransactionMessageInstruction(\n              getSetComputeUnitLimitInstruction({ units: Number(computeUnitLimit) }),\n              tx,\n            )\n          : tx;\n\n      const withComputePrice =\n        typeof computeUnitPrice !== \"undefined\"\n          ? appendTransactionMessageInstruction(\n              getSetComputeUnitPriceInstruction({ microLamports: Number(computeUnitPrice) }),\n              withComputeLimit,\n            )\n          : withComputeLimit;\n\n      return appendTransactionMessageInstructions(instructions, withComputePrice);\n    },\n  ) as FullTransaction<\n    TVersion extends \"auto\" ? TransactionVersion : TVersion,\n    TransactionMessageWithFeePayer | TransactionMessageWithFeePayerSigner\n  >;\n}\n","import type { Simplify } from \"../types/index\";\n\nimport type { Address, GetSignaturesForAddressApi, Rpc } from \"@solana/kit\";\nimport { isSolanaError, SOLANA_ERROR__TRANSACTION_ERROR__UNKNOWN, SolanaError } from \"@solana/kit\";\n\ntype GetOldestSignatureForAddressRpc<TCluster> = Rpc<GetSignaturesForAddressApi> & {\n  \"~cluster\"?: TCluster;\n};\n\ntype GetOldestSignatureForAddressConfig = Simplify<\n  Parameters<GetSignaturesForAddressApi[\"getSignaturesForAddress\"]>[1]\n> & { abortSignal?: AbortSignal };\n\n/**\n * Get the oldest signature for the provided `address`\n */\nexport async function getOldestSignatureForAddress<TCluster>(\n  rpc: GetOldestSignatureForAddressRpc<TCluster>,\n  address: Address,\n  config?: GetOldestSignatureForAddressConfig,\n): Promise<ReturnType<GetSignaturesForAddressApi[\"getSignaturesForAddress\"]>[0]> {\n  const signatures = await rpc.getSignaturesForAddress(address, config).send({ abortSignal: config?.abortSignal });\n\n  if (!signatures.length) {\n    throw new SolanaError(SOLANA_ERROR__TRANSACTION_ERROR__UNKNOWN, {\n      errorName: \"OldestSignatureNotFound\",\n    });\n  }\n\n  const oldest = signatures[signatures.length - 1];\n  if (signatures.length < (config?.limit || 1000)) return oldest;\n\n  try {\n    // if signatures are found to the limit, recurse for find the oldest\n    return await getOldestSignatureForAddress(rpc, address, { ...config, before: oldest.signature });\n  } catch (err) {\n    // if signatures found were exactly at the limit, there will be no more to find, so we return the oldest\n    if (isSolanaError(err, SOLANA_ERROR__TRANSACTION_ERROR__UNKNOWN)) return oldest;\n    throw err;\n  }\n}\n","import type { Signature, SignatureBytes } from \"@solana/kit\";\nimport { getBase58Decoder } from \"@solana/kit\";\n\n/**\n * Converts signature bytes to a {@link Signature} string.\n * @param sigBytes - The signature bytes to convert\n * @returns The base58-encoded signature string\n */\nexport function getSignatureFromBytes(sigBytes: SignatureBytes): Signature {\n  return getBase58Decoder().decode(sigBytes) as Signature;\n}\n","import type { Address, BaseTransactionMessage } from \"@solana/kit\";\nimport { AccountRole, SOLANA_ERROR__INSTRUCTION_ERROR__GENERIC_ERROR, SolanaError } from \"@solana/kit\";\nimport type { getOldestSignatureForAddress } from \"./get-oldest-signature\";\n\n/**\n * Insert a single of reference key {@link Address} into a transaction message\n *\n * Use {@link getOldestSignatureForAddress} to locate the oldest signature for a reference key's address\n *\n * Note: The `transaction` must have at least one non-memo instruction.\n */\nexport function insertReferenceKeyToTransactionMessage<TTransaction extends BaseTransactionMessage>(\n  reference: Address,\n  transaction: TTransaction,\n): TTransaction {\n  return insertReferenceKeysToTransactionMessage([reference], transaction);\n}\n\n/**\n * Insert multiple reference key {@link Address | Addresses} into a transaction message\n *\n * Use {@link getOldestSignatureForAddress} to locate the oldest signature for a reference key's address\n *\n * Note: The `transaction` must have at least one non-memo instruction.\n */\nexport function insertReferenceKeysToTransactionMessage<TTransaction extends BaseTransactionMessage>(\n  references: Address[],\n  transaction: TTransaction,\n): TTransaction {\n  const nonMemoIndex = transaction.instructions.findIndex(\n    (ix) => ix.programAddress !== \"MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr\",\n  );\n\n  if (transaction.instructions.length == 0 || nonMemoIndex == -1) {\n    throw new SolanaError(SOLANA_ERROR__INSTRUCTION_ERROR__GENERIC_ERROR, {\n      index: transaction.instructions.length || nonMemoIndex,\n      cause: \"At least one non-memo instruction is required\",\n    });\n  }\n\n  const modifiedIx = {\n    ...transaction.instructions[nonMemoIndex],\n    accounts: [\n      ...(transaction.instructions[nonMemoIndex].accounts || []),\n      // actually insert the reference keys\n      ...references.map((ref) => ({\n        address: ref,\n        role: AccountRole.READONLY,\n      })),\n    ],\n  };\n\n  const instructions = [...transaction.instructions];\n  instructions.splice(nonMemoIndex, 1, modifiedIx);\n\n  return Object.freeze({\n    ...transaction,\n    instructions: Object.freeze(instructions),\n  });\n}\n","import { createKeyPairFromBytes, createSignerFromKeyPair, getBase58Encoder, type KeyPairSigner } from \"@solana/kit\";\n\n/**\n * Create a `CryptoKeyPair` from as base58 encoded secret key\n */\nexport async function createKeypairFromBase58(punitiveSecretKey: string): Promise<CryptoKeyPair> {\n  return createKeyPairFromBytes(getBase58Encoder().encode(punitiveSecretKey));\n}\n\n/**\n * Create a `KeyPairSigner` from as base58 encoded secret key\n */\nexport async function createKeypairSignerFromBase58(punitiveSecretKey: string): Promise<KeyPairSigner> {\n  return createSignerFromKeyPair(await createKeypairFromBase58(punitiveSecretKey));\n}\n","import { assertKeyExporterIsAvailable, assertKeyGenerationIsAvailable } from \"@solana/assertions\";\nimport type { KeyPairSigner, createKeyPairFromBytes, createKeyPairSignerFromBytes } from \"@solana/kit\";\nimport { createSignerFromKeyPair } from \"@solana/kit\";\n\nexport function assertKeyPairIsExtractable(keyPair: CryptoKeyPair): asserts keyPair is ExtractableCryptoKeyPair {\n  assertKeyExporterIsAvailable();\n\n  if (!keyPair.privateKey) {\n    throw new Error(\"Keypair is missing private key\");\n  }\n\n  if (!keyPair.publicKey) {\n    throw new Error(\"Keypair is missing public key\");\n  }\n\n  if (!keyPair.privateKey.extractable) {\n    throw new Error(\"Private key is not extractable\");\n  }\n}\n\ntype Extractable = { \"~extractable\": true };\n\ntype ExtractableCryptoKeyPair = CryptoKeyPair & Extractable;\ntype ExtractableKeyPairSigner = KeyPairSigner & Extractable;\n\n/**\n * Generates an extractable Ed25519 `CryptoKeyPair` capable of signing messages and transactions\n * */\nexport async function generateExtractableKeyPair(): Promise<ExtractableCryptoKeyPair> {\n  await assertKeyGenerationIsAvailable();\n  return crypto.subtle.generateKey(\n    /* algorithm */ \"Ed25519\", // Native implementation status: https://github.com/WICG/webcrypto-secure-curves/issues/20\n    /* extractable */ true,\n    /* allowed uses */ [\"sign\", \"verify\"],\n  ) as Promise<ExtractableCryptoKeyPair>;\n}\n\n/**\n * Generates an extractable signer capable of signing messages and transactions using a Crypto KeyPair.\n * */\nexport async function generateExtractableKeyPairSigner(): Promise<ExtractableKeyPairSigner> {\n  return createSignerFromKeyPair(await generateExtractableKeyPair()) as Promise<ExtractableKeyPairSigner>;\n}\n\n/**\n * Extracts the raw key material from an extractable Ed25519 CryptoKeyPair.\n *\n * @remarks\n * - Requires a keypair generated with extractable=true. See {@link generateExtractableKeyPair}.\n * - The extracted bytes can be used to reconstruct the `CryptoKeyPair` with {@link createKeyPairFromBytes}.\n *\n * @param keypair An extractable Ed25519 `CryptoKeyPair`\n * @returns Raw key bytes as `Uint8Array`\n */\nexport async function extractBytesFromKeyPair(keypair: ExtractableCryptoKeyPair | CryptoKeyPair): Promise<Uint8Array> {\n  assertKeyPairIsExtractable(keypair);\n\n  const [publicKeyBytes, privateKeyJwk] = await Promise.all([\n    crypto.subtle.exportKey(\"raw\", keypair.publicKey),\n    crypto.subtle.exportKey(\"jwk\", keypair.privateKey),\n  ]);\n\n  if (!privateKeyJwk.d) throw new Error(\"Failed to get private key bytes\");\n\n  return new Uint8Array([...Buffer.from(privateKeyJwk.d, \"base64\"), ...new Uint8Array(publicKeyBytes)]);\n}\n\n/**\n * Extracts the raw key material from an extractable Ed25519 KeyPairSigner.\n *\n * @remarks\n * - Requires a keypair generated with extractable=true. See {@link generateExtractableKeyPairSigner}.\n * - The extracted bytes can be used to reconstruct the `CryptoKeyPair` with {@link createKeyPairSignerFromBytes}.\n *\n * @param keypairSigner An extractable Ed25519 `KeyPairSigner`\n * @returns Raw key bytes as `Uint8Array`\n */\nexport async function extractBytesFromKeyPairSigner(\n  keypairSigner: ExtractableKeyPairSigner | KeyPairSigner,\n): Promise<Uint8Array> {\n  return extractBytesFromKeyPair(keypairSigner.keyPair);\n}\n","import { COMPUTE_BUDGET_PROGRAM_ADDRESS, ComputeBudgetInstruction } from \"@solana-program/compute-budget\";\nimport type { Instruction, InstructionWithData, TransactionMessage } from \"@solana/kit\";\nimport { isInstructionForProgram, isInstructionWithData } from \"@solana/kit\";\n\n/**\n * Check if a given instruction is a `SetComputeUnitLimit` instruction\n */\nexport function isSetComputeLimitInstruction(\n  instruction: Instruction,\n): instruction is Instruction<typeof COMPUTE_BUDGET_PROGRAM_ADDRESS> & InstructionWithData<Uint8Array> {\n  return (\n    isInstructionForProgram(instruction, COMPUTE_BUDGET_PROGRAM_ADDRESS) &&\n    isInstructionWithData(instruction) &&\n    instruction.data[0] === ComputeBudgetInstruction.SetComputeUnitLimit\n  );\n}\n\n/**\n * Check if a given transaction contains a `SetComputeUnitLimit` instruction\n */\nexport function hasSetComputeLimitInstruction(tx: TransactionMessage): boolean {\n  return tx.instructions.filter(isSetComputeLimitInstruction).length == 1;\n}\n\n/**\n * Check if a given instruction is a `SetComputeUnitPrice` instruction\n */\nexport function isSetComputeUnitPriceInstruction(\n  instruction: Instruction,\n): instruction is Instruction<typeof COMPUTE_BUDGET_PROGRAM_ADDRESS> & InstructionWithData<Uint8Array> {\n  return (\n    isInstructionForProgram(instruction, COMPUTE_BUDGET_PROGRAM_ADDRESS) &&\n    isInstructionWithData(instruction) &&\n    instruction.data[0] === ComputeBudgetInstruction.SetComputeUnitPrice\n  );\n}\n\n/**\n * Check if a given transaction contains a `SetComputeUnitPrice` instruction\n */\nexport function hasSetComputeUnitPriceInstruction(tx: TransactionMessage): boolean {\n  return tx.instructions.filter(isSetComputeUnitPriceInstruction).length == 1;\n}\n","import { COMPUTE_BUDGET_PROGRAM_ADDRESS, getSetComputeUnitLimitInstruction } from \"@solana-program/compute-budget\";\nimport type {\n  GetLatestBlockhashApi,\n  Rpc,\n  SimulateTransactionApi,\n  TransactionMessage,\n  TransactionMessageWithBlockhashLifetime,\n  TransactionMessageWithFeePayer,\n} from \"@solana/kit\";\nimport {\n  appendTransactionMessageInstruction,\n  assertIsTransactionMessageWithBlockhashLifetime,\n  setTransactionMessageLifetimeUsingBlockhash,\n} from \"@solana/kit\";\nimport { isSetComputeLimitInstruction, estimateComputeUnitLimitFactory } from \"../programs/compute-budget\";\nimport { transactionToBase64WithSigners } from \"./base64-to-transaction\";\nimport { debug, isDebugEnabled } from \"./debug\";\n\ntype PrepareCompilableTransactionMessage = TransactionMessageWithFeePayer & TransactionMessage;\n\nexport type PrepareTransactionConfig<TMessage extends PrepareCompilableTransactionMessage> = {\n  /**\n   * Transaction to prepare for sending to the blockchain\n   */\n  transaction: TMessage;\n  /**\n   * RPC client capable of simulating transactions and getting the latest blockhash\n   **/\n  rpc: Rpc<GetLatestBlockhashApi & SimulateTransactionApi>;\n  /**\n   * Multiplier applied to the simulated compute unit value obtained from simulation\n   *\n   * Default: `1.1`\n   **/\n  computeUnitLimitMultiplier?: number;\n  /**\n   * Whether or not you wish to force reset the compute unit limit value (if one is already set)\n   * using the simulation response and `computeUnitLimitMultiplier`\n   **/\n  computeUnitLimitReset?: boolean;\n  /**\n   * Whether or not you wish to force reset the latest blockhash (if one is already set)\n   *\n   * Default: `true`\n   **/\n  blockhashReset?: boolean;\n};\n\n/**\n * Prepare a Transaction to be signed and sent to the network. Including:\n * - setting a compute unit limit (if not already set)\n * - fetching the latest blockhash (if not already set)\n * - (optional) simulating and resetting the compute unit limit\n * - (optional) resetting latest blockhash to the most recent\n */\nexport async function prepareTransaction<TMessage extends PrepareCompilableTransactionMessage>(\n  config: PrepareTransactionConfig<TMessage>,\n): Promise<TMessage & TransactionMessageWithBlockhashLifetime> {\n  // set the config defaults\n  if (!config.computeUnitLimitMultiplier) config.computeUnitLimitMultiplier = 1.1;\n  if (config.blockhashReset !== false) config.blockhashReset = true;\n\n  const computeBudgetIndex = {\n    limit: -1,\n    price: -1,\n  };\n\n  config.transaction.instructions.map((ix, index) => {\n    if (ix.programAddress != COMPUTE_BUDGET_PROGRAM_ADDRESS) return;\n\n    if (isSetComputeLimitInstruction(ix)) {\n      computeBudgetIndex.limit = index;\n    }\n    // else if (isSetComputeUnitPriceInstruction(ix)) {\n    //   computeBudgetIndex.price = index;\n    // }\n  });\n\n  // set a compute unit limit instruction\n  if (computeBudgetIndex.limit < 0 || config.computeUnitLimitReset) {\n    const units = await estimateComputeUnitLimitFactory({ rpc: config.rpc })(config.transaction);\n    debug(`Obtained compute units from simulation: ${units}`, \"debug\");\n    const ix = getSetComputeUnitLimitInstruction({\n      units: units * config.computeUnitLimitMultiplier,\n    });\n\n    if (computeBudgetIndex.limit < 0) {\n      config.transaction = appendTransactionMessageInstruction(ix, config.transaction) as unknown as TMessage;\n    } else if (config.computeUnitLimitReset) {\n      const nextInstructions = [...config.transaction.instructions];\n      nextInstructions.splice(computeBudgetIndex.limit, 1, ix);\n      config.transaction = Object.freeze({\n        ...config.transaction,\n        instructions: nextInstructions,\n      } as TMessage);\n    }\n  }\n\n  // update the latest blockhash\n  if (config.blockhashReset || \"lifetimeConstraint\" in config.transaction == false) {\n    const { value: latestBlockhash } = await config.rpc.getLatestBlockhash().send();\n    if (\"lifetimeConstraint\" in config.transaction == false) {\n      debug(\"Transaction missing latest blockhash, fetching one.\", \"debug\");\n      config.transaction = setTransactionMessageLifetimeUsingBlockhash(\n        latestBlockhash,\n        config.transaction,\n      ) as unknown as TMessage;\n    } else if (config.blockhashReset) {\n      debug(\"Auto resetting the latest blockhash.\", \"debug\");\n      config.transaction = Object.freeze({\n        ...config.transaction,\n        lifetimeConstraint: latestBlockhash,\n      } as TransactionMessageWithBlockhashLifetime & typeof config.transaction);\n    }\n  }\n\n  assertIsTransactionMessageWithBlockhashLifetime(config.transaction);\n\n  // skip the async call if debugging is off\n  if (isDebugEnabled()) {\n    debug(`Transaction as base64: ${await transactionToBase64WithSigners(config.transaction)}`, \"debug\");\n  }\n\n  return config.transaction;\n}\n","/**\n * Calculate the total rent needed for to create an account, with or without extra data stored in it\n */\nexport function getMinimumBalanceForRentExemption(space: bigint | number = 0) {\n  /**\n   * Default values for Rent calculations\n   *\n   * Values taken from: https://github.com/anza-xyz/solana-sdk/blob/c07f692e41d757057c8700211a9300cdcd6d33b1/rent/src/lib.rs#L93-L97\n   *\n   */\n  const RENT = {\n    /**\n     * Account storage overhead for calculation of base rent. (aka the number of bytes required to store an account with no data.\n     */\n    ACCOUNT_STORAGE_OVERHEAD: 128n,\n    /**\n     * Amount of time (in years) a balance must include rent for the account to\n     * be rent exempt.\n     */\n    DEFAULT_EXEMPTION_THRESHOLD: BigInt(Math.floor(2.0 * 1000)) / 1000n,\n    /**\n     * Default rental rate in lamports/byte-year. This calculation is based on:\n     * - 10^9 lamports per SOL\n     * - $1 per SOL\n     * - $0.01 per megabyte day\n     * - $3.65 per megabyte year\n     */\n    DEFAULT_LAMPORTS_PER_BYTE_YEAR: BigInt(Math.floor(((1_000_000_000 / 100) * 365) / (1024 * 1024))),\n  };\n\n  return (\n    ((RENT.ACCOUNT_STORAGE_OVERHEAD + BigInt(space)) *\n      RENT.DEFAULT_LAMPORTS_PER_BYTE_YEAR *\n      RENT.DEFAULT_EXEMPTION_THRESHOLD) /\n    1n\n  );\n}\n","import {\n  assertIsTransactionSigner,\n  createNoopSigner,\n  isTransactionSigner,\n  type Address,\n  type TransactionSigner,\n} from \"@solana/kit\";\nimport type { SolanaClusterMoniker } from \"../types\";\nimport { GENESIS_HASH } from \"./const\";\n\n/**\n * Determine the Solana moniker from its genesis hash\n *\n * If the hash is NOT known, returns `unknown`\n */\nexport function getMonikerFromGenesisHash(hash: string): SolanaClusterMoniker | \"unknown\" {\n  switch (hash) {\n    case GENESIS_HASH.mainnet:\n      return \"mainnet\";\n    case GENESIS_HASH.devnet:\n      return \"devnet\";\n    case GENESIS_HASH.testnet:\n      return \"testnet\";\n    default:\n      return \"unknown\";\n  }\n}\n\nexport function checkedAddress<TAddress extends string = string>(\n  input: Address<TAddress> | TransactionSigner<TAddress>,\n): Address<TAddress> {\n  return typeof input == \"string\" ? input : input.address;\n}\n\nexport function checkedTransactionSigner<TAddress extends string = string>(\n  input: Address<TAddress> | TransactionSigner<TAddress>,\n): TransactionSigner<TAddress> {\n  if (typeof input === \"string\" || \"address\" in input == false) input = createNoopSigner(input);\n  if (!isTransactionSigner(input)) throw new Error(\"A signer or address is required\");\n  assertIsTransactionSigner(input);\n  return input;\n}\n\n/**\n * Convert a lamport number to the human readable string of a SOL value\n * @param lamports - The amount in lamports\n * @param decimals - Number of decimal places to show (default: 9, max: 9)\n */\nexport function lamportsToSol(lamports: bigint | number, decimals: number = 9): string {\n  const maxDecimals = Math.min(decimals, 9);\n  const solValue = Number(lamports) / 1_000_000_000;\n  return new Intl.NumberFormat(\"en-US\", {\n    maximumFractionDigits: maxDecimals,\n    minimumFractionDigits: 0,\n  }).format(solValue);\n}\n","import type {} from \"@solana/kit\";\nimport {\n  getBase58Encoder,\n  getPublicKeyFromAddress,\n  verifySignature,\n  type Address,\n  type ReadonlyUint8Array,\n  type Signature,\n  type SignatureBytes,\n} from \"@solana/kit\";\n\n/**\n * Verifies a Solana Address had signed the given message.\n *\n * @param address - The Solana address expected to have signed the message\n * @param signature - The signature to verify\n * @param signedMessage - The original message that was signed\n * @returns Promise that resolves to `true` if the signature is valid, `false` otherwise\n *\n * @example\n * ```typescript\n * const isValid = await verifySignatureForAddress(\n *   \"GC5AFcYqshWUnNK23MbWTXPix3FUagZt4fjUAt88FT59\" as Address,\n *   \"jrZaHRqiRojydQMxHqqe7FEkfeyw64KfPdF2ww1mm3hpVtGyxBvEU5NmHdZFoawYnYu62ujgqw3gcL2XHYbxd9K\",\n *   \"Hello, Solana!!\"\n * );\n * console.log(isValid); // true or false\n * ```\n */\nexport async function verifySignatureForAddress(\n  address: Address,\n  signature: string | Signature | SignatureBytes | Uint8Array | ReadonlyUint8Array,\n  message: string | Uint8Array,\n): Promise<boolean> {\n  const publicKey = await getPublicKeyFromAddress(address);\n  if (typeof message === \"string\") {\n    message = new TextEncoder().encode(message);\n  }\n  // massage the signature into the branded type for `SignatureBytes`\n  if (typeof signature === \"string\") {\n    signature = getBase58Encoder().encode(signature);\n  }\n  return verifySignature(publicKey, signature as SignatureBytes, message);\n}\n"]}