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

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)
-      }
-    }
-  }
-}

package/src/transaction/hydrateTransaction.ts

@@ -1,117 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import { assertEx } from '@xylabs/sdk-js'
-import type { Payload, WithStorageMeta } from '@xyo-network/sdk-js'
-import {
-  asAnyPayload, hydrateTypedBoundWitness, tryHydrateTypedBoundWitness,
-} from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, HydratedTransaction, SignedHydratedTransaction,
-  SignedHydratedTransactionWithHashMeta,
-  SignedHydratedTransactionWithStorageMeta, TransactionBoundWitness,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  asSignedHydratedTransaction, isAllowedBlockPayload, isSignedTransactionBoundWitnessWithStorageMeta,
-} from '@xyo-network/xl1-protocol-lib'
-
-import type { ChainStoreRead } from '../model/index.ts'
-
-/** tryHydrateTransaction constant. */
-export const tryHydrateTransaction = async (
-  { chainMap }: ChainStoreRead,
-  hash: Hash,
-): Promise<SignedHydratedTransactionWithStorageMeta | undefined> => {
-  return (await tryHydrateTypedBoundWitness<TransactionBoundWitness>(
-    {
-      get(hashes: Hash[]) {
-        return chainMap.get(hashes)
-      },
-      next() {
-        throw new Error('Not implemented')
-      },
-    },
-    hash,
-    isSignedTransactionBoundWitnessWithStorageMeta,
-  )) as SignedHydratedTransactionWithStorageMeta | undefined
-}
-
-/** hydrateTransaction constant. */
-export const hydrateTransaction = async (
-  { chainMap }: ChainStoreRead,
-  hash: Hash,
-): Promise<SignedHydratedTransaction> => {
-  return await hydrateTypedBoundWitness<TransactionBoundWitness>(
-    {
-      get(hashes: Hash[]) {
-        return chainMap.get(hashes)
-      },
-      next() {
-        throw new Error('Not implemented')
-      },
-    },
-    hash,
-    isSignedTransactionBoundWitnessWithStorageMeta,
-  ) as SignedHydratedTransaction
-}
-
-/** FlattenHydratedTransaction helper function. */
-export function flattenHydratedTransaction<T extends HydratedTransaction>(hydratedTransaction: T): (T[0] | T[1][number])[] {
-  const [tx, txPayloads] = hydratedTransaction
-  return [...txPayloads, tx]
-}
-
-/** tryUnflattenHydratedTransaction constant. */
-export const tryUnflattenHydratedTransaction = (
-  flattened: Payload[],
-): SignedHydratedTransaction | undefined => {
-  // Last element is always the transaction bound witness
-  const tx = flattened.at(-1)
-
-  // Everything else is a payloads
-  const txPayloads = flattened.slice(0, -1)
-
-  return asSignedHydratedTransaction([tx, txPayloads])
-}
-
-/** unflattenHydratedTransaction constant. */
-export const unflattenHydratedTransaction = (flattened: Payload[]): SignedHydratedTransaction =>
-  asSignedHydratedTransaction(tryUnflattenHydratedTransaction(flattened), true)
-
-/** FlattenHydratedTransactions helper function. */
-export function flattenHydratedTransactions<T extends HydratedTransaction>(hydratedTransactions: T[]): (T[0] | T[1][number])[] {
-  return hydratedTransactions.flatMap(tx => flattenHydratedTransaction(tx))
-}
-
-/** tryHydrateElevatedTransaction constant. */
-export const tryHydrateElevatedTransaction = async (
-  { chainMap }: ChainStoreRead,
-  hash: Hash,
-): Promise<SignedHydratedTransactionWithHashMeta | undefined> => {
-  const hydratedTransaction = await tryHydrateTransaction({ chainMap }, hash)
-  if (!hydratedTransaction) {
-    return undefined
-  }
-  const [transaction, payloads] = hydratedTransaction
-  const opCodes = (transaction.script ?? []).filter(operation => operation.startsWith('elevate|'))
-  const elevatedPayloads: WithStorageMeta<AllowedBlockPayload>[] = []
-  for (const opCode of opCodes) {
-    const [code, hash] = opCode.split('|')
-    if (code === 'elevated') {
-      const elevatedPayload = payloads.find(payload => payload._hash === hash)
-      if (isAllowedBlockPayload(elevatedPayload)) {
-        elevatedPayloads.push(elevatedPayload)
-      }
-    }
-  }
-  if (opCodes.length === elevatedPayloads.length) {
-    return [transaction, elevatedPayloads.map(p => asAnyPayload(p, true))]
-  }
-  return undefined
-}
-
-/** hydrateElevatedTransaction constant. */
-export const hydrateElevatedTransaction = async (
-  context: ChainStoreRead,
-  hash: Hash,
-): Promise<SignedHydratedTransactionWithHashMeta> => {
-  return assertEx(await tryHydrateElevatedTransaction(context, hash), () => 'Hydration failed')
-}

package/src/transaction/index.ts

@@ -1,9 +0,0 @@
-export * from './buildRandomTransaction.ts'
-export * from './buildTransaction.ts'
-export * from './buildUnsignedTransaction.ts'
-export * from './confirmSubmittedTransaction.ts'
-export * from './hydrateTransaction.ts'
-export * from './primitives/index.ts'
-export * from './script.ts'
-export * from './signTransaction.ts'
-export * from './TransactionBuilder.ts'

package/src/transaction/primitives/index.ts

@@ -1,4 +0,0 @@
-export * from './transactionBlockByteCount.ts'
-export * from './transactionElevatedPayloads.ts'
-export * from './transactionOperations.ts'
-export * from './transactionRequiredGas.ts'

package/src/transaction/primitives/transactionBlockByteCount.ts

@@ -1,10 +0,0 @@
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { HydratedTransaction } from '@xyo-network/xl1-protocol-lib'
-
-/** The number of bytes that a transaction and its payloads will take up in a block */
-export function transactionBlockByteCount([transaction, payloads]: HydratedTransaction): number {
-  const cleanTransaction = PayloadBuilder.omitStorageMeta(transaction)
-  const transactionBytes = JSON.stringify(cleanTransaction).length
-  const cleanPayloads = PayloadBuilder.omitStorageMeta(payloads)
-  return cleanPayloads.reduce((acc: number, payload) => acc + JSON.stringify(payload).length, 0) + transactionBytes
-}

package/src/transaction/primitives/transactionElevatedPayloads.ts

@@ -1,18 +0,0 @@
-import { asHash, type Hash } from '@xylabs/sdk-js'
-import type { Payload, WithHashMeta } from '@xyo-network/sdk-js'
-import type { HydratedTransactionWithHashMeta, TransactionBoundWitness } from '@xyo-network/xl1-protocol-lib'
-
-import { crackOperations } from './transactionOperations.ts'
-
-/** TransactionElevatedPayloadHashes helper function. */
-export function transactionElevatedPayloadHashes(transaction: TransactionBoundWitness): Hash[] {
-  const elevateOperations = crackOperations(transaction.script ?? []).filter(op => op[0] === 'elevate')
-  return elevateOperations.map(op => asHash(op[1][0], true))
-}
-
-/** TransactionElevatedPayloads helper function. */
-export function transactionElevatedPayloads([transaction, payloads]: HydratedTransactionWithHashMeta): WithHashMeta<Payload>[] {
-  const hashes = transactionElevatedPayloadHashes(transaction)
-  const elevatedPayloads = payloads.filter(payload => hashes.includes(payload._hash))
-  return elevatedPayloads
-}

package/src/transaction/primitives/transactionOperations.ts

@@ -1,13 +0,0 @@
-/** CrackOperation helper function. */
-export function crackOperation(operation: string): [string, string[]] {
-  const parts = operation.split('|')
-  if (parts.length < 2) {
-    throw new Error(`Invalid operation format: ${operation}`)
-  }
-  return [parts[0], parts.slice(1)]
-}
-
-/** CrackOperations helper function. */
-export function crackOperations(operations: string[]): [string, string[]][] {
-  return operations.map(op => crackOperation(op))
-}

package/src/transaction/primitives/transactionRequiredGas.ts

@@ -1,22 +0,0 @@
-import type { HydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol-lib'
-import { AttoXL1, TransactionGasCosts } from '@xyo-network/xl1-protocol-lib'
-
-import { transactionBlockByteCount } from './transactionBlockByteCount.ts'
-import { transactionElevatedPayloads } from './transactionElevatedPayloads.ts'
-
-/** The required gas for the byte storage on the block chain for a transaction */
-export function transactionBytesRequiredGas([transaction, payloads]: HydratedTransactionWithHashMeta): AttoXL1 {
-  const transactionBlockBytes = transactionBlockByteCount([transaction, payloads])
-  return AttoXL1(TransactionGasCosts.characterStorage * BigInt(transactionBlockBytes))
-}
-
-/** TransactionRequiredGas helper function. */
-export function transactionRequiredGas(hydratedTransaction: HydratedTransactionWithHashMeta): AttoXL1 {
-  const elevatedPayloads = transactionElevatedPayloads(hydratedTransaction)
-  const hashes = elevatedPayloads.length + 1 /* for transaction itself */
-  const signatures = hydratedTransaction[0].addresses.length
-  return AttoXL1(transactionBytesRequiredGas(hydratedTransaction)
-    + TransactionGasCosts.hashValidation * BigInt(hashes)
-    + TransactionGasCosts.signatureValidation * BigInt(signatures)
-    + TransactionGasCosts.payloadValidation * BigInt(elevatedPayloads.length))
-}

package/src/transaction/script.ts

@@ -1,48 +0,0 @@
-import { asHash, type Hash } from '@xylabs/sdk-js'
-import { assertEx, filterAs } from '@xylabs/sdk-js'
-import type { WithHashMeta } from '@xyo-network/sdk-js'
-import { isHashMeta } from '@xyo-network/sdk-js'
-import type { AllowedBlockPayload, HydratedTransactionWithHashMeta } from '@xyo-network/xl1-protocol-lib'
-import { isAllowedBlockPayload } from '@xyo-network/xl1-protocol-lib'
-
-/** tryExtractElevatedHashesFromScript constant. */
-export const tryExtractElevatedHashesFromScript = (strings: string[]): Hash[] => {
-  const hashes = strings
-    .filter(str => str.startsWith('elevate|'))
-    .map(str => str.split('|')[1])
-  return filterAs(hashes, h => asHash(h))
-}
-
-/** extractElevatedHashesFromScript constant. */
-export const extractElevatedHashesFromScript = (strings: string[]): Hash[] => {
-  const hashes = strings
-    .filter(str => str.startsWith('elevate|'))
-    .map(str => str.split('|')[1])
-  const filtered = filterAs(hashes, h => asHash(h))
-  assertEx(filtered.length === hashes.length, () => 'Invalid elevated hashes')
-  return filtered
-}
-
-/** tryExtractElevatedHashes constant. */
-export const tryExtractElevatedHashes = (tx: HydratedTransactionWithHashMeta): WithHashMeta<AllowedBlockPayload>[] => {
-  const [bw, payloads] = tx
-  const { script } = bw
-  const hashes = script ? tryExtractElevatedHashesFromScript(script) : []
-  return payloads
-    .filter(p => hashes.includes(p._hash))
-    .filter(isAllowedBlockPayload)
-    .filter(isHashMeta)
-}
-
-/** extractElevatedHashes constant. */
-export const extractElevatedHashes = (tx: HydratedTransactionWithHashMeta): WithHashMeta<AllowedBlockPayload>[] => {
-  const [bw, payloads] = tx
-  const { script } = bw
-  const hashes = script ? tryExtractElevatedHashesFromScript(script) : []
-  const filtered = payloads
-    .filter(p => hashes.includes(p._hash))
-    .filter(isAllowedBlockPayload)
-    .filter(isHashMeta)
-  assertEx(filtered.length === hashes.length, () => 'Invalid elevated hashes')
-  return filtered
-}

package/src/transaction/signTransaction.ts

@@ -1,32 +0,0 @@
-import {
-  assertEx, hexFromArrayBuffer, toArrayBuffer,
-} from '@xylabs/sdk-js'
-import type { AccountInstance, Signed } from '@xyo-network/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { TransactionBoundWitness, UnsignedTransactionBoundWitness } from '@xyo-network/xl1-protocol-lib'
-
-/**
- * Signs an unsigned transaction with the provided account.
- * @param tx The transaction to sign
- * @param account The account to sign the transaction with
- * @returns The signed transaction
- */
-export async function signTransaction(tx: UnsignedTransactionBoundWitness, account: AccountInstance) {
-  assertEx(tx.from === account.address, () => 'Signer address does not match transaction from address')
-  // Clone tx to prevent modifying original
-  const unsignedTx = structuredClone(tx)
-  // Update dynamic fields based on account
-  unsignedTx.addresses = [account.address]
-  unsignedTx.previous_hashes = [account.previousHash ?? null]
-  // Calculate tx hash and sign it
-  const hash = await PayloadBuilder.dataHash(unsignedTx)
-  const hashBytes = toArrayBuffer(hash)
-  const [signature] = await account.sign(hashBytes)
-  // Append the signatures to the transaction
-  const result: Signed<TransactionBoundWitness> = {
-    ...unsignedTx,
-    $signatures: [hexFromArrayBuffer(signature)],
-  }
-  // Return the signed transaction
-  return result
-}

package/src/utils/HydratedCache.ts

@@ -1,39 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { BlockContextRead } from '@xyo-network/xl1-protocol-lib'
-import { LRUCache } from 'lru-cache'
-
-/** Function type for Hydrate operations. */
-export type HydrateFunction<T> = (
-  context: BlockContextRead,
-  hash: Hash,
-) => Promise<T | undefined>
-
-/** HydratedCache implementation. */
-export class HydratedCache<T extends {}> {
-  protected readonly cache: LRUCache<Hash, T>
-  protected context: BlockContextRead
-  protected readonly hydrateFunction: HydrateFunction<T>
-
-  constructor(
-    context: BlockContextRead,
-    hydrateFunction: HydrateFunction<T>,
-    maxCount: number = 2000,
-    ttl: number = Number.MAX_SAFE_INTEGER,
-  ) {
-    this.context = context
-    this.hydrateFunction = hydrateFunction
-    this.cache = new LRUCache<Hash, T>({ max: maxCount, ttl })
-  }
-
-  async get(hash: Hash): Promise<T | null> {
-    const existing = this.cache.get(hash)
-    if (existing !== undefined) return existing
-    const block = (await this.hydrateFunction(this.context, hash)) ?? null
-    if (block !== null) this.cache.set(hash, block)
-    return block
-  }
-
-  has(hash: Hash): boolean {
-    return this.cache.has(hash)
-  }
-}

package/src/utils/index.ts

@@ -1,2 +0,0 @@
-export * from './HydratedCache.ts'
-export * from './isZodError.ts'

package/src/utils/isZodError.ts

@@ -1,11 +0,0 @@
-import { z } from 'zod'
-
-/** Type guard that checks if a value is a valid ZodError. */
-export const isZodError = (error: unknown): error is z.ZodError => {
-  return error instanceof z.ZodError
-}
-
-/** prettifyZodError constant. */
-export const prettifyZodError = (error: z.ZodError): string => {
-  return z.prettifyError(error)
-}

package/src/validation/index.ts

@@ -1,2 +0,0 @@
-export * from './lib/index.ts'
-export * from './schema/index.ts'

package/src/validation/lib/getUrl.ts

@@ -1,7 +0,0 @@
-import { isLocalhost } from './isLocalhost.ts'
-
-/** getUrl constant. */
-export const getUrl = (host: string, port: number): string => {
-  const scheme = isLocalhost(host) ? 'http' : 'https'
-  return `${scheme}://${host}:${port}`
-}

package/src/validation/lib/index.ts

@@ -1,2 +0,0 @@
-export * from './getUrl.ts'
-export * from './isLocalhost.ts'

package/src/validation/lib/isLocalhost.ts

@@ -1,9 +0,0 @@
-/** Type guard that checks if a value is a valid Localhost. */
-export const isLocalhost = (hostname: string): boolean => {
-  return (
-    hostname === 'localhost'
-    || hostname === '127.0.0.1'
-    || hostname === '::1' // IPv6 localhost
-    || hostname.endsWith('.localhost')
-  )
-}

package/src/validation/schema/Address.ts

@@ -1,2 +0,0 @@
-/** TODO constant. */
-export const TODO = true

package/src/validation/schema/Mnemonic.ts

@@ -1,21 +0,0 @@
-import { z } from 'zod'
-
-/**
- * Validates a single string containing a BIP-39 mnemonic.
- *
- * • Trims leading/trailing whitespace.
- * • Collapses any run of whitespace (spaces, tabs, new-lines) to a single space.
- * • Splits on spaces → array of words.
- * • Checks that the word-count is 12, 15, 18, 21, or 24.
- *
- */
-export const MnemonicStringZod = z
-  .string()
-  .transform(s => s.trim().replaceAll(/\s+/g, ' ')) // normalize spacing
-  .refine(
-    s => [12, 15, 18, 21, 24].includes(s.split(' ').length),
-    { message: 'Mnemonic must contain 12, 15, 18, 21, or 24 words.' },
-  ).describe('BIP-39 mnemonic string')
-
-/** MnemonicString type. */
-export type MnemonicString = z.infer<typeof MnemonicStringZod>

package/src/validation/schema/index.ts

@@ -1,2 +0,0 @@
-export * from './Address.ts'
-export * from './Mnemonic.ts'

package/src/wallet/generateXyoBaseWalletFromPhrase.ts

@@ -1,13 +0,0 @@
-import { HDWallet } from '@xyo-network/sdk-js'
-
-import { DEFAULT_WALLET_PATH } from './paths.ts'
-
-/**
- * Initializes a wallet to the default XYO path from a mnemonic phrase
- * @param walletPhrase The mnemonic phrase for the wallet
- * @returns A wallet initialized to the default XYO path using the provided phrase
- */
-export const generateXyoBaseWalletFromPhrase = (walletPhrase: string) => {
-  const wallet = HDWallet.fromPhrase(walletPhrase, DEFAULT_WALLET_PATH)
-  return wallet
-}

package/src/wallet/index.ts

@@ -1,2 +0,0 @@
-export * from './generateXyoBaseWalletFromPhrase.ts'
-export * from './paths.ts'

package/src/wallet/paths.ts

@@ -1,17 +0,0 @@
-/** WALLET_COMPLIANCE constant. */
-export const WALLET_COMPLIANCE = '44\'' as const
-
-/** COIN_TYPES constant. */
-export const COIN_TYPES = { Ethereum: '60\'' } as const
-
-/** ACCOUNT_TYPE constant. */
-export const ACCOUNT_TYPE = { GANACHE: '0\'', XYO: '0\'' } as const
-
-/** CHANGE_ADDRESS constant. */
-export const CHANGE_ADDRESS = { META_MASK: '0', XYO: '0' } as const
-
-/** ADDRESS_INDEX constant. */
-export const ADDRESS_INDEX = { META_MASK: '0', XYO: '0' } as const
-
-/** DEFAULT_WALLET_PATH constant. */
-export const DEFAULT_WALLET_PATH = `m/${WALLET_COMPLIANCE}/${COIN_TYPES.Ethereum}/${ACCOUNT_TYPE.XYO}/${CHANGE_ADDRESS.XYO}`