@xyo-network/xl1-protocol-sdk 1.26.11 → 1.26.13

package/src/test/buildRandomGenesisBlock.ts

@@ -1,47 +0,0 @@
-import { asAddress, assertEx } from '@xylabs/sdk-js'
-import type { AccountInstance, Id } from '@xyo-network/sdk-js'
-import {
-  Account, asAnyPayload, asSchema, IdSchema,
-  PayloadBuilder,
-} from '@xyo-network/sdk-js'
-import {
-  asXL1BlockNumber, type ChainId, type HydratedBlockWithHashMeta,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { buildRandomTransaction } from '../transaction/index.ts'
-import { buildGenesisBlock } from './buildGenesisBlock.ts'
-
-/** TestChainId constant. */
-export const TestChainId = assertEx(asAddress('c5fe2e6F6841Cbab12d8C0618Be2DF8C6156cC44')) as ChainId
-
-/**
- * Creates a random block
- * @param chainId The chain id for the block
- * @param blockProducer The producer for the blocks
- * @param transactionAccount The account to use for the transaction
- * @returns A block
- */
-export const buildRandomGenesisBlock = async (
-  chainId: ChainId = TestChainId,
-  blockProducer?: AccountInstance,
-  transactionAccount?: AccountInstance,
-): Promise<HydratedBlockWithHashMeta> => {
-  const producer = blockProducer ?? (await Account.random())
-  const txAccount = transactionAccount ?? await Account.random()
-  const additionalPayload = new PayloadBuilder<Id>({ schema: IdSchema }).fields({ salt: `${Date.now()}` }).build()
-  const additionalPrivatePayload = new PayloadBuilder({ schema: asSchema('network.xyo.private', true) }).fields({ salt: `${Date.now()}` }).build()
-  const txs = [await buildRandomTransaction(
-    chainId,
-    [additionalPayload, additionalPrivatePayload],
-    txAccount,
-    asXL1BlockNumber(0, true),
-    asXL1BlockNumber(1000, true),
-    [asSchema('network.xyo.private', true)],
-  )]
-  const block = await buildGenesisBlock(chainId, txs, [], [producer])
-  const payloads = [
-    ...block[1],
-    await PayloadBuilder.addHashMeta(additionalPayload),
-  ]
-  return [block[0], payloads.map(p => asAnyPayload(p, true))]
-}

package/src/test/createGenesisBlock.ts

@@ -1,41 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import type { AccountInstance, WithHashMeta } from '@xyo-network/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, ChainId, SignedHydratedBlockWithHashMeta,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  BlockBoundWitnessSchemaPayload, BlockBoundWitnessWithStorageMetaSchemaPayload,
-  ChainStakeIntentPayloadJsonSchemaPayload, HashPayloadJsonSchemaPayload, TransactionBoundWitnessSchemaPayload, TransactionBoundWitnessWithStorageMetaSchemaPayload, TransferPayloadJsonSchemaPayload,
-} from '@xyo-network/xl1-schema'
-
-import { createTransferPayload } from '../createTransferPayload.ts'
-import { buildGenesisBlock } from './buildGenesisBlock.ts'
-import { createProducerChainStakeIntent } from './createProducerChainStakeIntentTransaction.ts'
-
-/** createGenesisBlock constant. */
-export const createGenesisBlock = async (
-  initialBlockProducer: AccountInstance,
-  nextContractAddress: ChainId,
-  genesisBlockRewardAmount: bigint,
-  genesisBlockRewardAddress: Address,
-): Promise<SignedHydratedBlockWithHashMeta> => {
-  const blockPayloads: WithHashMeta<AllowedBlockPayload>[] = await PayloadBuilder.addHashMeta([
-    TransferPayloadJsonSchemaPayload,
-    BlockBoundWitnessSchemaPayload,
-    BlockBoundWitnessWithStorageMetaSchemaPayload,
-    TransactionBoundWitnessSchemaPayload,
-    TransactionBoundWitnessWithStorageMetaSchemaPayload,
-    ChainStakeIntentPayloadJsonSchemaPayload,
-    HashPayloadJsonSchemaPayload,
-  ])
-  const intentPayload = await createProducerChainStakeIntent(initialBlockProducer.address, 1, 0)
-  blockPayloads.push(intentPayload)
-  if (genesisBlockRewardAmount > 0n) {
-    blockPayloads.push(await PayloadBuilder.addHashMeta(createTransferPayload(
-      nextContractAddress as Address,
-      { [genesisBlockRewardAddress]: genesisBlockRewardAmount },
-    )))
-  }
-  return await buildGenesisBlock(nextContractAddress, [], blockPayloads, [initialBlockProducer])
-}

package/src/test/createProducerChainStakeIntentTransaction.ts

@@ -1,48 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import type { AccountInstance } from '@xyo-network/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type {
-  ChainId, ChainStakeIntent,
-  HydratedTransactionWithHashMeta,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asXL1BlockNumber, ChainStakeIntentSchema,
-  defaultTransactionFees,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { buildTransaction } from '../transaction/index.ts'
-
-/** Creates a ProducerChainStakeIntent instance. */
-export async function createProducerChainStakeIntent(from: Address, exp: number, nbf = 0) {
-  return await PayloadBuilder.addHashMeta(new PayloadBuilder<ChainStakeIntent>({ schema: ChainStakeIntentSchema }).fields({
-    from,
-    exp,
-    nbf,
-    intent: 'producer',
-  }).build())
-}
-
-/** Creates a ProducerChainStakeIntentTransaction instance. */
-export async function createProducerChainStakeIntentTransaction(
-  chain: ChainId,
-  signers: AccountInstance[] = [],
-  producer: Address,
-  exp: XL1BlockNumber,
-  nbf = asXL1BlockNumber(0, true),
-  fees = defaultTransactionFees,
-): Promise<HydratedTransactionWithHashMeta> {
-  // Create staked intents for all the block producers declaring their intent to produce blocks
-  const intent = await createProducerChainStakeIntent(producer, exp, nbf)
-  const tx = await buildTransaction(
-    chain,
-    [intent],
-    [],
-    signers,
-    nbf,
-    exp,
-    signers[0].address,
-    fees,
-  )
-  return tx
-}

package/src/test/getSimpleBlockViewerLocator.ts

@@ -1,41 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import type { ArchivistInstance } from '@xyo-network/sdk-js'
-import { type ChainId, XYO_ZERO_ADDRESS } from '@xyo-network/xl1-protocol-lib'
-
-import { getTestProviderContext } from '../_internal/index.ts'
-import { type Config, ConfigZod } from '../config/index.ts'
-import {
-  SimpleBlockViewer, SimpleChainContractViewer, SimpleFinalizationViewer,
-} from '../simple/index.ts'
-import { buildRandomChainArchivist } from './buildRandomChain.ts'
-
-/** Parameters for TestSimpleBlockViewerLocator. */
-export interface TestSimpleBlockViewerLocatorParams {
-  chainId?: ChainId
-  config?: Config
-  finalizedArchivist?: ArchivistInstance
-  minWithdrawalBlocks?: number
-  rewardsContract?: Address
-  stakingTokenAddress?: Address
-}
-
-/** Retrieves the TestSimpleBlockViewerLocator. */
-export async function getTestSimpleBlockViewerLocator({
-  minWithdrawalBlocks = 10,
-  config = ConfigZod.parse({}),
-  finalizedArchivist: finalizedArchivistIn,
-  rewardsContract = XYO_ZERO_ADDRESS, stakingTokenAddress = XYO_ZERO_ADDRESS,
-}: TestSimpleBlockViewerLocatorParams) {
-  const finalizedArchivist = finalizedArchivistIn ?? await buildRandomChainArchivist()
-  const context = getTestProviderContext(config)
-  context.locator.registerMany([
-    SimpleChainContractViewer.factory<SimpleChainContractViewer>(SimpleChainContractViewer.dependencies, {
-      minWithdrawalBlocks,
-      rewardsContract,
-      stakingTokenAddress,
-    }),
-    SimpleFinalizationViewer.factory<SimpleFinalizationViewer>(SimpleFinalizationViewer.dependencies, { finalizedArchivist }),
-    SimpleBlockViewer.factory<SimpleBlockViewer>(SimpleBlockViewer.dependencies, { finalizedArchivist }),
-  ])
-  return context.locator
-}

package/src/test/getTestProviderContext.ts

@@ -1,8 +0,0 @@
-import { getTestProviderContext as getTestProviderContextInternal } from '../_internal/index.ts'
-import type { Config } from '../config/index.ts'
-import type { CreatableProviderContext } from '../model/index.ts'
-
-/** Retrieves the TestProviderContext. */
-export function getTestProviderContext(config: Config): CreatableProviderContext {
-  return getTestProviderContextInternal(config)
-}

package/src/test/index.ts

@@ -1,2 +0,0 @@
-export * from './getSimpleBlockViewerLocator.ts'
-export * from './getTestProviderContext.ts'

package/src/time/index.ts

@@ -1 +0,0 @@
-export * from './primitives/index.ts'

package/src/time/primitives/index.ts

@@ -1 +0,0 @@
-export * from './xl1BlockNumberToEthBlockNumber.ts'

package/src/time/primitives/xl1BlockNumberToEthBlockNumber.ts

@@ -1,13 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { ChainContextRead, XL1BlockNumber } from '@xyo-network/xl1-protocol-lib'
-import { asTimePayload, TimeSchema } from '@xyo-network/xl1-protocol-lib'
-
-import { hashFromBlockNumber, hydrateBlock } from '../../block/index.ts'
-
-/** Xl1BlockNumberToEthBlockNumber helper function. */
-export async function xl1BlockNumberToEthBlockNumber(context: ChainContextRead, xl1BlockNumber: XL1BlockNumber): Promise<number> {
-  const blockHash = await hashFromBlockNumber(context, xl1BlockNumber)
-  const hydratedBlock = await hydrateBlock(context, blockHash)
-  const timePayload = asTimePayload(hydratedBlock[1].find(p => p.schema === TimeSchema), { required: true })
-  return assertEx(timePayload.ethereum, () => 'No ethereum timestamp found on block')
-}

package/src/transaction/TransactionBuilder.ts

@@ -1,164 +0,0 @@
-import type { Hex } from '@xylabs/sdk-js'
-import { assertEx, Base } from '@xylabs/sdk-js'
-import type {
-  AccountInstance, Payload, PayloadBuilderOptions,
-} from '@xyo-network/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload,
-  ChainId,
-  TransactionFeesBigInt,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asXL1BlockNumber,
-  defaultTransactionFees, isAllowedBlockPayload, minTransactionFees, XYO_ZERO_ADDRESS,
-} from '@xyo-network/xl1-protocol-lib'
-
-import { buildTransaction } from './buildTransaction.ts'
-import { transactionRequiredGas } from './primitives/index.ts'
-
-/** Builder for constructing Transaction instances. */
-export class TransactionBuilder<TPayload extends Payload> extends Base<Omit<PayloadBuilderOptions, 'schema'>> {
-  private _blockRange?: [number, number]
-  private _chain?: Hex
-  private _elevatedPayloads: AllowedBlockPayload[] = []
-  private _fees: TransactionFeesBigInt | undefined
-  private _payloads: TPayload[] = []
-  private _signers: AccountInstance[] = []
-
-  constructor(options: Omit<PayloadBuilderOptions, 'schema'> = {}) {
-    super(options)
-  }
-
-  async build() {
-    const chain = assertEx(this._chain, () => 'Chain must be set before building the transaction')
-    const fees = assertEx(this._fees, () => 'Fees must be set before building the transaction')
-    const blockRange = assertEx(this._blockRange, () => 'Block range must be set before building the transaction')
-    return await buildTransaction(
-      chain,
-      this._elevatedPayloads,
-      this._payloads,
-      this._signers,
-      asXL1BlockNumber(blockRange[0], true),
-      asXL1BlockNumber(blockRange[1], true),
-      this._signers[0]?.address,
-      fees,
-    )
-  }
-
-  chain(chain: ChainId) {
-    this._chain = chain
-    return this
-  }
-
-  async dryRun() {
-    return await buildTransaction(
-      XYO_ZERO_ADDRESS,
-      this._elevatedPayloads,
-      this._payloads,
-      this._signers,
-      asXL1BlockNumber(0, true),
-      asXL1BlockNumber(1000, true),
-      this._signers[0]?.address,
-      defaultTransactionFees,
-    )
-  }
-
-  elevatedPayload(payload?: AllowedBlockPayload) {
-    const allowedPayload = isAllowedBlockPayload(payload) ? payload : undefined
-    const allowPayloadExists = assertEx(allowedPayload, () => 'Payload must be an AllowedBlockPayload')
-    this._elevatedPayloads.push(allowPayloadExists)
-    return this
-  }
-
-  elevatedPayloads(payloads?: AllowedBlockPayload[]) {
-    if (payloads)
-      for (const payload of payloads) {
-        this.elevatedPayload(payload)
-      }
-    return this
-  }
-
-  async estimatedMinimumFees(): Promise<TransactionFeesBigInt> {
-    const tx = await this.dryRun()
-    const requiredGas = transactionRequiredGas(tx)
-    return {
-      base: minTransactionFees.base,
-      // eslint-disable-next-line unicorn/prefer-math-min-max
-      gasLimit: requiredGas > minTransactionFees.gasLimit ? requiredGas : minTransactionFees.gasLimit,
-      gasPrice: minTransactionFees.gasPrice,
-      priority: minTransactionFees.priority,
-    }
-  }
-
-  fees(fees: TransactionFeesBigInt) {
-    this._fees = fees
-    return this
-  }
-
-  payload(payload?: TPayload) {
-    this._payloads.push(payload as TPayload)
-    return this
-  }
-
-  payloads(payloads?: TPayload[]) {
-    if (payloads)
-      for (const payload of payloads) {
-        if (payload !== null) {
-          this.payload(payload)
-        }
-      }
-    return this
-  }
-
-  range(blockRange: [number, number]) {
-    if (blockRange.length !== 2) {
-      throw new Error('Block range must be an array of two numbers')
-    }
-    this._blockRange = blockRange
-    return this
-  }
-
-  async removeElevatedPayload(payload: AllowedBlockPayload) {
-    const hash = await PayloadBuilder.hash(payload)
-    const existingHashes = await PayloadBuilder.hashes(this._elevatedPayloads)
-
-    // no async after this point to prevent changing _elevatedPayloads from other promise
-    const existingPayloadIndex = existingHashes.indexOf(hash)
-    if (existingPayloadIndex === -1) {
-      throw new Error('Payload not found in the transaction')
-    }
-    this._elevatedPayloads = this._elevatedPayloads.filter((_, index) => index !== existingPayloadIndex)
-    return this
-  }
-
-  async removePayload(payload: TPayload) {
-    const hash = await PayloadBuilder.hash(payload)
-    const existingHashes = await PayloadBuilder.hashes(this._payloads)
-
-    // no async after this point to prevent changing _payloads from other promise
-    const existingPayloadIndex = existingHashes.indexOf(hash)
-    if (existingPayloadIndex === -1) {
-      throw new Error('Payload not found in the transaction')
-    }
-    this._payloads = this._payloads.filter((_, index) => index !== existingPayloadIndex)
-    return this
-  }
-
-  signer(signer?: AccountInstance) {
-    if (signer) {
-      this._signers.push(signer)
-    }
-    return this
-  }
-
-  signers(signers?: (AccountInstance | null)[]) {
-    if (signers)
-      for (const signer of signers) {
-        if (signer !== null) {
-          this.signer(signer)
-        }
-      }
-    return this
-  }
-}

package/src/transaction/buildRandomTransaction.ts

@@ -1,38 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import type {
-  AccountInstance, Payload, Schema,
-} from '@xyo-network/sdk-js'
-import { Account } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, ChainId,
-  SignedHydratedTransactionWithHashMeta,
-  Transfer,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-import { asXL1BlockNumber, isAllowedBlockPayload } from '@xyo-network/xl1-protocol-lib'
-
-import { createTransferPayload } from '../createTransferPayload.ts'
-import { buildTransaction } from './buildTransaction.ts'
-
-/** buildRandomTransaction constant. */
-export const buildRandomTransaction = async (
-  chain: ChainId,
-  payloads?: Payload[],
-  account?: AccountInstance,
-  nbf: XL1BlockNumber = asXL1BlockNumber(0, true),
-  exp: XL1BlockNumber = asXL1BlockNumber(nbf + 1000, true),
-  privatePayloadSchemas: Schema[] = [],
-  receiverAddress?: Address,
-): Promise<SignedHydratedTransactionWithHashMeta> => {
-  const elevatedPayloads: AllowedBlockPayload[] = (payloads ?? []).filter(isAllowedBlockPayload)
-  const additionalPayloads: Payload[] = (payloads ?? []).filter(payload => !isAllowedBlockPayload(payload))
-  const sender = account ?? await Account.random()
-  if (elevatedPayloads?.length === 0) {
-    const receiver = receiverAddress ?? (await Account.random()).address
-    const transferPayload: Transfer = createTransferPayload(sender.address, { [receiver]: 1n })
-    elevatedPayloads.push(transferPayload)
-  }
-  const hydratedTransaction = await buildTransaction(chain, elevatedPayloads, additionalPayloads, sender, nbf, exp)
-  // remove private payloads from hydrated
-  return [hydratedTransaction[0], hydratedTransaction[1].filter(p => !privatePayloadSchemas.includes(p.schema))]
-}

package/src/transaction/buildTransaction.ts

@@ -1,68 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { assertEx, toHex } from '@xylabs/sdk-js'
-import type { AccountInstance, Payload } from '@xyo-network/sdk-js'
-import {
-  asAnyPayload, BoundWitnessBuilder, PayloadBuilder,
-} from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload,
-  ChainId,
-  ExecutableFields,
-  FromFields,
-  SignedHydratedTransactionWithHashMeta,
-  TransactionBoundWitness, TransactionBoundWitnessFields, TransactionFeesBigInt,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-import { defaultTransactionFees } from '@xyo-network/xl1-protocol-lib'
-
-/** Builds a Transaction instance. */
-export async function buildTransaction(
-  chain: ChainId,
-  onChainPayloads: AllowedBlockPayload[],
-  offChainPayloads: Payload[],
-  signer: AccountInstance | AccountInstance[],
-  nbf: XL1BlockNumber,
-  exp: XL1BlockNumber,
-  from?: Address,
-  fees: TransactionFeesBigInt = defaultTransactionFees,
-): Promise<SignedHydratedTransactionWithHashMeta> {
-  if (from === undefined && Array.isArray(signer)) {
-    throw new Error('from is required when signer is an array')
-  }
-
-  const txBoundWitnessFields: Omit<TransactionBoundWitnessFields, 'from'> = {
-    chain,
-    fees: {
-      base: toHex(fees.base),
-      gasLimit: toHex(fees.gasLimit),
-      gasPrice: toHex(fees.gasPrice),
-      priority: toHex(fees.priority),
-    },
-    nbf,
-    exp,
-  }
-
-  const elevatedHashes = await PayloadBuilder.hashes(onChainPayloads)
-  const script: string[] = []
-  for (const elevatedHash of elevatedHashes) {
-    script.push(`elevate|${elevatedHash}`)
-  }
-
-  const fields: TransactionBoundWitnessFields & FromFields & Partial<ExecutableFields> = {
-    ...txBoundWitnessFields,
-    from: from ?? (Array.isArray(signer) ? assertEx(signer.at(0)?.address) : signer.address),
-  }
-
-  if (script.length > 0) {
-    fields.script = script
-  }
-
-  const [tx, txPayloads] = await new BoundWitnessBuilder<TransactionBoundWitness>()
-    .fields(fields)
-    .meta({ $signatures: [] })
-    .payloads([...onChainPayloads, ...offChainPayloads])
-    .signers(Array.isArray(signer) ? signer : [signer])
-    .build()
-
-  return [await PayloadBuilder.addHashMeta(tx), await PayloadBuilder.addHashMeta(txPayloads.map(p => asAnyPayload(p, true)))]
-}

package/src/transaction/buildUnsignedTransaction.ts

@@ -1,56 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-import { toHex } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/sdk-js'
-import { BoundWitnessBuilder, PayloadBuilder } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, ChainId, ExecutableFields, FromFields, TransactionBoundWitness, TransactionBoundWitnessFields, TransactionFeesBigInt,
-  UnsignedHydratedTransaction,
-  XL1BlockNumber,
-} from '@xyo-network/xl1-protocol-lib'
-import { defaultTransactionFees } from '@xyo-network/xl1-protocol-lib'
-
-/** Builds a UnsignedTransaction instance. */
-export async function buildUnsignedTransaction(
-  chain: ChainId,
-  onChainPayloads: AllowedBlockPayload[],
-  offChainPayloads: Payload[],
-  nbf: XL1BlockNumber,
-  exp: XL1BlockNumber,
-  from: Address,
-  fees: TransactionFeesBigInt = defaultTransactionFees,
-): Promise<UnsignedHydratedTransaction> {
-  const txBoundWitnessFields: Omit<TransactionBoundWitnessFields, 'from'> = {
-    chain,
-    fees: {
-      base: toHex(fees.base),
-      gasLimit: toHex(fees.gasLimit),
-      gasPrice: toHex(fees.gasPrice),
-      priority: toHex(fees.priority),
-    },
-    nbf,
-    exp,
-  }
-
-  const elevatedHashes = await PayloadBuilder.hashes(onChainPayloads)
-  const script: string[] = []
-  for (const elevatedHash of elevatedHashes) {
-    script.push(`elevate|${elevatedHash}`)
-  }
-
-  const fields: TransactionBoundWitnessFields & FromFields & Partial<ExecutableFields> = {
-    ...txBoundWitnessFields,
-    from,
-  }
-
-  if (script.length > 0) {
-    fields.script = script
-  }
-
-  const [tx, txPayloads] = await new BoundWitnessBuilder<TransactionBoundWitness>()
-    .fields(fields)
-    .meta({ $signatures: [] })
-    .payloads([...onChainPayloads, ...offChainPayloads])
-    .build(false)
-
-  return [tx, txPayloads]
-}

package/src/transaction/confirmSubmittedTransaction.ts

@@ -1,42 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { delay, isDefined } from '@xylabs/sdk-js'
-import type {
-  ConfirmSubmittedTransactionOptions, SignedHydratedTransaction,
-  XyoViewer,
-} from '@xyo-network/xl1-protocol-lib'
-
-const DEFAULT_CONFIRMATION_ATTEMPTS = 20
-const DEFAULT_DELAY_BETWEEN_ATTEMPTS = 1000 // milliseconds
-
-/**
- * Confirms a submitted transaction by checking if it has been included in the blockchain.
- * @param viewer The viewer
- * @param txHash The hash of the transaction to confirm
- * @param options Options for confirmation
- * @returns The confirmed transaction or throws an error if not confirmed
- */
-export const confirmSubmittedTransaction = async (
-  viewer: XyoViewer,
-  txHash: Hash,
-  options?: ConfirmSubmittedTransactionOptions,
-): Promise<SignedHydratedTransaction> => {
-  const { attempts: maxAttempts = DEFAULT_CONFIRMATION_ATTEMPTS, delay: attemptDelay = DEFAULT_DELAY_BETWEEN_ATTEMPTS } = options ?? {}
-  options?.logger?.log('🚀 confirming transaction:', txHash, '\n')
-  let attempts = 0
-  while (true) {
-    const tx = await viewer.transaction.byHash(txHash) ?? undefined
-    if (isDefined(tx)) {
-      options?.logger?.log('✅ Transaction confirmed:', txHash, '\n')
-      return tx
-    } else {
-      attempts++
-      if (attempts > maxAttempts) {
-        options?.logger?.error(`⚠️ Transaction not confirmed after ${maxAttempts} attempts`)
-        throw new Error(`Transaction ${txHash} not confirmed after ${maxAttempts} attempts`)
-      } else {
-        options?.logger?.log(`🔄 Transaction not confirmed yet, attempt ${attempts}. Retrying...`, '\n')
-        await delay(attemptDelay)
-      }
-    }
-  }
-}