@xyo-network/xl1-rpc 1.7.11 → 1.7.13

package/src/provider/host/spec/MemoryXyoGateway.spec.ts

@@ -0,0 +1,78 @@
+import { Account } from '@xyo-network/account'
+import type { AccountInstance } from '@xyo-network/account-model'
+import {
+  beforeEach, describe, expect, it,
+} from 'vitest'
+
+import { RpcXyoConnection } from '../../provider/index.ts'
+import { MemoryXyoSigner } from '../../signer/index.ts'
+import { MemoryXyoGateway } from '../MemoryXyoGateway.ts'
+import { MemoryPermissionsStore } from '../PermissionsStore/index.ts'
+
+describe('MemoryXyoGateway', () => {
+  const endpoint = 'http://localhost:8080/rpc'
+  const dataLakeEndpoint = 'http://localhost:8080/chain/archivist'
+  let account: AccountInstance
+  let signer: MemoryXyoSigner
+  let store: MemoryPermissionsStore
+  let sut: MemoryXyoGateway
+
+  beforeEach(async () => {
+    account = await Account.random()
+    signer = new MemoryXyoSigner(account)
+
+    store = new MemoryPermissionsStore()
+    sut = new MemoryXyoGateway(signer, store)
+  })
+
+  describe('addConnection', () => {
+    describe('should return the added', () => {
+      it('with config', async () => {
+        const config = {
+          name: 'localhost', dataLakeEndpoint, networkEndpoint: endpoint,
+        }
+        const response = await sut.addConnection(config)
+        expect(response).toBeDefined()
+      })
+      it('with connection', async () => {
+        const connection = new RpcXyoConnection({ endpoint, account })
+        const response = await sut.addConnection('localhost', connection)
+        expect(response).toBeDefined()
+        expect(response).toBe(connection)
+      })
+    })
+  })
+
+  describe('activeConnection', () => {
+    describe('with no connections', () => {
+      it('should have no active connection', () => {
+        expect(sut.activeConnection()).toBeUndefined()
+      })
+    })
+    describe('with connections', () => {
+      it('should return the active connection', async () => {
+        const connection = new RpcXyoConnection({ endpoint, account })
+        await sut.addConnection('localhost', connection)
+        expect(sut.activeConnection()).toBeDefined()
+      })
+    })
+  })
+
+  describe('connections', () => {
+    describe('with connections', () => {
+      const name = 'localhost'
+      let connection: RpcXyoConnection
+      beforeEach(async () => {
+        connection = new RpcXyoConnection({ endpoint, account })
+        await sut.addConnection(name, connection)
+      })
+      it('should return connections', async () => {
+        const response = await sut.connections()
+        expect(response).toBeDefined()
+        expect(response).toHaveProperty(name)
+        expect(Object.keys(response)).toHaveLength(1)
+        expect(response[name]).toBe(connection)
+      })
+    })
+  })
+})

package/src/provider/provider/XyoConnection.ts

@@ -1,30 +1,35 @@
 import { assertEx } from '@xylabs/assert'
 import type { Address } from '@xylabs/hex'
 import type { Signed } from '@xyo-network/boundwitness-model'
+import { HydratedTransactionWrapper } from '@xyo-network/chain-wrappers'
 import { PayloadBuilder } from '@xyo-network/payload-builder'
-import type { Payload } from '@xyo-network/payload-model'
+import { isAnyPayload, type Payload } from '@xyo-network/payload-model'
 import type {
   AllowedBlockPayload,
   HydratedTransaction,
-  TransactionBoundWitness, TransactionFeesBigInt, XyoConnectionProvider, XyoNetwork, XyoRunner, XyoSigner, XyoViewer,
+  TransactionBoundWitness, TransactionFeesBigInt,
+  TransactionSubmitterOptions, XyoConnectionProvider, XyoDataLakeProvider, XyoDataLakeViewer, XyoNetwork, XyoRunner, XyoSigner, XyoViewer,
 } from '@xyo-network/xl1-protocol'
-import { defaultTransactionFees } from '@xyo-network/xl1-protocol'
+import { defaultTransactionFees, isDataLakeProvider } from '@xyo-network/xl1-protocol'
 
 export class XyoConnection implements XyoConnectionProvider {
   private readonly _network?: XyoNetwork
   private readonly _runner?: XyoRunner
   private readonly _signer?: XyoSigner
+  private readonly _storage?: XyoDataLakeProvider | XyoDataLakeViewer
   private readonly _viewer?: XyoViewer
 
   constructor(params?: {
     network?: XyoNetwork
     runner?: XyoRunner
     signer?: XyoSigner
+    storage?: XyoDataLakeProvider | XyoDataLakeViewer
     viewer?: XyoViewer
   }) {
     this._network = params?.network
     this._runner = params?.runner
     this._signer = params?.signer
+    this._storage = params?.storage
     this._viewer = params?.viewer
   }
 
@@ -40,6 +45,10 @@ export class XyoConnection implements XyoConnectionProvider {
     return this._signer
   }
 
+  get storage(): XyoDataLakeProvider | XyoDataLakeViewer | undefined {
+    return this._storage
+  }
+
   get viewer(): XyoViewer | undefined {
     return this._viewer
   }
@@ -64,17 +73,12 @@ export class XyoConnection implements XyoConnectionProvider {
     additionalPayloads: Payload[],
     {
       chain, exp, fees, from, nbf,
-    }: {
-      chain?: Address
-      exp?: number
-      fees?: TransactionFeesBigInt
-      from?: Address
-      nbf?: number
-    } = {},
+    }: TransactionSubmitterOptions = {},
   ): Promise<HydratedTransaction> {
     const viewer = assertEx(this.viewer, () => 'No viewer available')
     const signer = assertEx(this.signer, () => 'No signer available')
     const runner = assertEx(this.runner, () => 'No runner available')
+    const storage = this.storage
     const chainResolved = chain ?? await viewer.chainId()
     if (chainResolved === undefined) throw new Error('Failed to determine chain')
     const nbfResolved = Math.max(await viewer.currentBlockNumber() ?? 0, nbf ?? 0)
@@ -94,6 +98,12 @@ export class XyoConnection implements XyoConnectionProvider {
     const hydratedTransaction: HydratedTransaction = [await PayloadBuilder.addStorageMeta(signedTransaction),
       await PayloadBuilder.addStorageMeta(elevatedPayloads)]
 
+    // if storage configured, add the external payloads to it
+    if (isDataLakeProvider(storage)) {
+      const wrapper = await HydratedTransactionWrapper.parse(hydratedTransaction)
+      await storage.add(Object.values(wrapper.externalPayloads).filter(isAnyPayload))
+    }
+
     assertEx(await runner.broadcastTransaction(hydratedTransaction), () => 'Failed to broadcast transaction')
 
     return hydratedTransaction

package/src/provider/signer/JsonRpcXyoSigner.ts

@@ -1,5 +1,6 @@
 import { type Address } from '@xylabs/hex'
-import type { Signed } from '@xyo-network/boundwitness-model'
+import type { Promisable } from '@xylabs/promise'
+import type { Signed, UnsignedBoundWitness } from '@xyo-network/boundwitness-model'
 import type { Payload } from '@xyo-network/payload-model'
 import type {
   AllowedBlockPayload,
@@ -10,7 +11,8 @@ import type {
 
 import type { RpcTransport } from '../../transport/index.ts'
 import type { XyoSignerRpcSchemas } from '../../types/index.ts'
-export class JsonRpcXyoSigner implements XyoSigner {
+
+export class RpcXyoSigner implements XyoSigner {
   protected readonly transport: RpcTransport<typeof XyoSignerRpcSchemas>
 
   constructor(transport: RpcTransport<typeof XyoSignerRpcSchemas>) {
@@ -40,4 +42,13 @@ export class JsonRpcXyoSigner implements XyoSigner {
       from,
     ])
   }
+
+  signTransaction(tx: [UnsignedBoundWitness<TransactionBoundWitness>, Payload[]]): Promisable<[Signed<TransactionBoundWitness>, Payload[]]> {
+    throw new Error('Method not implemented.')
+  }
 }
+
+/**
+ * @deprecated Use `RpcXyoSigner` instead.
+ */
+export class JsonRpcXyoSigner extends RpcXyoSigner {}

package/src/provider/signer/MemoryXyoSigner.ts

@@ -1,6 +1,7 @@
 import type { Address } from '@xylabs/hex'
+import type { Promisable } from '@xylabs/promise'
 import type { AccountInstance } from '@xyo-network/account-model'
-import type { Signed } from '@xyo-network/boundwitness-model'
+import type { Signed, UnsignedBoundWitness } from '@xyo-network/boundwitness-model'
 import { type Payload } from '@xyo-network/payload-model'
 import type {
   AllowedBlockPayload, TransactionBoundWitness, TransactionFeesBigInt, XyoSigner,
@@ -40,4 +41,8 @@ export class MemoryXyoSigner implements XyoSigner {
     )
     return transaction[0]
   }
+
+  signTransaction(_tx: [UnsignedBoundWitness<TransactionBoundWitness>, Payload[]]): Promisable<[Signed<TransactionBoundWitness>, Payload[]]> {
+    throw new Error('Method not implemented.')
+  }
 }

package/src/provider/signer/spec/RpcEngineXyoSigner.spec.ts

@@ -10,7 +10,7 @@ import {
 import { rpcEngineFromProvider } from '../../../engine/index-node.ts'
 import { MemoryRpcTransport } from '../../../transport/index.ts'
 import { XyoConnection } from '../../provider/index.ts'
-import { JsonRpcXyoSigner } from '../JsonRpcXyoSigner.ts'
+import { RpcXyoSigner } from '../JsonRpcXyoSigner.ts'
 import { MemoryXyoSigner } from '../MemoryXyoSigner.ts'
 
 describe('RpcEngine - XyoSigner', () => {
@@ -22,7 +22,7 @@ describe('RpcEngine - XyoSigner', () => {
     const provider = new XyoConnection({ signer })
     const engine = rpcEngineFromProvider(provider)
     const transport = new MemoryRpcTransport(engine)
-    sut = new JsonRpcXyoSigner(transport)
+    sut = new RpcXyoSigner(transport)
   })
   describe('address', () => {
     it('should return signer addresses', async () => {

package/src/transport/HttpRpcTransport.ts

@@ -2,7 +2,8 @@ import type {
   JsonRpcFailure, JsonRpcRequest, JsonRpcSuccess,
 } from '@metamask/utils'
 import { AxiosJson } from '@xylabs/axios'
-import { isUndefinedOrNull } from '@xylabs/typeof'
+import { isError, isUndefinedOrNull } from '@xylabs/typeof'
+import { isAxiosError } from 'axios'
 import { v4 } from 'uuid'
 import type { z } from 'zod'
 
@@ -37,24 +38,32 @@ export class HttpRpcTransport<T extends RpcSchemaMap = RpcSchemaMap> implements
     method: TMethod,
     params?: z.infer<TSchemas[TMethod]['params']['to']>,
   ): Promise<z.infer<TSchemas[TMethod]['result']['from']>> {
-    const id = v4()
-    const body: JsonRpcRequest = {
-      jsonrpc,
-      id,
-      method: method as string,
-    }
+    try {
+      const id = v4()
+      const body: JsonRpcRequest = {
+        jsonrpc,
+        id,
+        method: method as string,
+      }
 
-    if (params) {
-      body.params = schemas[method].params.to.parse(params)
-    }
+      if (params) {
+        body.params = schemas[method].params.to.parse(params)
+      }
 
-    const res = await new AxiosJson().post(url, body)
+      const res = await new AxiosJson().post(url, body)
 
-    const json = res.data
-    if (isUndefinedOrNull(json) || (json as Partial<JsonRpcFailure>).error) {
-      throw new Error((json as JsonRpcFailure).error.message)
-    }
+      const json = res.data
+      if (isUndefinedOrNull(json) || (json as Partial<JsonRpcFailure>).error) {
+        throw new Error((json as JsonRpcFailure).error.message)
+      }
 
-    return schemas[method].result.from.parse((json as JsonRpcSuccess).result)
+      return schemas[method].result.from.parse((json as JsonRpcSuccess).result)
+    } catch (ex) {
+      let message = isError(ex) ? ex.message : String(ex)
+      if (isAxiosError(ex)) {
+        message = `Http error occurred [${ex.status}|${ex.code ?? '<unknown>'}]: ${ex.message}`
+      }
+      throw new Error(`Error occurred while calling RPC method ${String(method)}: ${message}`)
+    }
   }
 }

package/src/types/schema/XyoSignerRpcSchemas.ts

@@ -2,7 +2,10 @@ import { z } from 'zod'
 
 import type { XyoSignerRpcMethodName } from '../XyoSignerRpc.ts'
 import {
-  AddressFromStringSchema, AddressToStringSchema, PayloadSchema, SignedTransactionBoundWitnessSchema, TransactionFeesFromStingSchema,
+  AddressFromStringSchema, AddressToStringSchema,
+  HydratedTransactionSchema,
+  PayloadSchema, SignedHydratedTransactionSchema, SignedTransactionBoundWitnessSchema,
+  TransactionFeesFromStingSchema,
   TransactionFeesToStingSchema,
 } from './common/index.ts'
 import type { RpcSchemaMap } from './RpcSchemaMap.ts'
@@ -44,4 +47,14 @@ export const XyoSignerRpcSchemas: RpcSchemaMap<XyoSignerRpcMethodName> = {
       from: SignedTransactionBoundWitnessSchema,
     },
   },
+  xyoSigner_signTransaction: {
+    params: {
+      to: z.tuple([HydratedTransactionSchema]),
+      from: z.tuple([HydratedTransactionSchema]),
+    },
+    result: {
+      to: SignedHydratedTransactionSchema,
+      from: SignedHydratedTransactionSchema,
+    },
+  },
 }