@xyo-network/xl1-protocol-sdk 1.16.1 → 1.16.2

package/src/simple/gateway/SimpleXyoGatewayRunner.ts

@@ -0,0 +1,116 @@
+import { assertEx } from '@xylabs/assert'
+import type {
+  Address, Hash, Hex,
+} from '@xylabs/hex'
+import { BigIntToJsonZod } from '@xylabs/hex'
+import { isDefined } from '@xylabs/typeof'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { Payload, WithHashMeta } from '@xyo-network/payload-model'
+import {
+  type AllowedBlockPayload,
+  type AttoXL1,
+  type SignedHydratedTransaction,
+  type SignedHydratedTransactionWithHashMeta,
+  type Transfer,
+  TransferSchema,
+} from '@xyo-network/xl1-protocol'
+
+import type {
+  DataLakeRunner,
+  TransactionOptions,
+  XyoConnection, XyoGateway, XyoGatewayRunner,
+  XyoSigner,
+} from '../../provider/index.ts'
+import { buildUnsignedTransaction } from '../../transaction/index.ts'
+
+export class SimpleXyoGatewayRunner implements XyoGatewayRunner {
+  protected readonly gateway: XyoGateway
+  private _dataLakes: (DataLakeRunner | null)[]
+
+  constructor(gateway: XyoGateway, dataLakes: DataLakeRunner[] = []) {
+    this.gateway = gateway
+    this._dataLakes = [...dataLakes]
+  }
+
+  get connection(): XyoConnection {
+    return this.gateway.connection
+  }
+
+  get dataLakes(): DataLakeRunner[] {
+    throw new Error('Method not implemented.')
+  }
+
+  get signer(): XyoSigner {
+    return this.gateway.signer
+  }
+
+  addDataLake(dataLake: DataLakeRunner): number {
+    this._dataLakes.push(dataLake)
+    return this._dataLakes.length - 1
+  }
+
+  async addPayloadsToChain(
+    onChain: AllowedBlockPayload[],
+    offChain: Payload[],
+    options?: TransactionOptions,
+  ): Promise<[Hash, SignedHydratedTransactionWithHashMeta]> {
+    // Get chain providers
+    const viewer = assertEx(this.connection.viewer, () => 'No viewer available on connection')
+
+    // Resolve transaction options
+    const {
+      nbf, exp, chain, fees,
+    } = options ?? {}
+    const resolvedChainId = isDefined(chain) ? chain : await viewer.chainId()
+    const resolvedNbf = isDefined(nbf) ? nbf : await viewer?.currentBlockNumber()
+    const resolvedExp = isDefined(exp) ? exp : resolvedNbf + 10
+
+    // Build, sign, and broadcast the transaction
+    const tx = await buildUnsignedTransaction(resolvedChainId, onChain, offChain, resolvedNbf, resolvedExp, await this.signer.address(), fees)
+    return await this.addTransactionToChain(tx)
+  }
+
+  async addTransactionToChain(tx: SignedHydratedTransaction): Promise<[Hash, SignedHydratedTransactionWithHashMeta]> {
+    const connection = this.gateway.connection
+    const signer = this.gateway.signer
+    const runner = assertEx(connection.runner, () => 'No runner available on connection')
+    const signedTx = await signer.signTransaction(tx)
+    await this.addPayloadsToDataLakes(signedTx[1])
+    return [await runner.broadcastTransaction(
+      [await PayloadBuilder.addStorageMeta(signedTx[0]),
+        await PayloadBuilder.addStorageMeta(signedTx[1])],
+    ), signedTx]
+  }
+
+  removeDataLake(index: number): void {
+    this._dataLakes[index] = null
+  }
+
+  async send(to: Address, amount: AttoXL1, options?: TransactionOptions): Promise<Hash> {
+    return await this.sendMany({ [to]: amount }, options)
+  }
+
+  async sendMany(transfers: Record<Address, AttoXL1>, options?: TransactionOptions): Promise<Hash> {
+    const from = await this.signer.address()
+    const hexTransfers: Record<Address, Hex> = Object.fromEntries(
+      Object.entries(transfers).map(([address, amount]) => ([
+        address, BigIntToJsonZod.parse(amount),
+      ])),
+    )
+    const transfer = new PayloadBuilder<Transfer>({ schema: TransferSchema }).fields({
+      from,
+      transfers: hexTransfers,
+      epoch: Date.now(),
+    }).build()
+    const [hash] = await this.addPayloadsToChain([transfer], [], options)
+    return hash
+  }
+
+  protected async addPayloadsToDataLakes(payloads: WithHashMeta<Payload>[]): Promise<void> {
+    await Promise.all(this._dataLakes.map(async (dataLake) => {
+      await Promise.all(payloads.map(async (payload) => {
+        await dataLake?.set(payload._hash, payload)
+      }))
+    }))
+  }
+}

package/src/simple/gateway/index.ts

@@ -0,0 +1,2 @@
+export * from './SimpleXyoGateway.ts'
+export * from './SimpleXyoGatewayRunner.ts'

package/src/simple/index.ts

@@ -0,0 +1,7 @@
+export * from './client/index.ts'
+export * from './datalake/index.ts'
+export * from './gateway/index.ts'
+export * from './network/index.ts'
+export * from './permissions/index.ts'
+export * from './runner/index.ts'
+export * from './signer/index.ts'

package/src/simple/network/SimpleXyoNetwork.ts

@@ -0,0 +1,48 @@
+import { isUndefined } from '@xylabs/typeof'
+import type {
+  GatewayName,
+  NetworkStatus,
+} from '@xyo-network/xl1-protocol'
+import { isNetworkStatus } from '@xyo-network/xl1-protocol'
+import axios from 'axios'
+
+import type { XyoNetwork } from '../../provider/index.ts'
+import {
+  errorStatus, StatusNetworks, unknownStatus,
+} from './lib/index.ts'
+
+export class SimpleXyoNetwork implements XyoNetwork {
+  protected readonly _networkId: GatewayName
+
+  constructor(networkId: GatewayName) {
+    this._networkId = networkId
+  }
+
+  async status(): Promise<NetworkStatus> {
+    const statusNetwork = StatusNetworks[this._networkId]
+    if (isUndefined(statusNetwork)) {
+      throw new Error(`Unknown status network ID: ${this._networkId}`)
+    }
+
+    return await this.makeRequest(statusNetwork.statusUrl)
+  }
+
+  private async makeRequest(url: string): Promise<NetworkStatus> {
+    try {
+      const response = await axios.get(url)
+      if (isNetworkStatus(response.data)) {
+        return response.data
+      } else {
+        if (response.status === 200) {
+          console.error('Unknown network status response:', response.data)
+
+          return unknownStatus
+        }
+        return errorStatus
+      }
+    } catch (error) {
+      console.error('Error fetching network status:', error)
+      return errorStatus
+    }
+  }
+}

package/src/simple/network/index.ts

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

package/src/simple/network/lib/FailedNetworkStatusPayloads.ts

@@ -0,0 +1,14 @@
+import type { NetworkStatus } from '@xyo-network/xl1-protocol'
+import { NetworkStatusSchema } from '@xyo-network/xl1-protocol'
+
+export const unknownStatus: NetworkStatus = {
+  description: 'Unknown Network Status',
+  schema: NetworkStatusSchema,
+  state: 'unknown',
+}
+
+export const errorStatus: NetworkStatus = {
+  description: 'Error Fetching Network Status',
+  schema: NetworkStatusSchema,
+  state: 'unknown',
+}

package/src/simple/network/lib/StatusNetworks.ts

@@ -0,0 +1,27 @@
+import type { GatewayName } from '@xyo-network/xl1-protocol'
+
+export type StatusNetwork = {
+  id: GatewayName
+  statusUrl: string
+}
+
+export const MainNetworkStats: StatusNetwork = {
+  id: 'mainnet' as GatewayName,
+  statusUrl: 'https://xyo.network/chain-network-status-mainnet.json',
+}
+
+export const SequenceNetworkStats: StatusNetwork = {
+  id: 'sequence' as GatewayName,
+  statusUrl: 'https://beta.xyo.network/chain-network-status-sequence.json',
+}
+
+export const LocalNetworkStats: StatusNetwork = {
+  id: 'local' as GatewayName,
+  statusUrl: 'http://localhost:3002/chain-network-status-local.json',
+}
+
+export const StatusNetworks: Record<GatewayName, StatusNetwork> = {
+  ['mainnet' as GatewayName]: MainNetworkStats,
+  ['sequence' as GatewayName]: SequenceNetworkStats,
+  ['local' as GatewayName]: LocalNetworkStats,
+}

package/src/simple/network/lib/index.ts

@@ -0,0 +1,2 @@
+export * from './FailedNetworkStatusPayloads.ts'
+export * from './StatusNetworks.ts'

package/src/simple/network/spec/XyoNetwork.spec.ts

@@ -0,0 +1,77 @@
+import type { NetworkId } from '@xyo-network/xl1-protocol'
+import { NetworkStatusSchema } from '@xyo-network/xl1-protocol'
+import axios from 'axios'
+import type { Mocked } from 'vitest'
+import {
+  beforeEach, describe, expect, it, vitest,
+} from 'vitest'
+
+import {
+  errorStatus, StatusNetworks, unknownStatus,
+} from '../lib/index.ts'
+import { SimpleXyoNetwork } from '../SimpleXyoNetwork.ts'
+
+vitest.mock('axios')
+const mockedAxios = axios as Mocked<typeof axios>
+
+describe('SimpleXyoNetwork', () => {
+  const mockNetworkStatus = {
+    description: 'Mock Network Status',
+    schema: NetworkStatusSchema,
+    state: 'active',
+  }
+
+  const networks = Object.values(StatusNetworks)
+
+  beforeEach(() => {
+    vitest.clearAllMocks()
+  })
+
+  for (const { id, statusUrl } of networks) {
+    it(`should fetch the ${id} status successfully`, async () => {
+      mockedAxios.get.mockResolvedValueOnce({ data: mockNetworkStatus })
+
+      const network = new SimpleXyoNetwork(id)
+      const status = await network.status()
+
+      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
+      expect(status).toEqual(mockNetworkStatus)
+    })
+
+    it(`should return unknownStatus for invalid response data on ${id}`, async () => {
+      mockedAxios.get.mockResolvedValueOnce({ data: { invalid: 'data' }, status: 200 })
+
+      const network = new SimpleXyoNetwork(id)
+      const status = await network.status()
+
+      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
+      expect(status).toEqual(unknownStatus)
+    })
+
+    it(`should return errorStatus for non-200 response on ${id}`, async () => {
+      mockedAxios.get.mockResolvedValueOnce({ data: {}, status: 500 })
+
+      const network = new SimpleXyoNetwork(id)
+      const status = await network.status()
+
+      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
+      expect(status).toEqual(errorStatus)
+    })
+
+    it(`should return errorStatus for network errors on ${id}`, async () => {
+      mockedAxios.get.mockRejectedValueOnce(new Error('Network error'))
+
+      const network = new SimpleXyoNetwork(id)
+      const status = await network.status()
+
+      expect(mockedAxios.get).toHaveBeenCalledWith(statusUrl)
+      expect(status).toEqual(errorStatus)
+    })
+  }
+
+  it('should throw an error for unknown network ID', async () => {
+    const network = new SimpleXyoNetwork('invalid' as unknown as NetworkId)
+
+    await expect(network.status()).rejects.toThrow('Unknown status network ID: invalid')
+  })
+})

package/src/simple/permissions/SimpleXyoPermissions.ts

@@ -0,0 +1,82 @@
+import { assertEx } from '@xylabs/assert'
+
+import type {
+  CaveatTypes,
+  InvokerPermission, PermissionRequest, RequestedPermission, XyoPermissions,
+} from '../../provider/index.ts'
+import type { Invoker, PermissionsStore } from './store/index.ts'
+
+/**
+ * In-memory implementation of XyoPermissions for testing or ephemeral use cases.
+ * Does not persist data beyond the lifetime of the instance.
+ * Assumes all permission requests are granted and revocations always succeed.
+ */
+export class SimpleXyoPermissions implements XyoPermissions {
+  invoker: Invoker
+  private _store: PermissionsStore
+
+  constructor(store: PermissionsStore) {
+    this._store = store
+    this.invoker = store.invoker
+  }
+
+  get store(): PermissionsStore {
+    return assertEx(this._store, () => 'Store must be defined to get permissions')
+  }
+
+  async getPermissions(): Promise<InvokerPermission[]> {
+    return await this.store.getPermissions()
+  }
+
+  // assumed the permissions are always granted
+  async requestPermissions(permissions: PermissionRequest[]): Promise<RequestedPermission[]> {
+    await Promise.resolve()
+    // Flatten PermissionRequest[] into InvokerPermission[]
+    const newPermissions: InvokerPermission[] = []
+    const now = Date.now()
+    for (const req of permissions) {
+      for (const parentCapability in req) {
+        newPermissions.push({
+          invoker: this.invoker,
+          parentCapability,
+          caveats: Object.entries(req[parentCapability]).map(([type, value]) => ({ type: type as CaveatTypes, value })),
+          date: now,
+        })
+      }
+    }
+
+    // Update or add permissions in the store
+    const existingPermissions = await this.getPermissions()
+    for (const perm of newPermissions) {
+      const idx = existingPermissions.findIndex(
+        p => p.invoker === perm.invoker && p.parentCapability === perm.parentCapability,
+      )
+      if (idx === -1) {
+        existingPermissions.push(perm)
+      } else {
+        existingPermissions[idx] = perm
+      }
+    }
+    await this.store.setPermissions(existingPermissions)
+
+    // Return the granted permissions in RequestedPermission shape
+    return newPermissions.map(({ parentCapability, date }) => ({ parentCapability, date }))
+  }
+
+  // Assumes the permissions are always revoked
+  async revokePermissions(permissions: PermissionRequest): Promise<RequestedPermission[]> {
+    const existingPermissions = await this.getPermissions()
+    const revoked: RequestedPermission[] = []
+    for (const parentCapability in permissions) {
+      const idx = existingPermissions.findIndex(
+        p => p.invoker === this.invoker && p.parentCapability === parentCapability,
+      )
+      if (idx !== -1) {
+        const removed = existingPermissions.splice(idx, 1)[0]
+        revoked.push({ parentCapability: removed.parentCapability, date: removed.date })
+      }
+    }
+    await this.store.setPermissions(existingPermissions)
+    return revoked
+  }
+}

package/src/simple/permissions/index.ts

@@ -0,0 +1,2 @@
+export * from './SimpleXyoPermissions.ts'
+export * from './store/index.ts'

package/src/simple/permissions/spec/SimpleXyoPermissions.spec.ts

@@ -0,0 +1,93 @@
+import {
+  beforeEach, describe, expect, it,
+} from 'vitest'
+
+import type { PermissionRequest } from '../../../provider/index.ts'
+import { SimpleXyoPermissions } from '../SimpleXyoPermissions.ts'
+import { MemoryPermissionsStore } from '../store/index.ts'
+
+describe('MemoryXyoPermissions', () => {
+  const invoker = 'https://example.com'
+  const parentCapability = 'xyoViewer_chainId'
+  let memoryPermissions: SimpleXyoPermissions
+
+  // Helper to build PermissionRequest
+  const buildPermissionRequest = (cap: string, caveats: Record<string, unknown> = {}) =>
+    ({ [cap]: caveats }) as PermissionRequest
+
+  beforeEach(() => {
+    memoryPermissions = new SimpleXyoPermissions(new MemoryPermissionsStore(invoker))
+  })
+
+  it('returns an empty list initially', async () => {
+    const permissions = await memoryPermissions.getPermissions()
+    expect(permissions).toEqual([])
+  })
+
+  it('adds and retrieves a permission', async () => {
+    const req = buildPermissionRequest(parentCapability)
+    const result = await memoryPermissions.requestPermissions([req])
+    expect(Array.isArray(result)).toBe(true)
+    expect(result.length).toBe(1)
+    expect(result[0].parentCapability).toBe(parentCapability)
+    expect(typeof result[0].date).toBe('number')
+
+    const permissions = await memoryPermissions.getPermissions()
+    expect(permissions.length).toBe(1)
+    expect(permissions[0].parentCapability).toBe(parentCapability)
+    expect(permissions[0].invoker).toBe(invoker)
+    expect(typeof permissions[0].date).toBe('number')
+  })
+
+  it('replaces an existing permission with the same key', async () => {
+    const req = buildPermissionRequest(parentCapability)
+    await memoryPermissions.requestPermissions([req])
+    const originalDate = (await memoryPermissions.getPermissions())[0].date
+
+    await new Promise(r => setTimeout(r, 5)) // ensure timestamp difference
+    await memoryPermissions.requestPermissions([req])
+    const updatedDate = (await memoryPermissions.getPermissions())[0].date
+
+    expect(updatedDate).toBeGreaterThan(originalDate!)
+  })
+
+  it('revokes a previously granted permission', async () => {
+    const req = buildPermissionRequest(parentCapability)
+    await memoryPermissions.requestPermissions([req])
+    expect((await memoryPermissions.getPermissions()).length).toBe(1)
+
+    const result = await memoryPermissions.revokePermissions(req)
+    expect(Array.isArray(result)).toBe(true)
+    expect(result.length).toBe(1)
+    expect(result[0].parentCapability).toBe(parentCapability)
+
+    const permissions = await memoryPermissions.getPermissions()
+    expect(permissions).toEqual([])
+  })
+
+  it('revoking a non-existent permission does nothing and returns empty array', async () => {
+    const req = buildPermissionRequest(parentCapability)
+    const result = await memoryPermissions.revokePermissions(req)
+    expect(result).toEqual([])
+    expect(await memoryPermissions.getPermissions()).toEqual([])
+  })
+
+  it('can handle multiple permissions from different invokers', async () => {
+    const memoryPermissionsA = new SimpleXyoPermissions(new MemoryPermissionsStore('https://a.com'))
+    const memoryPermissionsB = new SimpleXyoPermissions(new MemoryPermissionsStore('https://b.com'))
+    const reqA1 = buildPermissionRequest('xyo_1')
+    const reqA2 = buildPermissionRequest('xyo_3')
+    const reqB = buildPermissionRequest('xyo_2')
+
+    await memoryPermissionsA.requestPermissions([reqA1, reqA2])
+    await memoryPermissionsB.requestPermissions([reqB])
+
+    const resultsA = await memoryPermissionsA.getPermissions()
+    const resultsB = await memoryPermissionsB.getPermissions()
+
+    expect(resultsA.length).toBe(2)
+    expect(resultsB.length).toBe(1)
+    expect(resultsA.map(p => p.parentCapability).toSorted((a, b) => a.localeCompare(b))).toEqual(['xyo_1', 'xyo_3'])
+    expect(resultsB[0].parentCapability).toBe('xyo_2')
+  })
+})

package/src/simple/permissions/store/MemoryPermissions.ts

@@ -0,0 +1,32 @@
+import { assertEx } from '@xylabs/assert'
+
+import type { InvokerPermission } from '../../../provider/index.ts'
+import type { Invoker, PermissionsStore } from './PermissionsStore.ts'
+
+/**
+ * In-memory implementation of XyoPermissions for testing or ephemeral use cases.
+ * Does not persist data beyond the lifetime of the instance.
+ * Assumes all permission requests are granted and revocations always succeed.
+ */
+export class MemoryPermissionsStore implements PermissionsStore {
+  private _invoker: Invoker
+  private permissions: InvokerPermission[] = []
+
+  constructor(invoker: Invoker) {
+    this._invoker = invoker
+  }
+
+  get invoker(): Invoker {
+    return assertEx(this._invoker, () => 'Invoker must be defined to get permissions')
+  }
+
+  async getPermissions(): Promise<InvokerPermission[]> {
+    await Promise.resolve()
+    return this.permissions
+  }
+
+  async setPermissions(permissions: InvokerPermission[]): Promise<void> {
+    await Promise.resolve()
+    this.permissions = permissions
+  }
+}

package/src/simple/permissions/store/PermissionsStore.ts

@@ -0,0 +1,15 @@
+import type { InvokerPermission, PermissionsGetHandler } from '../../../provider/index.ts'
+
+export type Invoker = string
+export type ParentCapability = string
+/**
+ * Interface for a permissions store that abstracts away the storage medium.
+ * (i.e. in-memory, browser storage, database, etc.)
+ */
+export interface PermissionsStore extends PermissionsGetHandler {
+  // The invoker associated with this permissions store
+  readonly invoker: Invoker
+  // Retrieve all permissions associated with the invoker.
+  // Store or update permissions for the invoker
+  setPermissions(permissions: InvokerPermission[]): Promise<void>
+}

package/src/simple/permissions/store/index.ts

@@ -0,0 +1,2 @@
+export * from './MemoryPermissions.ts'
+export * from './PermissionsStore.ts'

package/src/simple/runner/SimpleXyoRunner.ts

@@ -0,0 +1,29 @@
+import type { Hash } from '@xylabs/hex'
+import { MemoryArchivist } from '@xyo-network/archivist-memory'
+import type { ArchivistInstance } from '@xyo-network/archivist-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import type { SignedHydratedTransactionWithStorageMeta } from '@xyo-network/xl1-protocol'
+
+import type { XyoRunner } from '../../provider/index.ts'
+import { flattenHydratedTransaction } from '../../transaction/index.ts'
+
+export class SimpleXyoRunner implements XyoRunner {
+  private _mempoolArchivist?: ArchivistInstance
+
+  constructor(mempoolArchivist?: ArchivistInstance) {
+    this._mempoolArchivist = mempoolArchivist
+  }
+
+  async broadcastTransaction(transaction: SignedHydratedTransactionWithStorageMeta): Promise<Hash> {
+    const archivist = await this.getMempoolArchivist()
+    await archivist.insert(flattenHydratedTransaction(transaction))
+    return await PayloadBuilder.hash(transaction[0])
+  }
+
+  protected async getMempoolArchivist(): Promise<ArchivistInstance> {
+    if (!this._mempoolArchivist) {
+      this._mempoolArchivist = await MemoryArchivist.create({ account: 'random' })
+    }
+    return this._mempoolArchivist
+  }
+}

package/src/simple/runner/index.ts

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

package/src/simple/signer/SimpleXyoSigner.ts

@@ -0,0 +1,52 @@
+import type { Address } from '@xylabs/hex'
+import type { Promisable } from '@xylabs/promise'
+import type { AccountInstance } from '@xyo-network/account-model'
+import type { Signed, UnsignedBoundWitness } from '@xyo-network/boundwitness-model'
+import { PayloadBuilder } from '@xyo-network/payload-builder'
+import { type Payload } from '@xyo-network/payload-model'
+import type {
+  AllowedBlockPayload, ChainId, SignedHydratedTransactionWithHashMeta, TransactionBoundWitness, TransactionFeesBigInt,
+} from '@xyo-network/xl1-protocol'
+
+import type { XyoSigner } from '../../provider/index.ts'
+import { buildTransaction, signTransaction } from '../../transaction/index.ts'
+
+export class SimpleXyoSigner implements XyoSigner {
+  protected readonly _account: AccountInstance
+
+  constructor(account: AccountInstance) {
+    this._account = account
+  }
+
+  address(): Promisable<Address> {
+    return this._account.address
+  }
+
+  async createSignedTransaction(
+    chain: ChainId,
+    elevatedPayloads: AllowedBlockPayload[],
+    additionalPayloads: Payload[],
+    nbf: number,
+    exp: number,
+    fees: TransactionFeesBigInt,
+    from?: Address,
+  ): Promise<Signed<TransactionBoundWitness>> {
+    const fromAddress = from ?? this._account.address
+    const transaction = await buildTransaction(
+      chain,
+      elevatedPayloads,
+      additionalPayloads,
+      this._account,
+      nbf,
+      exp,
+      fromAddress,
+      fees,
+    )
+    return transaction[0]
+  }
+
+  async signTransaction(tx: [UnsignedBoundWitness<TransactionBoundWitness>, Payload[]]): Promise<SignedHydratedTransactionWithHashMeta> {
+    const txBW = await signTransaction(tx[0], this._account)
+    return [await PayloadBuilder.addStorageMeta(txBW), await PayloadBuilder.addStorageMeta(tx[1])]
+  }
+}

package/src/simple/signer/index.ts

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

package/dist/neutral/provider/XyoGatewayHelpers.d.ts

@@ -1,16 +0,0 @@
-import type { Address, Hash, Hex } from '@xylabs/hex';
-import type { Promisable } from '@xylabs/promise';
-import type { Payload } from '@xyo-network/payload-model';
-import type { AllowedBlockPayload, TransactionBoundWitness, TransactionFeesBigInt } from '@xyo-network/xl1-protocol';
-export interface TransactionOptions {
-    chain?: Hex;
-    exp?: number;
-    fees?: TransactionFeesBigInt;
-    from?: Address;
-    nbf?: number;
-}
-export interface XyoGatewayHelpers {
-    addPayloadsToChain(onChain: AllowedBlockPayload[], offChain: Payload[], options?: TransactionOptions): Promisable<[Hash, [TransactionBoundWitness, Payload[]]]>;
-    addTransactionToChain(tx: [TransactionBoundWitness, Payload[]]): Promisable<Hash>;
-}
-//# sourceMappingURL=XyoGatewayHelpers.d.ts.map

package/dist/neutral/provider/XyoGatewayHelpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XyoGatewayHelpers.d.ts","sourceRoot":"","sources":["../../../src/provider/XyoGatewayHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAAE,IAAI,EAAE,GAAG,EACnB,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,KAAK,EACV,mBAAmB,EAAE,uBAAuB,EAAE,qBAAqB,EACpE,MAAM,2BAA2B,CAAA;AAElC,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,GAAG,CAAA;IACX,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,qBAAqB,CAAA;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,iBAAiB;IAEhC,kBAAkB,CAChB,OAAO,EAAE,mBAAmB,EAAE,EAC9B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC,uBAAuB,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,CAAA;IAE3D,qBAAqB,CACnB,EAAE,EAAE,CAAC,uBAAuB,EAAE,OAAO,EAAE,CAAC,GACvC,UAAU,CAAC,IAAI,CAAC,CAAA;CAEpB"}

package/dist/neutral/provider/XyoSigner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"XyoSigner.d.ts","sourceRoot":"","sources":["../../../src/provider/XyoSigner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAA;AACnF,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,KAAK,EACV,mBAAmB,EAAE,OAAO,EAAE,uBAAuB,EACrD,qBAAqB,EACtB,MAAM,2BAA2B,CAAA;AAElC,MAAM,WAAW,SAAS;IACxB,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,CAAA;IAI9B,eAAe,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAC,uBAAuB,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,MAAM,CAAC,uBAAuB,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAA;CAC1I;AAED,MAAM,WAAW,mBAAmB;IAClC,8CAA8C;IAC9C,uBAAuB,CACrB,KAAK,EAAE,OAAO,EACd,gBAAgB,EAAE,mBAAmB,EAAE,EACvC,kBAAkB,EAAE,OAAO,EAAE,EAC7B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,qBAAqB,EAC3B,IAAI,CAAC,EAAE,OAAO,GACb,UAAU,CAAC,MAAM,CAAC,uBAAuB,CAAC,CAAC,CAAA;CAC/C"}