@keetanetwork/keetanet-client 0.12.2 → 0.14.0

package/api/index.d.ts

@@ -6,6 +6,7 @@ declare const rootTree: {
             POST: (request: APIRequest, payload: {
                 blocks: string[];
                 votes?: string[];
+                quote?: string;
             }) => Promise<{
                 vote: import("../lib/vote").Vote;
             }>;
@@ -16,6 +17,13 @@ declare const rootTree: {
                 votes: import("../lib/vote").Vote[] | null;
             }>;
         };
+        quote: {
+            POST: (request: APIRequest, payload: {
+                blocks: string[];
+            }) => Promise<{
+                quote: import("../lib/vote").VoteQuote;
+            }>;
+        };
     };
     node: {
         peers: {
@@ -67,6 +75,9 @@ declare const rootTree: {
                     representatives: import("./node").NodeAPIGetAllRepresentativesResponse[];
                 }>;
             };
+            history: {
+                GET: (request: APIRequest, account?: string | unknown, startFromURL?: unknown) => Promise<import("./node").NodeAPIGetAccountHistoryResponse>;
+            };
             account: {
                 ':account': {
                     GET: (request: APIRequest, pubKey: string) => Promise<import("./node").NodeAPIAccountState | import("./node").NodeAPIAccountStateError>;
@@ -80,10 +91,10 @@ declare const rootTree: {
                         GET: (request: APIRequest, account: string) => Promise<import("./node").NodeAPIGetAccountChainResponse>;
                     };
                     history: {
-                        GET: (request: APIRequest, account: string, start?: unknown) => Promise<import("./node").NodeAPIGetAccountHistoryResponse>;
+                        GET: (request: APIRequest, account?: string | unknown, startFromURL?: unknown) => Promise<import("./node").NodeAPIGetAccountHistoryResponse>;
                         start: {
                             ':block': {
-                                GET: (request: APIRequest, account: string, start?: unknown) => Promise<import("./node").NodeAPIGetAccountHistoryResponse>;
+                                GET: (request: APIRequest, account?: string | unknown, startFromURL?: unknown) => Promise<import("./node").NodeAPIGetAccountHistoryResponse>;
                             };
                         };
                     };
@@ -171,6 +182,16 @@ declare const rootTree: {
             }>;
         };
     };
+    p2p: {
+        message: {
+            POST: (request: APIRequest, payload: {
+                message: string;
+                greeting: object;
+            }) => Promise<{
+                success: boolean;
+            }>;
+        };
+    };
 };
 export interface APIRequest {
     node: Node;

package/api/node.d.ts

@@ -1,3 +1,4 @@
+import KeetaNet from '../lib';
 import type { AccountInfo, GetAllBalancesResponse, LedgerStatistics, ACLRow } from '../lib/ledger/types';
 import type { P2PSwitchStatistics } from '../lib/p2p';
 import { NodeKind } from '../lib/node';
@@ -14,6 +15,7 @@ interface GetPeersAPIResponse {
         p2p: string;
         api: string;
     };
+    preferUpdates?: string;
     signature?: string;
 }
 interface GetAccountChainAPIResponse {
@@ -63,6 +65,7 @@ interface GetAccountHistoryResponse {
         '$id': string;
         '$timestamp': string;
     }[];
+    nextKey: InstanceType<typeof KeetaNet.Vote.VoteBlocksHash> | null;
 }
 declare function getPeers(request: APIRequest): Promise<{
     peers: GetPeersAPIResponse[];
@@ -130,7 +133,7 @@ declare function listACLsByPrincipal(request: APIRequest, principal: string | Ge
 }>;
 declare function listACLsByPrincipalWithInfo(request: APIRequest, principalPubKey: string, entityList?: string): Promise<PrincipalACLWithInfoResponse>;
 declare function getAccountChain(request: APIRequest, account: string): Promise<GetAccountChainAPIResponse>;
-declare function getAccountHistory(request: APIRequest, account: string, start?: unknown): Promise<GetAccountHistoryResponse>;
+declare function getAccountHistory(request: APIRequest, account?: string | unknown, startFromURL?: unknown): Promise<GetAccountHistoryResponse>;
 declare function getAllRepresentatives(request: APIRequest): Promise<{
     representatives: GetAllRepresentativesAPIResponse[];
 }>;
@@ -173,6 +176,9 @@ declare const _default: {
         representatives: {
             GET: typeof getAllRepresentatives;
         };
+        history: {
+            GET: typeof getAccountHistory;
+        };
         account: {
             ':account': {
                 GET: typeof getAccountState;

package/api/p2p.d.ts

@@ -0,0 +1,13 @@
+import type { APIRequest } from ".";
+declare function handleMessage(request: APIRequest, payload: {
+    message: string;
+    greeting: object;
+}): Promise<{
+    success: boolean;
+}>;
+declare const _default: {
+    message: {
+        POST: typeof handleMessage;
+    };
+};
+export default _default;

package/api/vote.d.ts

@@ -1,10 +1,12 @@
 import type { APIRequest } from '.';
 import KeetaNet from '../lib';
 type Vote = InstanceType<typeof KeetaNet['Vote']>;
+type VoteQuote = InstanceType<typeof KeetaNet['Vote']['Quote']>;
 type BlockHash = InstanceType<typeof KeetaNet['Block']['Hash']>;
 declare function createNewVote(request: APIRequest, payload: {
     blocks: string[];
     votes?: string[];
+    quote?: string;
 }): Promise<{
     vote: Vote;
 }>;
@@ -12,6 +14,11 @@ declare function getVotes(request: APIRequest, blockhash: string): Promise<{
     blockhash: BlockHash;
     votes: Vote[] | null;
 }>;
+declare function createNewQuote(request: APIRequest, payload: {
+    blocks: string[];
+}): Promise<{
+    quote: VoteQuote;
+}>;
 declare const _default: {
     _root: {
         POST: typeof createNewVote;
@@ -19,5 +26,8 @@ declare const _default: {
     ':blockhash': {
         GET: typeof getVotes;
     };
+    quote: {
+        POST: typeof createNewQuote;
+    };
 };
 export default _default;

package/benchmarking/test.d.ts

@@ -0,0 +1,4 @@
+declare const smallJSON = "{\"data\": [1000]}";
+declare const largeJSON: string;
+declare const smallObj: any;
+declare const largeObj: any;

package/client/builder.d.ts

@@ -2,12 +2,13 @@ import type { GenericAccount, IdentifierKeyAlgorithm } from '../lib/account';
 import { Account, AccountKeyAlgorithm } from '../lib/account';
 import type { AdjustMethod, BlockHash } from '../lib/block';
 import { Block } from '../lib/block';
-import type { BlockJSONOperations } from '../lib/block/operations';
+import { type BlockJSONOperations } from '../lib/block/operations';
 import type { AccountInfo } from '../lib/ledger/types';
 import type { AcceptedPermissionTypes } from '../lib/permissions';
-import type { UserClient } from '.';
+import type { UserClient, PublishOptions } from '.';
 import { Permissions } from '../lib/permissions';
 import { Certificate, CertificateBundle } from '../lib/utils/certificate';
+import type { VoteStaple } from '../lib/vote';
 type GetPrevFunction = (acct: GenericAccount | string) => Promise<BlockHash | string | null | undefined>;
 interface AccountSignerOptions {
     account: GenericAccount;
@@ -166,8 +167,9 @@ export declare class UserClientBuilder {
     get defaultOptions(): BuilderOptions;
     updateAccounts(accountOptions: Partial<AccountSignerOptions>): void;
     clone(): Promise<UserClientBuilder>;
-    publish(): Promise<Awaited<ReturnType<UserClient['publishBuilder']>>>;
-    publish(client?: UserClientOrClientAndNetwork): Promise<Awaited<ReturnType<UserClient['publishBuilder']>>>;
+    publish(options?: PublishOptions): Promise<Awaited<ReturnType<UserClient['publishBuilder']>>>;
+    publish(options?: PublishOptions, client?: UserClientOrClientAndNetwork): Promise<Awaited<ReturnType<UserClient['publishBuilder']>>>;
+    computeFeeBlock(staple: VoteStaple, options?: BuilderBlockOptions, renderOptions?: RenderOptions | UserClientOrClientAndNetwork): Promise<Block>;
     computeBlocks(): Promise<ComputeBlocksResponse>;
     computeBlocks(client?: UserClientOrClientAndNetwork): Promise<ComputeBlocksResponse>;
     computeBlocks(renderOptions: RenderOptions): Promise<ComputeBlocksResponse>;

package/client/client_common_tests.d.ts

@@ -7,6 +7,9 @@ import { UserClient } from '.';
 import { type CreateTestNodeOptions } from '../lib/utils/helper_testing';
 import { toJSONSerializable } from '../lib/utils/conversion';
 import { KeetaNetError as KeetaError } from '../lib/error';
+import { type Block } from '../lib/block';
+import type { Ledger } from '../lib/ledger';
+import type { ComputedEffectOfBlocks } from '../lib/ledger/effects';
 export type ClientParams = {
     ip?: string;
     port?: number;
@@ -37,6 +40,7 @@ export declare function setup(options?: NodeCreationOptions): Promise<{
     cleanupFunctions: (() => Promise<void>)[];
 }>;
 declare function runBasicTests(nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, _ignoreExpectErrorCode: any): Promise<void>;
+declare function runFeeBlockTests(_ignore_nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
 declare function runBuilderStorageTests(_ignoreNodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
 declare function runRecoverAccountTest(nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
 declare function runNonNodeTests(_ignore_nodes: LocalNode[], _ignore_userClient: UserClient, _ignore_trustedClient: UserClient, _ignore_params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
@@ -57,6 +61,20 @@ export declare const clientTests: {
             timeout: number;
         };
     };
+    'Fee Block Tests': {
+        test: typeof runFeeBlockTests;
+        options: {
+            p2pTested: boolean;
+            count: number;
+            customNodeOptions: {
+                ledger: {
+                    computeFeeFromBlocks: (ledger: Ledger, blocks: Block[], effects: ComputedEffectOfBlocks) => {
+                        amount: bigint;
+                    };
+                };
+            }[];
+        };
+    };
     'Builder/Storage Test': {
         test: typeof runBuilderStorageTests;
         options: {

package/client/index-browser.d.ts

@@ -24,8 +24,8 @@ import type { AcceptedPermissionTypes } from '../lib/permissions';
 import { type BlockOperations } from '../lib/block/operations';
 import { Certificate } from '../lib/utils/certificate';
 import { CertificateBundle, type CertificateHash } from '../lib/utils/certificate';
+import { VoteStaple, type VoteQuote } from '../lib/vote';
 type Vote = InstanceType<typeof KeetaNet['Vote']>;
-type VoteStaple = InstanceType<typeof KeetaNet['Vote']['Staple']>;
 type VoteBlocksHash = Vote['blocksHash'];
 /**
  * Account information
@@ -119,6 +119,16 @@ interface CertificateWithIntermediatesResponse {
     certificate: Certificate;
     intermediates: CertificateBundle | null;
 }
+export interface PublishOptions {
+    /**
+     * Client provided function to compute the fee block associated with any transactions
+     */
+    generateFeeBlock?: (staple: VoteStaple) => Promise<Block>;
+    /**
+     * Quotes if provided will be sent to the representative
+     */
+    quotes?: VoteQuote[];
+}
 /**
  */
 interface UserClientOptions {
@@ -146,6 +156,10 @@ interface UserClientOptions {
      * be no account and some operations may not be available.
      */
     account?: GenericAccount;
+    /**
+     * Client provided function to compute the fee block associated with any transactions
+     */
+    generateFeeBlock?: PublishOptions['generateFeeBlock'];
 }
 /**
  * The set of options that are applicable to read-only operations
@@ -324,22 +338,28 @@ export declare class Client {
      * votes and permanent votes for the blocks and then publish them to
      * the network.
      *
-     * @param blocks The blocks or UserClientBuilder to transmit
+     * The `blocks` builder will be computed using {@link computeBuilderBlocks} and then transmitted.
+     *
+     * @param builder The UserClientBuilder to compute and transmit transmit
+     * @param network The network to use for the builder (if using a builder)
      * @return The result of the publish operation
      */
-    transmit(blocks: Block[]): ReturnType<Client['transmitStaple']>;
+    transmitBuilder(builder: UserClientBuilder, network: bigint, options?: PublishOptions): ReturnType<Client['transmit']>;
     /**
      * Transmit a set of blocks to the network.  This will request short
      * votes and permanent votes for the blocks and then publish them to
-     * the network.
+     * the network.  Optionally it will generate a fee block from a user
+     * provided function if fees are required.
      *
-     * The `blocks` builder will be computed using {@link computeBuilderBlocks} and then transmitted.
-     *
-     * @param blocks The UserClientBuilder to compute and transmit transmit
-     * @param network The network to use for the builder (if using a builder)
+     * @param blocks The blocks to transmit
+     * @param options User provided options {@link PublishOptions }
      * @return The result of the publish operation
      */
-    transmit(blocks: UserClientBuilder, network: bigint): ReturnType<Client['transmitStaple']>;
+    transmit(blocks: Block[], options?: PublishOptions): Promise<{
+        voteStaple: VoteStaple;
+        publish: boolean;
+        from: "direct";
+    }>;
     /**
      * Publish a Vote Staple to the network.  This will publish the votes
      * and blocks to the network.
@@ -570,13 +590,13 @@ export declare class Client {
      * that it will always return at least 1 vote staple if there are any
      * vote staples available.
      *
-     * @param account The account to get the history for
+     * @param account The account to get the history for -- if null then the history for all accounts will be returned
      * @param options The options to use for the request
      * @param options.startBlocksHash The block hash to start from -- this is used to paginate the request
      * @param options.depth The maximum number of vote staples to return -- this is used to limit the number of vote staples returned
      * @return The history of vote staples for the given account, in reverse order starting with the most recent vote staple
      */
-    getHistory(account: GenericAccount | string, options?: {
+    getHistory(account: GenericAccount | string | null, options?: {
         startBlocksHash?: VoteBlocksHash | string;
         depth?: number;
     }): Promise<{
@@ -701,6 +721,7 @@ export declare class Client {
      * @param publish Publish the recovered staple to the network (default is true)
      */
     recoverAccount(account: GenericAccount, publish?: boolean): Promise<VoteStaple | null>;
+    getVoteQuotes(blocks: Block[]): Promise<VoteQuote[]>;
     /** Work in progress */
     getLedgerChecksum(rep?: ClientRepresentative | 'ANY'): Promise<{
         moment: string;
@@ -911,9 +932,10 @@ export declare class UserClient {
      * instead of this one.
      *
      * @param builder The builder to publish
+     * @param options options for publishing {@link PublishOptions }
      * @return The vote staple that was generated and whether it was able to be published
      */
-    publishBuilder(builder: UserClientBuilder): Promise<{
+    publishBuilder(builder: UserClientBuilder, options?: PublishOptions): Promise<{
         voteStaple: VoteStaple;
         publish: boolean;
         from: "direct";
@@ -1008,6 +1030,12 @@ export declare class UserClient {
      * @return The vote staple that was generated and whether it was able to be published
      */
     send(to: GenericAccount | string, amount: bigint | number, token: TokenAddress | string, external?: string, options?: UserClientOptions, retries?: number): Promise<Awaited<ReturnType<typeof this.publishBuilder>>>;
+    /**
+     * Gets a quote for the cost for a given set of blocks from each representative
+     * @param blocks
+     * @returns A list of quotes from representatives the client knows about
+     */
+    getQuotes(blocks: Block[]): Promise<VoteQuote[]>;
     /**
      * Generate a new identifier for the given type and publish the blocks
      *
@@ -1089,7 +1117,7 @@ export declare class UserClient {
      * @return The history for the account, paginated
      */
     history(query?: Parameters<Client['getHistory']>[1], options?: UserClientOptionsReadOnly): Promise<{
-        voteStaple: import("../lib/vote").VoteStaple;
+        voteStaple: VoteStaple;
         effects: import("../lib/ledger/effects").ComputedEffectOfBlocks;
     }[]>;
     /**
@@ -1214,7 +1242,7 @@ export declare class UserClient {
     get readonly(): boolean;
 }
 /** @hidden */
-export declare function blockGenerator(seed: string, index: number, transactionCount: number, network?: bigint): Promise<import("../lib/vote").VoteStaple>;
+export declare function blockGenerator(seed: string, index: number, transactionCount: number, network?: bigint): Promise<VoteStaple>;
 /** @hidden */
 export declare function emitBlocks(client: Client, blocks: number, seed: string, index: number, transactionCount: number, network?: bigint): Promise<void>;
 /**