@effectstream/db 0.100.0

package/src/sql/block-heights.queries.ts

@@ -0,0 +1,205 @@
+/** Types generated for queries found in "src/sql/block-heights.sql" */
+import { PreparedQuery } from '@pgtyped/runtime';
+
+import type { Buffer } from 'node:buffer';
+
+export type DateOrString = Date | string;
+
+/** 'GetLatestProcessedBlockHeight' parameters type */
+export type IGetLatestProcessedBlockHeightParams = void;
+
+/** 'GetLatestProcessedBlockHeight' return type */
+export interface IGetLatestProcessedBlockHeightResult {
+  block_height: number;
+  effectstream_block_hash: Buffer | null;
+  main_chain_block_hash: Buffer;
+  ms_timestamp: Date;
+  seed: string;
+  ver: number;
+}
+
+/** 'GetLatestProcessedBlockHeight' query type */
+export interface IGetLatestProcessedBlockHeightQuery {
+  params: IGetLatestProcessedBlockHeightParams;
+  result: IGetLatestProcessedBlockHeightResult;
+}
+
+const getLatestProcessedBlockHeightIR: any = {"usedParamSet":{},"params":[],"statement":"SELECT * FROM effectstream.effectstream_blocks\nWHERE effectstream_block_hash IS NOT NULL\nORDER BY block_height DESC\nLIMIT 1"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT * FROM effectstream.effectstream_blocks
+ * WHERE effectstream_block_hash IS NOT NULL
+ * ORDER BY block_height DESC
+ * LIMIT 1
+ * ```
+ */
+export const getLatestProcessedBlockHeight = new PreparedQuery<IGetLatestProcessedBlockHeightParams,IGetLatestProcessedBlockHeightResult>(getLatestProcessedBlockHeightIR);
+
+
+/** 'GetBlockSeeds' parameters type */
+export type IGetBlockSeedsParams = void;
+
+/** 'GetBlockSeeds' return type */
+export interface IGetBlockSeedsResult {
+  seed: string;
+}
+
+/** 'GetBlockSeeds' query type */
+export interface IGetBlockSeedsQuery {
+  params: IGetBlockSeedsParams;
+  result: IGetBlockSeedsResult;
+}
+
+const getBlockSeedsIR: any = {"usedParamSet":{},"params":[],"statement":"SELECT seed FROM effectstream.effectstream_blocks\nWHERE effectstream_block_hash IS NOT NULL\nORDER BY block_height DESC\nLIMIT 25"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT seed FROM effectstream.effectstream_blocks
+ * WHERE effectstream_block_hash IS NOT NULL
+ * ORDER BY block_height DESC
+ * LIMIT 25
+ * ```
+ */
+export const getBlockSeeds = new PreparedQuery<IGetBlockSeedsParams,IGetBlockSeedsResult>(getBlockSeedsIR);
+
+
+/** 'GetBlockHeights' parameters type */
+export interface IGetBlockHeightsParams {
+  block_heights: readonly (number)[];
+}
+
+/** 'GetBlockHeights' return type */
+export interface IGetBlockHeightsResult {
+  block_height: number;
+  effectstream_block_hash: Buffer | null;
+  main_chain_block_hash: Buffer;
+  ms_timestamp: Date;
+  seed: string;
+  ver: number;
+}
+
+/** 'GetBlockHeights' query type */
+export interface IGetBlockHeightsQuery {
+  params: IGetBlockHeightsParams;
+  result: IGetBlockHeightsResult;
+}
+
+const getBlockHeightsIR: any = {"usedParamSet":{"block_heights":true},"params":[{"name":"block_heights","required":true,"transform":{"type":"array_spread"},"locs":[{"a":70,"b":84}]}],"statement":"SELECT * FROM effectstream.effectstream_blocks \nWHERE block_height IN :block_heights!\nORDER BY block_height ASC"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT * FROM effectstream.effectstream_blocks 
+ * WHERE block_height IN :block_heights!
+ * ORDER BY block_height ASC
+ * ```
+ */
+export const getBlockHeights = new PreparedQuery<IGetBlockHeightsParams,IGetBlockHeightsResult>(getBlockHeightsIR);
+
+
+/** 'GetBlockByHash' parameters type */
+export interface IGetBlockByHashParams {
+  block_hash: Buffer;
+}
+
+/** 'GetBlockByHash' return type */
+export interface IGetBlockByHashResult {
+  block_height: number;
+  effectstream_block_hash: Buffer | null;
+  main_chain_block_hash: Buffer;
+  ms_timestamp: Date;
+  prev_block: Buffer | null;
+  seed: string;
+  ver: number;
+}
+
+/** 'GetBlockByHash' query type */
+export interface IGetBlockByHashQuery {
+  params: IGetBlockByHashParams;
+  result: IGetBlockByHashResult;
+}
+
+const getBlockByHashIR: any = {"usedParamSet":{"block_hash":true},"params":[{"name":"block_hash","required":true,"transform":{"type":"scalar"},"locs":[{"a":233,"b":244},{"a":278,"b":289}]}],"statement":"SELECT curr.*, prev.effectstream_block_hash as \"prev_block\"\nFROM effectstream.effectstream_blocks curr\nLEFT JOIN effectstream.effectstream_blocks prev ON prev.block_height = curr.block_height - 1\nWHERE curr.effectstream_block_hash = :block_hash! OR curr.main_chain_block_hash = :block_hash!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT curr.*, prev.effectstream_block_hash as "prev_block"
+ * FROM effectstream.effectstream_blocks curr
+ * LEFT JOIN effectstream.effectstream_blocks prev ON prev.block_height = curr.block_height - 1
+ * WHERE curr.effectstream_block_hash = :block_hash! OR curr.main_chain_block_hash = :block_hash!
+ * ```
+ */
+export const getBlockByHash = new PreparedQuery<IGetBlockByHashParams,IGetBlockByHashResult>(getBlockByHashIR);
+
+
+/** 'SaveLastBlock' parameters type */
+export interface ISaveLastBlockParams {
+  block_height: number;
+  main_chain_block_hash: Buffer;
+  ms_timestamp: DateOrString;
+  seed: string;
+  ver: number;
+}
+
+/** 'SaveLastBlock' return type */
+export type ISaveLastBlockResult = void;
+
+/** 'SaveLastBlock' query type */
+export interface ISaveLastBlockQuery {
+  params: ISaveLastBlockParams;
+  result: ISaveLastBlockResult;
+}
+
+const saveLastBlockIR: any = {"usedParamSet":{"block_height":true,"ver":true,"main_chain_block_hash":true,"seed":true,"ms_timestamp":true},"params":[{"name":"block_height","required":true,"transform":{"type":"scalar"},"locs":[{"a":140,"b":153}]},{"name":"ver","required":true,"transform":{"type":"scalar"},"locs":[{"a":156,"b":160}]},{"name":"main_chain_block_hash","required":true,"transform":{"type":"scalar"},"locs":[{"a":163,"b":185}]},{"name":"seed","required":true,"transform":{"type":"scalar"},"locs":[{"a":188,"b":193}]},{"name":"ms_timestamp","required":true,"transform":{"type":"scalar"},"locs":[{"a":196,"b":209}]}],"statement":"INSERT INTO effectstream.effectstream_blocks(block_height, ver, main_chain_block_hash, seed, ms_timestamp, effectstream_block_hash)\nVALUES (:block_height!, :ver!, :main_chain_block_hash!, :seed!, :ms_timestamp!, NULL)\nON CONFLICT (block_height)\nDO UPDATE SET\nblock_height = EXCLUDED.block_height,\nver = EXCLUDED.ver,\nmain_chain_block_hash = EXCLUDED.main_chain_block_hash,\nseed = EXCLUDED.seed,\nms_timestamp = EXCLUDED.ms_timestamp,\neffectstream_block_hash = EXCLUDED.effectstream_block_hash"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * INSERT INTO effectstream.effectstream_blocks(block_height, ver, main_chain_block_hash, seed, ms_timestamp, effectstream_block_hash)
+ * VALUES (:block_height!, :ver!, :main_chain_block_hash!, :seed!, :ms_timestamp!, NULL)
+ * ON CONFLICT (block_height)
+ * DO UPDATE SET
+ * block_height = EXCLUDED.block_height,
+ * ver = EXCLUDED.ver,
+ * main_chain_block_hash = EXCLUDED.main_chain_block_hash,
+ * seed = EXCLUDED.seed,
+ * ms_timestamp = EXCLUDED.ms_timestamp,
+ * effectstream_block_hash = EXCLUDED.effectstream_block_hash
+ * ```
+ */
+export const saveLastBlock = new PreparedQuery<ISaveLastBlockParams,ISaveLastBlockResult>(saveLastBlockIR);
+
+
+/** 'BlockHeightDone' parameters type */
+export interface IBlockHeightDoneParams {
+  block_hash: Buffer;
+  block_height: number;
+}
+
+/** 'BlockHeightDone' return type */
+export type IBlockHeightDoneResult = void;
+
+/** 'BlockHeightDone' query type */
+export interface IBlockHeightDoneQuery {
+  params: IBlockHeightDoneParams;
+  result: IBlockHeightDoneResult;
+}
+
+const blockHeightDoneIR: any = {"usedParamSet":{"block_hash":true,"block_height":true},"params":[{"name":"block_hash","required":true,"transform":{"type":"scalar"},"locs":[{"a":70,"b":81}]},{"name":"block_height","required":true,"transform":{"type":"scalar"},"locs":[{"a":104,"b":117}]}],"statement":"UPDATE effectstream.effectstream_blocks\nSET\neffectstream_block_hash = :block_hash!\nWHERE block_height = :block_height!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * UPDATE effectstream.effectstream_blocks
+ * SET
+ * effectstream_block_hash = :block_hash!
+ * WHERE block_height = :block_height!
+ * ```
+ */
+export const blockHeightDone = new PreparedQuery<IBlockHeightDoneParams,IBlockHeightDoneResult>(blockHeightDoneIR);
+
+

package/src/sql/block-heights.sql

@@ -0,0 +1,45 @@
+/* @name getLatestProcessedBlockHeight */
+SELECT * FROM effectstream.effectstream_blocks
+WHERE effectstream_block_hash IS NOT NULL
+ORDER BY block_height DESC
+LIMIT 1;
+
+/* @name getBlockSeeds */
+SELECT seed FROM effectstream.effectstream_blocks
+WHERE effectstream_block_hash IS NOT NULL
+ORDER BY block_height DESC
+LIMIT 25;
+
+/*
+ @name getBlockHeights
+ @param block_heights -> (...)
+*/
+SELECT * FROM effectstream.effectstream_blocks 
+WHERE block_height IN :block_heights!
+ORDER BY block_height ASC;
+
+/*
+ @name getBlockByHash
+*/
+SELECT curr.*, prev.effectstream_block_hash as "prev_block"
+FROM effectstream.effectstream_blocks curr
+LEFT JOIN effectstream.effectstream_blocks prev ON prev.block_height = curr.block_height - 1
+WHERE curr.effectstream_block_hash = :block_hash! OR curr.main_chain_block_hash = :block_hash!;
+
+/*  @name saveLastBlock */
+INSERT INTO effectstream.effectstream_blocks(block_height, ver, main_chain_block_hash, seed, ms_timestamp, effectstream_block_hash)
+VALUES (:block_height!, :ver!, :main_chain_block_hash!, :seed!, :ms_timestamp!, NULL)
+ON CONFLICT (block_height)
+DO UPDATE SET
+block_height = EXCLUDED.block_height,
+ver = EXCLUDED.ver,
+main_chain_block_hash = EXCLUDED.main_chain_block_hash,
+seed = EXCLUDED.seed,
+ms_timestamp = EXCLUDED.ms_timestamp,
+effectstream_block_hash = EXCLUDED.effectstream_block_hash;
+
+/* @name blockHeightDone */
+UPDATE effectstream.effectstream_blocks
+SET
+effectstream_block_hash = :block_hash!
+WHERE block_height = :block_height!;

package/src/sql/events.queries.ts

@@ -0,0 +1,201 @@
+/** Types generated for queries found in "src/sql/events.sql" */
+import { PreparedQuery } from '@pgtyped/runtime';
+
+export type Json = null | boolean | number | string | Json[] | { [key: string]: Json };
+
+/** 'GetEvents' parameters type */
+export interface IGetEventsParams {
+  address?: string | null | void;
+  from?: number | null | void;
+  to?: number | null | void;
+  topic: string;
+}
+
+/** 'GetEvents' return type */
+export interface IGetEventsResult {
+  address: string;
+  block_height: number;
+  data: Json;
+  id: number;
+  log_index: number;
+  topic: string;
+  tx_index: number;
+}
+
+/** 'GetEvents' query type */
+export interface IGetEventsQuery {
+  params: IGetEventsParams;
+  result: IGetEventsResult;
+}
+
+const getEventsIR: any = {"usedParamSet":{"from":true,"to":true,"address":true,"topic":true},"params":[{"name":"from","required":false,"transform":{"type":"scalar"},"locs":[{"a":66,"b":70}]},{"name":"to","required":false,"transform":{"type":"scalar"},"locs":[{"a":109,"b":111}]},{"name":"address","required":false,"transform":{"type":"scalar"},"locs":[{"a":144,"b":151}]},{"name":"topic","required":true,"transform":{"type":"scalar"},"locs":[{"a":173,"b":179}]}],"statement":"SELECT * FROM effectstream.event WHERE\n  COALESCE(block_height >= :from, 1=1) AND\n  COALESCE(block_height <= :to, 1=1) AND\n  COALESCE(address = :address, 1=1) AND\n  topic = :topic!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT * FROM effectstream.event WHERE
+ *   COALESCE(block_height >= :from, 1=1) AND
+ *   COALESCE(block_height <= :to, 1=1) AND
+ *   COALESCE(address = :address, 1=1) AND
+ *   topic = :topic!
+ * ```
+ */
+export const getEvents = new PreparedQuery<IGetEventsParams,IGetEventsResult>(getEventsIR);
+
+
+/** 'InsertEvent' parameters type */
+export interface IInsertEventParams {
+  address: string;
+  block_height: number;
+  data: Json;
+  log_index: number;
+  topic: string;
+  tx_index: number;
+}
+
+/** 'InsertEvent' return type */
+export type IInsertEventResult = void;
+
+/** 'InsertEvent' query type */
+export interface IInsertEventQuery {
+  params: IInsertEventParams;
+  result: IInsertEventResult;
+}
+
+const insertEventIR: any = {"usedParamSet":{"topic":true,"address":true,"data":true,"block_height":true,"tx_index":true,"log_index":true},"params":[{"name":"topic","required":true,"transform":{"type":"scalar"},"locs":[{"a":114,"b":120}]},{"name":"address","required":true,"transform":{"type":"scalar"},"locs":[{"a":125,"b":133}]},{"name":"data","required":true,"transform":{"type":"scalar"},"locs":[{"a":138,"b":143}]},{"name":"block_height","required":true,"transform":{"type":"scalar"},"locs":[{"a":148,"b":161}]},{"name":"tx_index","required":true,"transform":{"type":"scalar"},"locs":[{"a":166,"b":175}]},{"name":"log_index","required":true,"transform":{"type":"scalar"},"locs":[{"a":180,"b":190}]}],"statement":"INSERT INTO effectstream.event (\n  topic,\n  address,\n  data,\n  block_height,\n  tx_index,\n  log_index\n) VALUES (\n  :topic!,\n  :address!,\n  :data!,\n  :block_height!,\n  :tx_index!,\n  :log_index!\n)"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * INSERT INTO effectstream.event (
+ *   topic,
+ *   address,
+ *   data,
+ *   block_height,
+ *   tx_index,
+ *   log_index
+ * ) VALUES (
+ *   :topic!,
+ *   :address!,
+ *   :data!,
+ *   :block_height!,
+ *   :tx_index!,
+ *   :log_index!
+ * )
+ * ```
+ */
+export const insertEvent = new PreparedQuery<IInsertEventParams,IInsertEventResult>(insertEventIR);
+
+
+/** 'RegisterEventType' parameters type */
+export interface IRegisterEventTypeParams {
+  name: string;
+  topic: string;
+}
+
+/** 'RegisterEventType' return type */
+export type IRegisterEventTypeResult = void;
+
+/** 'RegisterEventType' query type */
+export interface IRegisterEventTypeQuery {
+  params: IRegisterEventTypeParams;
+  result: IRegisterEventTypeResult;
+}
+
+const registerEventTypeIR: any = {"usedParamSet":{"name":true,"topic":true},"params":[{"name":"name","required":true,"transform":{"type":"scalar"},"locs":[{"a":73,"b":78}]},{"name":"topic","required":true,"transform":{"type":"scalar"},"locs":[{"a":83,"b":89}]}],"statement":"INSERT INTO effectstream.registered_event (\n  name,\n  topic\n) VALUES (\n  :name!,\n  :topic!\n)"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * INSERT INTO effectstream.registered_event (
+ *   name,
+ *   topic
+ * ) VALUES (
+ *   :name!,
+ *   :topic!
+ * )
+ * ```
+ */
+export const registerEventType = new PreparedQuery<IRegisterEventTypeParams,IRegisterEventTypeResult>(registerEventTypeIR);
+
+
+/** 'GetTopicsForEvent' parameters type */
+export interface IGetTopicsForEventParams {
+  name: string;
+}
+
+/** 'GetTopicsForEvent' return type */
+export interface IGetTopicsForEventResult {
+  topic: string;
+}
+
+/** 'GetTopicsForEvent' query type */
+export interface IGetTopicsForEventQuery {
+  params: IGetTopicsForEventParams;
+  result: IGetTopicsForEventResult;
+}
+
+const getTopicsForEventIR: any = {"usedParamSet":{"name":true},"params":[{"name":"name","required":true,"transform":{"type":"scalar"},"locs":[{"a":61,"b":66}]}],"statement":"SELECT topic FROM effectstream.registered_event WHERE name = :name!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT topic FROM effectstream.registered_event WHERE name = :name!
+ * ```
+ */
+export const getTopicsForEvent = new PreparedQuery<IGetTopicsForEventParams,IGetTopicsForEventResult>(getTopicsForEventIR);
+
+
+/** 'GetTopics' parameters type */
+export type IGetTopicsParams = void;
+
+/** 'GetTopics' return type */
+export interface IGetTopicsResult {
+  name: string;
+  topic: string;
+}
+
+/** 'GetTopics' query type */
+export interface IGetTopicsQuery {
+  params: IGetTopicsParams;
+  result: IGetTopicsResult;
+}
+
+const getTopicsIR: any = {"usedParamSet":{},"params":[],"statement":"SELECT name, topic FROM effectstream.registered_event"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT name, topic FROM effectstream.registered_event
+ * ```
+ */
+export const getTopics = new PreparedQuery<IGetTopicsParams,IGetTopicsResult>(getTopicsIR);
+
+
+/** 'GetEventByTopic' parameters type */
+export interface IGetEventByTopicParams {
+  topic: string;
+}
+
+/** 'GetEventByTopic' return type */
+export interface IGetEventByTopicResult {
+  name: string;
+}
+
+/** 'GetEventByTopic' query type */
+export interface IGetEventByTopicQuery {
+  params: IGetEventByTopicParams;
+  result: IGetEventByTopicResult;
+}
+
+const getEventByTopicIR: any = {"usedParamSet":{"topic":true},"params":[{"name":"topic","required":true,"transform":{"type":"scalar"},"locs":[{"a":61,"b":67}]}],"statement":"SELECT name FROM effectstream.registered_event WHERE topic = :topic!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT name FROM effectstream.registered_event WHERE topic = :topic!
+ * ```
+ */
+export const getEventByTopic = new PreparedQuery<IGetEventByTopicParams,IGetEventByTopicResult>(getEventByTopicIR);
+
+

package/src/sql/events.sql

@@ -0,0 +1,41 @@
+/* @name getEvents */
+SELECT * FROM effectstream.event WHERE
+  COALESCE(block_height >= :from, 1=1) AND
+  COALESCE(block_height <= :to, 1=1) AND
+  COALESCE(address = :address, 1=1) AND
+  topic = :topic!;
+
+/* @name insertEvent */
+INSERT INTO effectstream.event (
+  topic,
+  address,
+  data,
+  block_height,
+  tx_index,
+  log_index
+) VALUES (
+  :topic!,
+  :address!,
+  :data!,
+  :block_height!,
+  :tx_index!,
+  :log_index!
+);
+
+/* @name registerEventType */
+INSERT INTO effectstream.registered_event (
+  name,
+  topic
+) VALUES (
+  :name!,
+  :topic!
+);
+
+/* @name getTopicsForEvent */
+SELECT topic FROM effectstream.registered_event WHERE name = :name!;
+
+/* @name getTopics */
+SELECT name, topic FROM effectstream.registered_event;
+
+/* @name getEventByTopic */
+SELECT name FROM effectstream.registered_event WHERE topic = :topic!;

package/src/sql/nonces.queries.ts

@@ -0,0 +1,85 @@
+/** Types generated for queries found in "src/sql/nonces.sql" */
+import { PreparedQuery } from '@pgtyped/runtime';
+
+/** 'FindNonce' parameters type */
+export interface IFindNonceParams {
+  nonce?: string | null | void;
+}
+
+/** 'FindNonce' return type */
+export interface IFindNonceResult {
+  block_height: number;
+  nonce: string;
+}
+
+/** 'FindNonce' query type */
+export interface IFindNonceQuery {
+  params: IFindNonceParams;
+  result: IFindNonceResult;
+}
+
+const findNonceIR: any = {"usedParamSet":{"nonce":true},"params":[{"name":"nonce","required":false,"transform":{"type":"scalar"},"locs":[{"a":48,"b":53}]}],"statement":"SELECT * FROM effectstream.nonces\nWHERE nonce = :nonce"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT * FROM effectstream.nonces
+ * WHERE nonce = :nonce
+ * ```
+ */
+export const findNonce = new PreparedQuery<IFindNonceParams,IFindNonceResult>(findNonceIR);
+
+
+/** 'DeleteNonces' parameters type */
+export interface IDeleteNoncesParams {
+  limit_block_height: number;
+}
+
+/** 'DeleteNonces' return type */
+export type IDeleteNoncesResult = void;
+
+/** 'DeleteNonces' query type */
+export interface IDeleteNoncesQuery {
+  params: IDeleteNoncesParams;
+  result: IDeleteNoncesResult;
+}
+
+const deleteNoncesIR: any = {"usedParamSet":{"limit_block_height":true},"params":[{"name":"limit_block_height","required":true,"transform":{"type":"scalar"},"locs":[{"a":54,"b":73}]}],"statement":"DELETE FROM effectstream.nonces\nWHERE block_height <= :limit_block_height!"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * DELETE FROM effectstream.nonces
+ * WHERE block_height <= :limit_block_height!
+ * ```
+ */
+export const deleteNonces = new PreparedQuery<IDeleteNoncesParams,IDeleteNoncesResult>(deleteNoncesIR);
+
+
+/** 'InsertNonce' parameters type */
+export interface IInsertNonceParams {
+  block_height: number;
+  nonce: string;
+}
+
+/** 'InsertNonce' return type */
+export type IInsertNonceResult = void;
+
+/** 'InsertNonce' query type */
+export interface IInsertNonceQuery {
+  params: IInsertNonceParams;
+  result: IInsertNonceResult;
+}
+
+const insertNonceIR: any = {"usedParamSet":{"nonce":true,"block_height":true},"params":[{"name":"nonce","required":true,"transform":{"type":"scalar"},"locs":[{"a":61,"b":67}]},{"name":"block_height","required":true,"transform":{"type":"scalar"},"locs":[{"a":70,"b":83}]}],"statement":"INSERT INTO effectstream.nonces(nonce, block_height)\nVALUES (:nonce!, :block_height!)"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * INSERT INTO effectstream.nonces(nonce, block_height)
+ * VALUES (:nonce!, :block_height!)
+ * ```
+ */
+export const insertNonce = new PreparedQuery<IInsertNonceParams,IInsertNonceResult>(insertNonceIR);
+
+

package/src/sql/nonces.sql

@@ -0,0 +1,11 @@
+/* @name findNonce */
+SELECT * FROM effectstream.nonces
+WHERE nonce = :nonce;
+
+/* @name deleteNonces */
+DELETE FROM effectstream.nonces
+WHERE block_height <= :limit_block_height!;
+
+/* @name insertNonce */
+INSERT INTO effectstream.nonces(nonce, block_height)
+VALUES (:nonce!, :block_height!);

package/src/sql/primitives.queries.ts

@@ -0,0 +1,35 @@
+/** Types generated for queries found in "src/sql/primitives.sql" */
+import { PreparedQuery } from '@pgtyped/runtime';
+
+export type Json = null | boolean | number | string | Json[] | { [key: string]: Json };
+
+/** 'InsertPrimitiveAccounting' parameters type */
+export interface IInsertPrimitiveAccountingParams {
+  effectstream_block_height: number;
+  payload: Json;
+  payload_type: string;
+  primitive_name: string;
+}
+
+/** 'InsertPrimitiveAccounting' return type */
+export type IInsertPrimitiveAccountingResult = void;
+
+/** 'InsertPrimitiveAccounting' query type */
+export interface IInsertPrimitiveAccountingQuery {
+  params: IInsertPrimitiveAccountingParams;
+  result: IInsertPrimitiveAccountingResult;
+}
+
+const insertPrimitiveAccountingIR: any = {"usedParamSet":{"primitive_name":true,"effectstream_block_height":true,"payload_type":true,"payload":true},"params":[{"name":"primitive_name","required":true,"transform":{"type":"scalar"},"locs":[{"a":120,"b":135}]},{"name":"effectstream_block_height","required":true,"transform":{"type":"scalar"},"locs":[{"a":138,"b":164}]},{"name":"payload_type","required":true,"transform":{"type":"scalar"},"locs":[{"a":167,"b":180}]},{"name":"payload","required":true,"transform":{"type":"scalar"},"locs":[{"a":183,"b":191}]}],"statement":"INSERT INTO effectstream.primitive_accounting(primitive_name, effectstream_block_height, payload_type, payload)\nVALUES (:primitive_name!, :effectstream_block_height!, :payload_type!, :payload!)\nON CONFLICT (primitive_name, effectstream_block_height, payload_hash) DO NOTHING"};
+
+/**
+ * Query generated from SQL:
+ * ```
+ * INSERT INTO effectstream.primitive_accounting(primitive_name, effectstream_block_height, payload_type, payload)
+ * VALUES (:primitive_name!, :effectstream_block_height!, :payload_type!, :payload!)
+ * ON CONFLICT (primitive_name, effectstream_block_height, payload_hash) DO NOTHING
+ * ```
+ */
+export const insertPrimitiveAccounting = new PreparedQuery<IInsertPrimitiveAccountingParams,IInsertPrimitiveAccountingResult>(insertPrimitiveAccountingIR);
+
+

package/src/sql/primitives.sql

@@ -0,0 +1,4 @@
+/* @name insertPrimitiveAccounting */
+INSERT INTO effectstream.primitive_accounting(primitive_name, effectstream_block_height, payload_type, payload)
+VALUES (:primitive_name!, :effectstream_block_height!, :payload_type!, :payload!)
+ON CONFLICT (primitive_name, effectstream_block_height, payload_hash) DO NOTHING;