hive-stream 3.0.1 → 3.0.2

package/DOCUMENTATION.md

@@ -9,6 +9,8 @@ Hive Stream is a Node.js library for streaming Hive blockchain activity and rout
 
 This document focuses on the contract system and how to build robust contracts using the new `defineContract`/`action` API.
 
+By default, `new Streamer()` registers the SQLite adapter and starts the built-in Express API server on port `5001` when `NODE_ENV !== 'test'`.
+
 ---
 
 ## Concepts
@@ -23,7 +25,6 @@ Contracts are registered with the `Streamer` and called when a payload matches `
 
 ### Actions
 An **action** is a handler function plus metadata such as:
-- the trigger (`custom_json`, `transfer`, or `time`)
 - the trigger (`custom_json`, `transfer`, `time`, `escrow_transfer`, `escrow_approve`, `escrow_dispute`, `escrow_release`, or `recurrent_transfer`)
 - an optional Zod schema to validate payloads
 - whether it requires an active key signature
@@ -32,6 +33,8 @@ An **action** is a handler function plus metadata such as:
 Hive Stream extracts payloads from:
 - **custom_json**: `op[1].json`
 - **transfer memo**: `op[1].memo`
+- **recurrent transfer memo**: `op[1].memo`
+- **escrow metadata**: `op[1].json_meta`
 
 It expects a wrapper object that looks like:
 
@@ -48,6 +51,19 @@ It expects a wrapper object that looks like:
 
 The wrapper key `hive_stream` is the default `PAYLOAD_IDENTIFIER`. You can change it in config.
 
+Relevant configuration defaults:
+
+- `PAYLOAD_IDENTIFIER`: `hive_stream`
+- `JSON_ID`: `hivestream`
+- `HIVE_ENGINE_ID`: `ssc-mainnet-hive`
+- `HIVE_ENGINE_API`: `https://api.hive-engine.com/rpc`
+
+### Event Handlers vs Contracts
+Streamer event handlers (`onTransfer`, `onCustomJson`, `onCustomJsonId`, etc.) and contract actions are different execution paths.
+
+- Event handlers fire for matching blockchain operations.
+- Contract actions only run when a valid wrapper exists under `PAYLOAD_IDENTIFIER` and the `contract` + `action` values match a registered contract action.
+
 ---
 
 ## Contract API

package/README.md

@@ -21,34 +21,55 @@ ss.onCustomJson((op, { sender, isSignedWithActiveKey }, blockNumber, blockId, pr
 });
 ```
 
+`new Streamer()` automatically registers the SQLite adapter and starts the built-in Express API server on port `5001` when `NODE_ENV !== 'test'`.
+
+## Builder/Tooling Metadata
+
+For external tooling (like visual builders), Hive Stream now exports a read-only metadata object:
+
+```javascript
+const { HIVE_STREAM_METADATA, getHiveStreamMetadata } = require('hive-stream');
+
+console.log(HIVE_STREAM_METADATA.subscriptions);
+console.log(getHiveStreamMetadata().writeOperations);
+```
+
+This metadata is static runtime data (no network calls) and includes config defaults, event callback signatures, write operation signatures, adapter metadata, contract trigger info, and valid `TimeAction` values.
+
 ## Configuration
 
 The `Streamer` object can accept an object of configuration values which are all optional. However, some operations like transferring Hive Engine tokens or other operations on the blockchain that are not READ ONLY, will require the active key and/or posting keys supplied as well as a username.
 
-The `BLOCK_CHECK_INTERVAL` value is how often to check for new blocks or in cases of error or falling behind, to poll for new blocks. You should keep this as the default 1000ms value which is one second. This allows you to account for situations where blocks fall behind the main block.
+The `blockCheckInterval` value is how often to check for new blocks or in cases of error or falling behind, to poll for new blocks. You should keep this as the default 1000ms value which is one second. This allows you to account for situations where blocks fall behind the main block.
+
+The `blocksBehindWarning` value is a numeric value of the number of blocks your API will fall behind from the master before warning to the console.
 
-The `BLOCKS_BEHIND_WARNING` value is a numeric value of the number of blocks your API will fall behind from the master before warning to the console.
+To resume automatically from stored state, keep `resumeFromState` enabled (default). To force a specific start block, set `resumeFromState` to `false` and supply `lastBlockNumber`.
 
-To resume automatically from stored state, keep `RESUME_FROM_STATE` enabled (default). To force a specific start block, set `RESUME_FROM_STATE` to `false` and supply `LAST_BLOCK_NUMBER`.
+For faster catch-up, `catchUpBatchSize` controls how many blocks are processed per polling cycle, and `catchUpDelayMs` controls the delay between catch-up batches (set to `0` for fastest catch-up).
 
-For faster catch-up, `CATCH_UP_BATCH_SIZE` controls how many blocks are processed per polling cycle, and `CATCH_UP_DELAY_MS` controls the delay between catch-up batches (set to `0` for fastest catch-up).
+The `apiNodes` are the Hive API endpoints used for failover. If you want to enable debug mode, set `debugMode` to `true`. The configuration values and their defaults can be found in `src/config.ts`.
 
-The `API_NODES` are the Hive API endpoints used for failover. If you want to enable debug mode, set `DEBUG_MODE` to `true`. The configuration values and their defaults can be found in `src/config.ts`.
+CamelCase config keys are recommended for readability. Legacy uppercase keys are still supported for backwards compatibility.
 
 ```
 const options = {
-  ACTIVE_KEY: '',
-  POSTING_KEY: '',
-  APP_NAME: 'hive-stream',
-  USERNAME: '',
-  LAST_BLOCK_NUMBER: 0,
-  BLOCK_CHECK_INTERVAL: 1000,
-  BLOCKS_BEHIND_WARNING: 25,
-  RESUME_FROM_STATE: true,
-  CATCH_UP_BATCH_SIZE: 50,
-  CATCH_UP_DELAY_MS: 0,
-  API_NODES: ['https://api.hive.blog', 'https://api.openhive.network', 'https://rpc.ausbit.dev'],
-  DEBUG_MODE: false
+  activeKey: '',
+  postingKey: '',
+  jsonId: 'hivestream',
+  hiveEngineApi: 'https://api.hive-engine.com/rpc',
+  hiveEngineId: 'ssc-mainnet-hive',
+  payloadIdentifier: 'hive_stream',
+  appName: 'hive-stream',
+  username: '',
+  lastBlockNumber: 0,
+  blockCheckInterval: 1000,
+  blocksBehindWarning: 25,
+  resumeFromState: true,
+  catchUpBatchSize: 50,
+  catchUpDelayMs: 0,
+  apiNodes: ['https://api.hive.blog', 'https://api.openhive.network', 'https://rpc.ausbit.dev'],
+  debugMode: true
 }
 
 const ss = new Streamer(options);
@@ -58,23 +79,24 @@ The configuration itself can also be overloaded using the `setConfig` method whi
 
 ```
 ss.setConfig({
-  ACTIVE_KEY: 'newactivekey',
-  USERNAME: 'newusername'
+  activeKey: 'newactivekey',
+  username: 'newusername'
 });
 ```
 
 ## Streamer
 
 The following subscription methods are read only methods, they allow you to react to certain Hive and Hive Engine events on the blockchain. You do not need to pass in any keys to use these methods as they're purely read only.
+These event subscriptions and contract actions are separate paths: subscriptions fire for matching operations, while contracts only run when a payload wrapper exists under `PAYLOAD_IDENTIFIER`.
 
 **The following actions DO require calling the `start` method first to watch the blockchain**
 
 #### Watch for transfers
 
 ```javascript
-ss.onTransfer((op, blockNumber, blockId, prevBlockId, trxId, blockTime) => {
-
-})
+ss.onTransfer('myaccount', (op, { sender, amount, asset, memo }, blockNumber, blockId, prevBlockId, trxId, blockTime) => {
+  // Fires only when op.to === 'myaccount'
+});
 ```
 
 #### Watch for escrow operations
@@ -107,7 +129,14 @@ ss.onCustomJson((op, { sender, isSignedWithActiveKey }, blockNumber, blockId, pr
 ```javascript
 ss.onCustomJsonId((op, { sender, isSignedWithActiveKey }, blockNumber, blockId, prevBlockId, trxId, blockTime) => {
   
-})
+}, 'your-custom-json-id');
+```
+
+#### Watch for Hive Engine custom JSON operations
+```javascript
+ss.onHiveEngine((contractName, contractAction, contractPayload, sender, op, blockNumber, blockId, prevBlockId, trxId, blockTime) => {
+  
+});
 ```
 
 #### Watch for post operations
@@ -220,7 +249,8 @@ downvote(votePercentage = '100.0', username, permlink) {
 
 ## Contracts
 
-Hive Stream allows you to register contract definitions that execute when a transfer memo or custom JSON operation matches. The payload lives under the `PAYLOAD_IDENTIFIER` (default: `hive_stream`).
+Hive Stream allows you to register contract definitions that execute when a transfer memo or custom JSON operation includes a contract wrapper. The payload lives under the `PAYLOAD_IDENTIFIER` key (default: `hive_stream`).
+Regular event handlers like `onTransfer` and `onCustomJson` still run for matching operations even when no contract wrapper is present.
 
 The payload shape is:
 

package/dist/config.d.ts

@@ -16,4 +16,27 @@ export interface ConfigInterface {
     API_NODES: string[];
     DEBUG_MODE: boolean;
 }
+export interface ConfigInput extends Partial<ConfigInterface> {
+    activeKey?: ConfigInterface['ACTIVE_KEY'];
+    postingKey?: ConfigInterface['POSTING_KEY'];
+    jsonId?: ConfigInterface['JSON_ID'];
+    hiveEngineApi?: ConfigInterface['HIVE_ENGINE_API'];
+    hiveEngineId?: ConfigInterface['HIVE_ENGINE_ID'];
+    appName?: ConfigInterface['APP_NAME'];
+    username?: ConfigInterface['USERNAME'];
+    payloadIdentifier?: ConfigInterface['PAYLOAD_IDENTIFIER'];
+    lastBlockNumber?: ConfigInterface['LAST_BLOCK_NUMBER'];
+    blockCheckInterval?: ConfigInterface['BLOCK_CHECK_INTERVAL'];
+    blocksBehindWarning?: ConfigInterface['BLOCKS_BEHIND_WARNING'];
+    resumeFromState?: ConfigInterface['RESUME_FROM_STATE'];
+    catchUpBatchSize?: ConfigInterface['CATCH_UP_BATCH_SIZE'];
+    catchUpDelayMs?: ConfigInterface['CATCH_UP_DELAY_MS'];
+    apiNodes?: ConfigInterface['API_NODES'];
+    debugMode?: ConfigInterface['DEBUG_MODE'];
+}
+type ConfigAliasKey = keyof Omit<ConfigInput, keyof ConfigInterface>;
+export declare const CONFIG_KEY_ALIASES: Record<ConfigAliasKey, keyof ConfigInterface>;
 export declare const Config: ConfigInterface;
+export declare function normalizeConfigInput(config?: ConfigInput): Partial<ConfigInterface>;
+export declare function createConfig(config?: ConfigInput): ConfigInterface;
+export {};

package/dist/config.js

@@ -1,6 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Config = void 0;
+exports.Config = exports.CONFIG_KEY_ALIASES = void 0;
+exports.normalizeConfigInput = normalizeConfigInput;
+exports.createConfig = createConfig;
+const CONFIG_KEYS = [
+    'ACTIVE_KEY',
+    'POSTING_KEY',
+    'JSON_ID',
+    'HIVE_ENGINE_API',
+    'HIVE_ENGINE_ID',
+    'APP_NAME',
+    'USERNAME',
+    'PAYLOAD_IDENTIFIER',
+    'LAST_BLOCK_NUMBER',
+    'BLOCK_CHECK_INTERVAL',
+    'BLOCKS_BEHIND_WARNING',
+    'RESUME_FROM_STATE',
+    'CATCH_UP_BATCH_SIZE',
+    'CATCH_UP_DELAY_MS',
+    'API_NODES',
+    'DEBUG_MODE',
+];
+exports.CONFIG_KEY_ALIASES = {
+    activeKey: 'ACTIVE_KEY',
+    postingKey: 'POSTING_KEY',
+    jsonId: 'JSON_ID',
+    hiveEngineApi: 'HIVE_ENGINE_API',
+    hiveEngineId: 'HIVE_ENGINE_ID',
+    appName: 'APP_NAME',
+    username: 'USERNAME',
+    payloadIdentifier: 'PAYLOAD_IDENTIFIER',
+    lastBlockNumber: 'LAST_BLOCK_NUMBER',
+    blockCheckInterval: 'BLOCK_CHECK_INTERVAL',
+    blocksBehindWarning: 'BLOCKS_BEHIND_WARNING',
+    resumeFromState: 'RESUME_FROM_STATE',
+    catchUpBatchSize: 'CATCH_UP_BATCH_SIZE',
+    catchUpDelayMs: 'CATCH_UP_DELAY_MS',
+    apiNodes: 'API_NODES',
+    debugMode: 'DEBUG_MODE',
+};
 exports.Config = {
     ACTIVE_KEY: process.env.ACTIVE_KEY,
     POSTING_KEY: process.env.POSTING_KEY,
@@ -19,4 +57,35 @@ exports.Config = {
     API_NODES: ['https://api.hive.blog', 'https://api.openhive.network', 'https://rpc.ausbit.dev'],
     DEBUG_MODE: true,
 };
+function normalizeConfigInput(config = {}) {
+    const normalized = {};
+    const normalizedRecord = normalized;
+    const canonicalConfig = config;
+    for (const key of CONFIG_KEYS) {
+        const value = canonicalConfig[key];
+        if (value !== undefined) {
+            normalizedRecord[key] = value;
+        }
+    }
+    const aliasEntries = Object.entries(exports.CONFIG_KEY_ALIASES);
+    for (const [aliasKey, canonicalKey] of aliasEntries) {
+        if (normalized[canonicalKey] !== undefined) {
+            continue;
+        }
+        const aliasValue = config[aliasKey];
+        if (aliasValue !== undefined) {
+            normalizedRecord[canonicalKey] = aliasValue;
+        }
+    }
+    return normalized;
+}
+function createConfig(config = {}) {
+    const normalized = normalizeConfigInput(config);
+    const apiNodes = Array.isArray(normalized.API_NODES) ? [...normalized.API_NODES] : [...exports.Config.API_NODES];
+    return {
+        ...exports.Config,
+        ...normalized,
+        API_NODES: apiNodes,
+    };
+}
 //# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AAmBa,QAAA,MAAM,GAAoB;IACnC,UAAU,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU;IAClC,WAAW,EAAE,OAAO,CAAC,GAAG,CAAC,WAAW;IAEpC,OAAO,EAAE,YAAY;IAErB,eAAe,EAAE,iCAAiC;IAClD,cAAc,EAAE,kBAAkB;IAElC,QAAQ,EAAE,aAAa;IAEvB,kBAAkB,EAAE,aAAa;IAEjC,QAAQ,EAAE,EAAE;IAEZ,iBAAiB,EAAE,CAAC;IAEpB,oBAAoB,EAAE,IAAI;IAC1B,qBAAqB,EAAE,EAAE;IACzB,iBAAiB,EAAE,IAAI;IACvB,mBAAmB,EAAE,EAAE;IACvB,iBAAiB,EAAE,CAAC;IAEpB,SAAS,EAAE,CAAC,uBAAuB,EAAE,8BAA8B,EAAE,wBAAwB,CAAC;IAE9F,UAAU,EAAE,IAAI;CACnB,CAAC"}
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './config';
 export * from './streamer';
 export * from './utils';
 export * from './actions';
+export * from './metadata';
 export * from './contracts/contract';
 export * from './adapters/base.adapter';
 export * from './adapters/sqlite.adapter';

package/dist/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./config"), exports);
 __exportStar(require("./streamer"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./actions"), exports);
+__exportStar(require("./metadata"), exports);
 __exportStar(require("./contracts/contract"), exports);
 __exportStar(require("./adapters/base.adapter"), exports);
 __exportStar(require("./adapters/sqlite.adapter"), exports);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,6CAA2B;AAC3B,0CAAwB;AACxB,4CAA0B;AAC1B,uDAAqC;AAErC,0DAAwC;AACxC,4DAA0C;AAC1C,6DAA2C;AAC3C,gEAA8C;AAE9C,2DAA+D;AAAtD,mHAAA,kBAAkB,OAAA;AAC3B,6DAAiE;AAAxD,qHAAA,mBAAmB,OAAA;AAC5B,mEAAuE;AAA9D,2HAAA,sBAAsB,OAAA;AAC/B,6DAAiE;AAAxD,qHAAA,mBAAmB,OAAA;AAC5B,yDAA0E;AAAjE,iHAAA,iBAAiB,OAAA;AAAE,2GAAA,WAAW,OAAA;AACvC,yDAA6D;AAApD,iHAAA,iBAAiB,OAAA;AAC1B,2DAA+D;AAAtD,mHAAA,kBAAkB,OAAA;AAC3B,+DAAmE;AAA1D,uHAAA,oBAAoB,OAAA;AAC7B,mEAAuE;AAA9D,2HAAA,sBAAsB,OAAA;AAE/B,QAAQ;AACR,sDAAoC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,6CAA2B;AAC3B,0CAAwB;AACxB,4CAA0B;AAC1B,6CAA2B;AAC3B,uDAAqC;AAErC,0DAAwC;AACxC,4DAA0C;AAC1C,6DAA2C;AAC3C,gEAA8C;AAE9C,2DAA+D;AAAtD,mHAAA,kBAAkB,OAAA;AAC3B,6DAAiE;AAAxD,qHAAA,mBAAmB,OAAA;AAC5B,mEAAuE;AAA9D,2HAAA,sBAAsB,OAAA;AAC/B,6DAAiE;AAAxD,qHAAA,mBAAmB,OAAA;AAC5B,yDAA0E;AAAjE,iHAAA,iBAAiB,OAAA;AAAE,2GAAA,WAAW,OAAA;AACvC,yDAA6D;AAApD,iHAAA,iBAAiB,OAAA;AAC1B,2DAA+D;AAAtD,mHAAA,kBAAkB,OAAA;AAC3B,+DAAmE;AAA1D,uHAAA,oBAAoB,OAAA;AAC7B,mEAAuE;AAA9D,2HAAA,sBAAsB,OAAA;AAE/B,QAAQ;AACR,sDAAoC"}

package/dist/metadata.d.ts

@@ -0,0 +1,63 @@
+import { ConfigInput, ConfigInterface } from './config';
+import type { ContractTrigger } from './types/hive-stream';
+export type MetadataPrimitive = string | number | boolean | null;
+export interface ConfigOptionMetadata {
+    key: keyof ConfigInterface;
+    builderKey?: keyof ConfigInput;
+    type: 'string' | 'number' | 'boolean' | 'string[]';
+    defaultValue: MetadataPrimitive | string[];
+    description: string;
+    envVar?: string;
+}
+export interface EventHandlerMetadata {
+    method: string;
+    signature: string;
+    callbackSignature: string;
+    description: string;
+    requiresStart: boolean;
+    accountFilterBuiltIn?: boolean;
+    idFilterBuiltIn?: boolean;
+}
+export interface WriteOperationMetadata {
+    method: string;
+    signature: string;
+    description: string;
+    requiresActiveKey: boolean;
+    requiresStart: boolean;
+}
+export interface AdapterMetadata {
+    name: string;
+    exportName: string;
+    constructorSignature: string;
+    description: string;
+}
+export interface ContractPayloadMetadata {
+    jsonIdDefault: string;
+    payloadIdentifierDefault: string;
+    shape: {
+        contract: string;
+        action: string;
+        payload: string;
+        meta: string;
+    };
+    supportedTriggers: ContractTrigger[];
+    supportedOperations: string[];
+}
+export interface HiveStreamMetadata {
+    schemaVersion: number;
+    config: {
+        options: ConfigOptionMetadata[];
+    };
+    subscriptions: EventHandlerMetadata[];
+    writeOperations: WriteOperationMetadata[];
+    contracts: {
+        payload: ContractPayloadMetadata;
+        helperExports: string[];
+    };
+    timeAction: {
+        validValues: string[];
+    };
+    adapters: AdapterMetadata[];
+}
+export declare const HIVE_STREAM_METADATA: Readonly<HiveStreamMetadata>;
+export declare function getHiveStreamMetadata(): Readonly<HiveStreamMetadata>;