WIP

Signed-off-by: 0x009922 <43530070+0x009922@users.noreply.github.com>

Author: 0x009922

packages/client/src/blocks-stream.ts

@@ -1,6 +1,6 @@
 import type Emittery from 'emittery'
 import Debug from 'debug'
-import { datamodel } from '@iroha2/data-model'
+import { codecOf, types } from '@iroha2/data-model'
 import { ENDPOINT_BLOCKS_STREAM } from './const'
 import type { SocketEmitMapBase } from './util'
 import { setupWebSocket } from './util'
@@ -11,11 +11,11 @@ const debug = Debug('@iroha2/client:blocks-stream')
 export interface SetupBlocksStreamParams {
   toriiURL: string
   adapter: IsomorphicWebSocketAdapter
-  fromBlockHeight?: datamodel.NonZero<datamodel.U64>
+  fromBlockHeight?: types.NonZero<types.U64>
 }
 
 export interface BlocksStreamEmitteryMap extends SocketEmitMapBase {
-  block: datamodel.SignedBlock
+  block: types.SignedBlock
 }
 
 export interface SetupBlocksStreamReturn {
@@ -40,14 +40,14 @@ export async function setupBlocksStream(params: SetupBlocksStreamParams): Promis
 
   ee.on('open', () => {
     sendRaw(
-      datamodel.BlockSubscriptionRequest$codec.encode({
-        fromBlockHeight: params.fromBlockHeight ?? datamodel.NonZero$schema(datamodel.U64$schema).parse(1n),
+      codecOf(types.BlockSubscriptionRequest).encode({
+        fromBlockHeight: params.fromBlockHeight ?? types.NonZero.parse(1n),
       }),
     )
   })
 
   ee.on('message', (raw) => {
-    const block = datamodel.SignedBlock$codec.decode(raw)
+    const block = codecOf(types.SignedBlock).decode(raw)
     ee.emit('block', block)
   })
 

packages/client/src/events.ts

@@ -1,4 +1,4 @@
-import { datamodel } from '@iroha2/data-model'
+import { codecOf, types } from '@iroha2/data-model'
 import type Emittery from 'emittery'
 import Debug from 'debug'
 import type { SocketEmitMapBase } from './util'
@@ -9,13 +9,13 @@ import type { IsomorphicWebSocketAdapter } from './web-socket/types'
 const debug = Debug('@iroha2/client:events')
 
 export interface EventsEmitteryMap extends SocketEmitMapBase {
-  event: datamodel.EventBox
+  event: types.EventBox
 }
 
 export interface SetupEventsParams {
   toriiURL: string
   adapter: IsomorphicWebSocketAdapter
-  filters?: datamodel.EventFilterBox[]
+  filters?: types.EventFilterBox[]
 }
 
 export interface SetupEventsReturn {
@@ -42,11 +42,11 @@ export async function setupEvents(params: SetupEventsParams): Promise<SetupEvent
   })
 
   ee.on('open', () => {
-    sendRaw(datamodel.EventSubscriptionRequest$codec.encode({ filters: params.filters ?? [] }))
+    sendRaw(codecOf(types.EventSubscriptionRequest).encode({ filters: params.filters ?? [] }))
   })
 
   ee.on('message', (raw) => {
-    const event = datamodel.EventBox$codec.decode(raw)
+    const event = codecOf(types.EventBox).decode(raw)
     ee.emit('event', event)
   })
 

packages/client/src/lib.ts

@@ -10,10 +10,9 @@
  */
 
 import type { KeyPair } from '@iroha2/crypto-core'
-import { datamodel, signTransaction, transactionHash } from '@iroha2/data-model'
-import { type Schema as DataModelSchema } from '@iroha2/data-model-schema'
+import { types, signTransaction, transactionHash, codecOf } from '@iroha2/data-model'
+import type { Schema as DataModelSchema } from '@iroha2/data-model-schema'
 import defer from 'p-defer'
-import type { z } from 'zod'
 
 import type { Except, RequiredKeysOf } from 'type-fest'
 import type { SetupBlocksStreamParams } from './blocks-stream'
@@ -30,22 +29,22 @@ import {
 import type { SetupEventsParams } from './events'
 import { setupEvents } from './events'
 import type { IsomorphicWebSocketAdapter } from './web-socket/types'
-import { type QueryOutput, type QueryPayload, doRequest } from './query'
+import { type QueryOutput, type QueryParams, doRequest } from './query'
 
 type Fetch = typeof fetch
 
 export interface SetPeerConfigParams {
   logger: {
-    level: datamodel.LogLevel
+    level: types.LogLevel
   }
 }
 
 export interface CreateClientParams {
   http: Fetch
   ws: IsomorphicWebSocketAdapter
   toriiURL: string
-  chain: z.input<typeof datamodel.ChainId$schema>
-  accountDomain: z.input<typeof datamodel.DomainId$schema>
+  chain: types.ChainId
+  accountDomain: types.DomainId
   accountKeyPair: KeyPair
 }
 
@@ -56,7 +55,7 @@ export interface SubmitParams {
    */
   verify?: boolean
   verifyAbort?: AbortSignal
-  payload?: Except<z.input<typeof datamodel.TransactionPayload$schema>, 'chain' | 'authority' | 'instructions'>
+  payload?: Except<types.TransactionPayload, 'chain' | 'authority' | 'instructions'>
 }
 
 export class ResponseError extends Error {
@@ -76,9 +75,9 @@ export class ResponseError extends Error {
 }
 
 export class TransactionRejectedError extends Error {
-  public reason: datamodel.TransactionRejectionReason
+  public reason: types.TransactionRejectionReason
 
-  public constructor(reason: datamodel.TransactionRejectionReason) {
+  public constructor(reason: types.TransactionRejectionReason) {
     // TODO: parse reason into a specific message
     super('Transaction rejected')
     this.reason = reason
@@ -92,55 +91,55 @@ export class TransactionExpiredError extends Error {
 }
 
 export class QueryValidationError extends Error {
-  public reason: datamodel.ValidationFail
+  public reason: types.ValidationFail
 
-  public constructor(reason: datamodel.ValidationFail) {
+  public constructor(reason: types.ValidationFail) {
     super('Query validation failed')
     this.reason = reason
   }
 }
 
 export class Client {
   public params: CreateClientParams
+
   // public readonly signer: Signer
 
   public constructor(params: CreateClientParams) {
     this.params = params
   }
 
-  public accountId(): datamodel.AccountId {
-    return datamodel.AccountId.parse({
-      domain: this.params.accountDomain,
-      signatory: this.params.accountKeyPair.publicKey(),
-    })
+  public accountId(): types.AccountId {
+    return new types.AccountId(
+      types.PublicKeyWrap.fromCrypto(this.params.accountKeyPair.publicKey()),
+      this.params.accountDomain,
+    )
   }
 
-  public async submit(instructions: z.input<typeof datamodel.Executable$schema>, params?: SubmitParams) {
-    const payload = datamodel.TransactionPayload({
+  public async submit(executable: types.Executable, params?: SubmitParams) {
+    const payload: types.TransactionPayload = {
       chain: this.params.chain,
       authority: this.accountId(),
-      instructions,
+      instructions: executable,
+      creationTime: types.Timestamp.fromDate(new Date()),
+      timeToLive: types.NonZero.parse(100_000n as types.Duration),
+      nonce: null,
+      metadata: new Map(),
       ...params?.payload,
-    })
+    }
     const tx = signTransaction(payload, this.params.accountKeyPair.privateKey())
 
     if (params?.verify) {
-      const hash = transactionHash(tx).payload()
+      const hash = transactionHash(tx)
       const stream = await this.eventsStream({
         filters: [
-          // TODO: include "status" when Iroha API is fixed about it
-          datamodel.EventFilterBox({
-            t: 'Pipeline',
-            value: {
-              t: 'Transaction',
-              value: {
-                // FIXME: fix data model, allow `null | Hash`
-                hash: { Some: hash },
-                // FIXME: Iroha design issue
-                //   If I want to filter by "rejected" status, I will also have to include a rejection reason into the
-                //   filter. I could imagine users wanting to just watch for rejections with all possible reasons.
-              },
-            },
+          types.EventFilterBox.Pipeline.Transaction({
+            hash: types.HashWrap.fromCrypto(hash),
+            blockHeight: null,
+            // TODO: include "status" when Iroha API is fixed about it
+            // FIXME: Iroha design issue
+            //   If I want to filter by "rejected" status, I will also have to include a rejection reason into the
+            //   filter. I could imagine users wanting to just watch for rejections with all possible reasons.
+            status: null,
           }),
         ],
       })
@@ -179,6 +178,10 @@ export class Client {
     }
   }
 
+  public query<Q extends types.QueryBox>(query: Q): AsyncGenerator<types.QueryOutputMap[Q['kind']]> {}
+
+  public querySingular<Q extends types.SingularQueryBox>(query: Q): Promise<types.SingularQueryOutputMap[Q['kind']]> {}
+
   // TODO: split to `query` and `querySingle`, make simpler types
   /**
    * Request data from Iroha using Query API.
@@ -214,10 +217,9 @@ export class Client {
    *
    * This function is a shortcut to {@link doRequest} with an addition of data stored in the client, i.e. {@link import('./query.ts').RequestBaseParams}.
    */
-  public request<
-    Q extends keyof datamodel.QueryOutputMap | keyof datamodel.SingularQueryOutputMap,
-    P extends QueryPayload<Q>,
-  >(...args: RequiredKeysOf<P> extends never ? [query: Q, params?: P] : [query: Q, params: P]): QueryOutput<Q> {
+  public request<Q extends keyof types.QueryOutputMap | keyof types.SingularQueryOutputMap, P extends QueryParams<Q>>(
+    ...args: RequiredKeysOf<P> extends never ? [query: Q, params?: P] : [query: Q, params: P]
+  ): QueryOutput<Q> {
     return doRequest(args[0], {
       ...args[1],
       authority: this.accountId(),
@@ -246,7 +248,7 @@ export class Client {
     })
   }
 
-  public async getStatus(): Promise<datamodel.Status> {
+  public async getStatus(): Promise<types.Status> {
     return getStatus(this.toriiRequestRequirements)
   }
 
@@ -271,6 +273,24 @@ export class Client {
   }
 }
 
+declare const client: Client
+
+client.query(types.QueryBox.FindAccounts({ predicate: types.CompoundPredicate.PASS, query: null }))
+client.query(
+  types.QueryBox.FindAccountsWithAsset({
+    query: {
+      assetDefinition: types.AssetDefinitionId.parse('rose#badland'),
+    },
+    predicate: types.CompoundPredicate.Atom(types.AccountPredicateBox.Id.DomainId.Name.EndsWith('land')),
+  }),
+)
+client.querySingular(
+  types.SingularQueryBox.FindDomainMetadata({
+    id: types.DomainId.parse('badland'),
+    key: types.Name.parse('badboy'),
+  }),
+)
+
 export interface ToriiHttpParams {
   http: Fetch
   toriiURL: string
@@ -296,12 +316,12 @@ export async function getHealth({ http, toriiURL }: ToriiHttpParams): Promise<He
   return { t: 'ok' }
 }
 
-export async function getStatus({ http, toriiURL }: ToriiHttpParams): Promise<datamodel.Status> {
+export async function getStatus({ http, toriiURL }: ToriiHttpParams): Promise<types.Status> {
   const response = await http(toriiURL + ENDPOINT_STATUS, {
     headers: { accept: 'application/x-parity-scale' },
   })
   await ResponseError.assertStatus(response, 200)
-  return response.arrayBuffer().then((buffer) => datamodel.Status$codec.decode(new Uint8Array(buffer)))
+  return response.arrayBuffer().then((buffer) => types.Status$codec.decode(new Uint8Array(buffer)))
 }
 
 export async function getMetrics({ http, toriiURL }: ToriiHttpParams) {
@@ -321,8 +341,8 @@ export async function setPeerConfig({ http, toriiURL }: ToriiHttpParams, params:
   await ResponseError.assertStatus(response, 202 /* ACCEPTED */)
 }
 
-export async function submitTransaction({ http, toriiURL }: ToriiHttpParams, tx: datamodel.SignedTransaction) {
-  const body = datamodel.SignedTransaction$codec.encode(tx)
+export async function submitTransaction({ http, toriiURL }: ToriiHttpParams, tx: types.SignedTransaction) {
+  const body = codecOf(types.SignedTransaction).encode(tx)
   const response = await http(toriiURL + ENDPOINT_TRANSACTION, { body, method: 'POST' })
   await ResponseError.assertStatus(response, 200)
 }