@xyo-network/xl1-wrappers 1.26.12 → 1.26.14

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "http://json.schemastore.org/package.json",
   "name": "@xyo-network/xl1-wrappers",
-  "version": "1.26.12",
+  "version": "1.26.14",
   "description": "XYO Layer One SDK Wrappers",
   "homepage": "https://xylabs.com",
   "bugs": {
@@ -23,7 +23,6 @@
   "exports": {
     ".": {
       "types": "./dist/neutral/index.d.ts",
-      "source": "./src/index.ts",
       "default": "./dist/neutral/index.mjs"
     },
     "./package.json": "./package.json"
@@ -33,31 +32,40 @@
   "types": "./dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
     "!**/*.test.*",
     "README.md"
   ],
   "dependencies": {
-    "@xyo-network/xl1-protocol-lib": "~1.26.12",
-    "@xyo-network/xl1-protocol-sdk": "~1.26.12",
-    "@xyo-network/xl1-validation": "~1.26.12"
+    "@xyo-network/xl1-protocol-lib": "~1.26.14",
+    "@xyo-network/xl1-protocol-sdk": "~1.26.14",
+    "@xyo-network/xl1-validation": "~1.26.14"
   },
   "devDependencies": {
+    "@metamask/providers": "^22.1.1",
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/sdk-js": "^5.0.91",
-    "@xylabs/ts-scripts-common": "~7.6.2",
-    "@xylabs/ts-scripts-yarn3": "~7.6.2",
-    "@xylabs/tsconfig": "~7.6.2",
-    "@xyo-network/sdk-js": "^5.3.20",
+    "@xylabs/geo": "^5.0.93",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.18",
+    "@xylabs/ts-scripts-pnpm": "~7.6.18",
+    "@xylabs/tsconfig": "~7.6.18",
+    "@xyo-network/sdk-js": "^5.3.25",
+    "acorn": "^8.16.0",
     "ajv": "^8.18.0",
-    "axios": "^1.13.6",
+    "axios": "^1.14.0",
+    "esbuild": "^0.28.0",
     "ethers": "^6.16.0",
+    "firebase": "^12.11.0",
+    "lru-cache": "^11.2.7",
+    "mapbox-gl": "^3.21.0",
+    "mongodb": "^7.1.1",
+    "tslib": "^2.8.1",
     "typescript": "~5.9.3",
-    "vite": "^6.0.0 || ^7.0.0 || ^8.0.0",
+    "vite": "^8.0.3",
     "vitest": "~4.1.2",
+    "webextension-polyfill": "^0.12.0",
     "zod": "~4.3.6"
   },
   "peerDependencies": {
@@ -68,14 +76,13 @@
     "axios": "^1",
     "ethers": "^6",
     "mongodb": "^6 || ^7",
-    "typescript": ">=4.9.5",
     "zod": "^4"
   },
   "engines": {
-    "node": ">=22.3 <23"
+    "node": ">=22.3"
   },
   "engineStrict": true,
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/Address.ts

@@ -1,20 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-import { isAddress } from '@xylabs/sdk-js'
-import type { AddressInstance } from '@xyo-network/xl1-protocol-sdk'
-
-import { BaseWrapper } from './Base.ts'
-
-/** Wrapper around an Ethereum-style address with validation. */
-export class AddressWrapper extends BaseWrapper<Address> implements AddressInstance {
-  get address(): Address {
-    return this.value
-  }
-
-  static override validateValue(address: unknown): Promisable<Error[]> {
-    return isAddress(address) ? [] : [new Error('Invalid address')]
-  }
-
-  override async validate(): Promise<Error[]> {
-    return await AddressWrapper.validateValue(this.address)
-  }
-}

package/src/AddressState.ts

@@ -1,19 +0,0 @@
-import type { Promisable } from '@xylabs/sdk-js'
-import type { XL1AmountInstance } from '@xyo-network/xl1-protocol-lib'
-import type {
-  AddressStateInstance,
-  BlockWindowInstance,
-} from '@xyo-network/xl1-protocol-sdk'
-
-import { AddressWrapper } from './Address.ts'
-
-/** Wrapper for an address with associated block window and balance state. */
-export class AddressStateWrapper extends AddressWrapper implements AddressStateInstance {
-  get blockWindow(): BlockWindowInstance {
-    throw new Error('Method [blockWindow] not implemented.')
-  }
-
-  balance(): Promisable<[XL1AmountInstance, BlockWindowInstance]> {
-    throw new Error('Method [balance] not implemented.')
-  }
-}

package/src/Base.ts

@@ -1,44 +0,0 @@
-import type { PromisableArray } from '@xylabs/sdk-js'
-import type { XyoConnection } from '@xyo-network/xl1-protocol-lib'
-
-/** Configuration for a base wrapper, providing a connection and a value to wrap. */
-export interface BaseWrapperConfig<T> {
-  provider: XyoConnection
-  value: T
-}
-
-/** Abstract base class for protocol value wrappers with validation support. */
-export class BaseWrapper<T, C extends BaseWrapperConfig<T> = BaseWrapperConfig<T>> {
-  protected readonly config: Partial<C>
-  protected readonly value: T
-  protected constructor(value: T, config: Partial<C> = {}) {
-    this.config = config
-    this.value = value
-  }
-
-  get provider(): XyoConnection | undefined {
-    return this.config.provider
-  }
-
-  static async create<T, C extends BaseWrapperConfig<T> = BaseWrapperConfig<T>>(value: T, config: Partial<C> = {}) {
-    if ((await this.validateValue(value)).length > 0) {
-      throw new Error(`Invalid value for ${this.constructor.name}: ${value}`)
-    }
-    if ((await this.validateConfig(config)).length > 0) {
-      throw new Error(`Invalid config for ${this.constructor.name}: ${config}`)
-    }
-    return new this<T>(value, config)
-  }
-
-  static validateConfig(_config: unknown): PromisableArray<Error> {
-    return []
-  }
-
-  static validateValue(_value: unknown): PromisableArray<Error> {
-    return []
-  }
-
-  validate(): PromisableArray<Error> {
-    return []
-  }
-}

package/src/BlockWindow.ts

@@ -1,44 +0,0 @@
-import type { Hash, Promisable } from '@xylabs/sdk-js'
-import type { HydratedBlock } from '@xyo-network/xl1-protocol-lib'
-import type { BlockWindowInstance } from '@xyo-network/xl1-protocol-sdk'
-
-/** Navigable store of hydrated blocks within a block window range. */
-export interface HydratedBlockRangeStore extends BlockWindowInstance {
-  first(): Promisable<HydratedBlock>
-  fromHash(hash: Hash): Promisable<HydratedBlock>
-  fromNumber(number: number): Promisable<HydratedBlock>
-  last(): Promisable<HydratedBlock>
-  next(): Promisable<HydratedBlock>
-  next(count: number): Promisable<HydratedBlock[]>
-  prev(): Promisable<HydratedBlock>
-  prev(count: number): Promisable<HydratedBlock[]>
-}
-
-/** Wrapper that exposes block window properties from a HydratedBlockRangeStore. */
-export class BlockWindowWrapper implements BlockWindowInstance {
-  private _store: HydratedBlockRangeStore
-
-  constructor(store: HydratedBlockRangeStore) {
-    this._store = store
-  }
-
-  get count() {
-    return this._store.count
-  }
-
-  get numberRange() {
-    return this._store.numberRange
-  }
-
-  get range() {
-    return this._store.range
-  }
-
-  static validate(_store: HydratedBlockRangeStore): Promisable<Error[]> {
-    return [] // TODO: Implement validation logic
-  }
-
-  async validate(): Promise<Error[]> {
-    return await BlockWindowWrapper.validate(this._store)
-  }
-}

package/src/BlockWindowBalanceCache.ts

@@ -1,21 +0,0 @@
-import type { Address, Promisable } from '@xylabs/sdk-js'
-
-import type { HydratedBlockRangeStore } from './BlockWindow.ts'
-
-/** Interface for querying address balances within a block window. */
-export interface BlockWindowBalanceCacheInstance {
-  balance(address: Address): Promisable<bigint>
-}
-
-/** Cache for looking up account balances within a hydrated block range. */
-export class BlockWindowBalanceCache implements BlockWindowBalanceCacheInstance {
-  private _store: HydratedBlockRangeStore
-
-  constructor(store: HydratedBlockRangeStore) {
-    this._store = store
-  }
-
-  balance(_address: Address): Promisable<bigint> {
-    throw new Error('Method [balance] not implemented.')
-  }
-}

package/src/Fees.ts

@@ -1,55 +0,0 @@
-import type { Hex, Promisable } from '@xylabs/sdk-js'
-import { hexToBigInt } from '@xylabs/sdk-js'
-import type { TransactionFeesBigInt, TransactionFeesHex } from '@xyo-network/xl1-protocol-lib'
-import { AttoXL1 } from '@xyo-network/xl1-protocol-lib'
-import type { TransactionFeesInstance } from '@xyo-network/xl1-protocol-sdk'
-
-function parseHexOrBigInt(value: Hex | bigint) {
-  return AttoXL1((typeof value === 'bigint' ? value : hexToBigInt(value)))
-}
-
-/** Wrapper for transaction fee fields (base, gasLimit, gasPrice, priority) with validation. */
-export class FeesWrapper implements TransactionFeesInstance {
-  base: AttoXL1
-  gasLimit: AttoXL1
-  gasPrice: AttoXL1
-  priority: AttoXL1
-
-  constructor({
-    base, gasLimit, gasPrice, priority,
-  }: TransactionFeesHex | TransactionFeesBigInt) {
-    this.base = parseHexOrBigInt(base)
-    this.gasLimit = parseHexOrBigInt(gasLimit)
-    this.gasPrice = parseHexOrBigInt(gasPrice)
-    this.priority = parseHexOrBigInt(priority)
-  }
-
-  static validate({
-    base, gasLimit, gasPrice, priority,
-  }: TransactionFeesHex | TransactionFeesBigInt): Promisable<Error[]> {
-    const errors: Error[] = []
-    const baseValue = parseHexOrBigInt(base)
-    const gasLimitValue = parseHexOrBigInt(gasLimit)
-    const gasPriceValue = parseHexOrBigInt(gasPrice)
-    const priorityValue = parseHexOrBigInt(priority)
-    if (baseValue <= 0n) {
-      errors.push(new Error('Base fee cannot be negative or zero'))
-    }
-    if (gasLimitValue < 0n) {
-      errors.push(new Error('Gas limit cannot be negative'))
-    }
-    if (gasPriceValue < 0n) {
-      errors.push(new Error('Gas price cannot be negative'))
-    }
-    if (priorityValue < 0n) {
-      errors.push(new Error('Priority cannot be negative'))
-    }
-    return errors
-  }
-
-  async validate(): Promise<Error[]> {
-    return await FeesWrapper.validate({
-      base: this.base, gasLimit: this.gasLimit, gasPrice: this.gasPrice, priority: this.priority,
-    })
-  }
-}

package/src/Signature.ts

@@ -1,27 +0,0 @@
-import type {
-  Address, Hash, Hex,
-} from '@xylabs/sdk-js'
-import { toArrayBuffer } from '@xylabs/sdk-js'
-import { BoundWitnessValidator } from '@xyo-network/sdk-js'
-import type { SignatureInstance } from '@xyo-network/xl1-protocol-sdk'
-
-/** Wrapper for cryptographic signatures with validation against BoundWitness hashes. */
-export class SignatureWrapper implements SignatureInstance {
-  address: Address
-  hash: Hash
-  signature: Hex
-
-  constructor(signature: Hex, address: Address, hash: Hash) {
-    this.signature = signature
-    this.address = address
-    this.hash = hash
-  }
-
-  static async validate(hash: Hash, address: Address, signature: Hex): Promise<Error[]> {
-    return await BoundWitnessValidator.validateSignature(toArrayBuffer(hash), toArrayBuffer(address), toArrayBuffer(signature))
-  }
-
-  async validate(): Promise<Error[]> {
-    return await SignatureWrapper.validate(this.hash, this.address, this.signature)
-  }
-}

package/src/chain/chain.ts

@@ -1,11 +0,0 @@
-import type { Address } from '@xylabs/sdk-js'
-
-import type { BaseWrapperConfig } from '../Base.ts'
-import { BaseWrapper } from '../Base.ts'
-
-/** Wrapper for a chain identifier address. */
-export class ChainWrapper extends BaseWrapper<Address, BaseWrapperConfig<Address>> {
-  get id(): Address {
-    return this.value
-  }
-}

package/src/chain/index.ts

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

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './Base.ts'
-export * from './chain/index.ts'
-export * from './Fees.ts'
-export * from './lib/index.ts'
-export * from './Signature.ts'
-export * from './transaction/index.ts'

package/src/lib/createSignatureWrappers.ts

@@ -1,18 +0,0 @@
-import { asHex } from '@xylabs/sdk-js'
-import type { BoundWitness } from '@xyo-network/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { SignatureInstance } from '@xyo-network/xl1-protocol-sdk'
-
-import { SignatureWrapper } from '../Signature.ts'
-
-/** Creates SignatureWrapper instances for each signature in a BoundWitness. */
-export const createSignatureWrappers = async (bw: BoundWitness): Promise<SignatureInstance[]> => {
-  const signatures: SignatureInstance[] = []
-  const hash = await PayloadBuilder.dataHash(bw)
-  for (let i = 0; i < bw.$signatures.length; i++) {
-    signatures.push(
-      new SignatureWrapper(asHex(bw.$signatures[i], true), bw.addresses[i], hash),
-    )
-  }
-  return signatures
-}

package/src/lib/index.ts

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

package/src/transaction/HydratedTransaction.ts

@@ -1,177 +0,0 @@
-import type { Hash, Hex } from '@xylabs/sdk-js'
-import { hexToBigInt, isDefined } from '@xylabs/sdk-js'
-import type {
-  Payload, Schema,
-  WithHashMeta,
-} from '@xyo-network/sdk-js'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type {
-  AllowedBlockPayload, BaseContext, HydratedTransactionWithHashMeta, Transfer,
-} from '@xyo-network/xl1-protocol-lib'
-import {
-  isAllowedBlockPayload, isTransfer, XYO_ZERO_ADDRESS,
-} from '@xyo-network/xl1-protocol-lib'
-import type {
-  HydratedTransactionInstance, SignatureInstance,
-  TransactionFeesInstance,
-} from '@xyo-network/xl1-protocol-sdk'
-import {
-  transactionRequiredGas, tryExtractElevatedHashes, tryExtractElevatedHashesFromScript,
-} from '@xyo-network/xl1-protocol-sdk'
-import { validateTransaction } from '@xyo-network/xl1-validation'
-
-import { FeesWrapper } from '../Fees.ts'
-import { createSignatureWrappers } from '../lib/index.ts'
-
-const sumTransfers = (payload: Transfer) => {
-  let total = 0n
-  for (let i of Object.values(payload.transfers)) {
-    total += hexToBigInt(i ?? '00' as Hex)
-  }
-  return total
-}
-
-/** Context for hydrated transaction wrapper operations. */
-export interface HydratedTransactionWrapperContext extends BaseContext {
-
-}
-
-/** Wrapper for a hydrated transaction providing access to payloads, signatures, fees, and validation. */
-export class HydratedTransactionWrapper<T extends HydratedTransactionWithHashMeta> implements HydratedTransactionInstance<T> {
-  data: T
-  fees: TransactionFeesInstance
-
-  protected context: HydratedTransactionWrapperContext
-  protected payloadsCache: WithHashMeta<AllowedBlockPayload & T[1][number]>[] = []
-
-  private _signatureCache: SignatureInstance[] = []
-
-  protected constructor(data: T, context?: HydratedTransactionWrapperContext) {
-    this.context = context ?? { singletons: {} }
-    this.data = data
-    this.fees = new FeesWrapper(
-      this.boundWitness.fees,
-    )
-  }
-
-  get boundWitness(): T[0] {
-    return this.data[0]
-  }
-
-  get elevatedPayloadCount(): number {
-    const { script } = this.data[0]
-    return script ? tryExtractElevatedHashesFromScript(script).length : 0
-  }
-
-  get elevatedPayloads() {
-    return tryExtractElevatedHashes(this.data) as WithHashMeta<AllowedBlockPayload & T[1][number]>[]
-  }
-
-  get externalPayloads(): Record<Hash, Schema | Payload> {
-    const allPayloads = this.payloads
-    const external: Record<Hash, Schema | Payload> = {}
-    for (let i = 0; i < this.boundWitness.payload_hashes.length; i++) {
-      const payloadHash = this.boundWitness.payload_hashes[i]
-      const payload = allPayloads.find(p => p._hash === payloadHash)
-      external[payloadHash] = isDefined(payload) ? payload : this.boundWitness.payload_schemas[i]
-    }
-    return external
-  }
-
-  get from() {
-    return this.data[0].from
-  }
-
-  get payloadCount(): number {
-    return this.payloadsCache.length
-  }
-
-  get payloads(): WithHashMeta<WithHashMeta<T[1][number]>>[] {
-    return [...this.payloadsCache]
-  }
-
-  get privateExternalPayloads(): Record<Hash, Schema> {
-    const allPayloads = this.payloads
-    const missing: Record<Hash, Schema> = {}
-    for (let i = 0; i < this.boundWitness.payload_hashes.length; i++) {
-      const payloadHash = this.boundWitness.payload_hashes[i]
-      if (!allPayloads.some(p => p._hash === payloadHash)) {
-        missing[payloadHash] = this.boundWitness.payload_schemas[i]
-      }
-    }
-    return missing
-  }
-
-  // list all the payloads that are included in the transaction and are not elevated and found in the hydration
-  get publicExternalPayloads(): Payload[] {
-    const allPayloads = this.payloads
-    const elevatedPayloads = this.elevatedPayloads
-    return allPayloads.filter(p => !elevatedPayloads.some(ep => ep._hash === p._hash))
-  }
-
-  get signatureCount(): number {
-    return this._signatureCache.length
-  }
-
-  get signatures(): SignatureInstance[] {
-    return [...this._signatureCache]
-  }
-
-  static async parse<T extends HydratedTransactionWithHashMeta>(transaction: T, validate = false): Promise<HydratedTransactionInstance<[T[0],
-    T[1][number][]]>> {
-    const wrapper = new HydratedTransactionWrapper<T>(
-      transaction,
-    )
-    const parsed = await wrapper.parse()
-    if (validate) {
-      const errors = await wrapper.validate()
-      if (errors.length > 0) {
-        throw new Error(`Block validation failed: ${errors.join(', ')}`)
-      }
-    }
-    return parsed
-  }
-
-  elevatedPayload(index: number): WithHashMeta<AllowedBlockPayload & T[1][number]> | undefined {
-    return this.elevatedPayloads.at(index)
-  }
-
-  gasRequired(): bigint {
-    return transactionRequiredGas(this.data)
-  }
-
-  payload(index: number) {
-    return this.payloads.at(index) as WithHashMeta<AllowedBlockPayload & T[1][number]>
-  }
-
-  reward(): bigint {
-    return this.payloadsCache.reduce((acc: bigint, payload) => acc + (
-      isTransfer(payload)
-        ? payload.from === XYO_ZERO_ADDRESS
-          ? sumTransfers(payload)
-          : 0n
-        : 0n), 0n)
-  }
-
-  signature(index: number): SignatureInstance | undefined {
-    return this._signatureCache[index]
-  }
-
-  async validate(): Promise<Error[]> {
-    const errors: Error[] = [...(await Promise.all(this._signatureCache.map(signature => signature.validate()))).flat(),
-      ...(await validateTransaction({ ...this.context, chainId: this.data[0].chain }, this.data))]
-    return errors
-  }
-
-  protected async parse(validate = false): Promise<HydratedTransactionInstance<[WithHashMeta<T[0]>, WithHashMeta<T[1][number]>[]]>> {
-    const transactionPayloads = (await PayloadBuilder.addHashMeta(this.data[1])).filter(isAllowedBlockPayload)
-    this._signatureCache = await createSignatureWrappers(this.data[0])
-    for (const payload of transactionPayloads) {
-      this.payloadsCache.push(payload)
-    }
-    if (validate) {
-      await this.validate()
-    }
-    return this
-  }
-}

package/src/transaction/index.ts

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