@keetanetwork/keetanet-client 0.12.2 → 0.14.0

package/lib/ledger/index.d.ts

@@ -1,7 +1,7 @@
 import { VoteStaple, Vote, VoteBlockHashMap } from '../vote';
 import { Block, BlockHash } from '../block';
-import type { VoteBlockHash } from '../vote';
-import type { GenericAccount, IdentifierAddress, NetworkAddress, TokenAddress } from '../account';
+import type { FeeAmountAndToken, VoteBlockHash, VoteQuote } from '../vote';
+import type { GenericAccount, IdentifierAddress, NetworkAddress, StorageAddress, TokenAddress } from '../account';
 import Account from '../account';
 import type Node from '../node';
 import type { BloomFilter } from '../utils/bloom';
@@ -31,6 +31,10 @@ export interface LedgerConfig {
      * Private key for the ledger if it is acting as a representative
      */
     privateKey?: Account;
+    /**
+     * Provided function to compute fees for a given set of Blocks and computed effects
+     */
+    computeFeeFromBlocks: (ledger: Ledger, blocks: Block[], effects: ComputedEffectOfBlocks) => FeeAmountAndToken | null;
     /**
      * Storage mechanism
      */
@@ -208,9 +212,9 @@ export interface LedgerStorageAPI {
      */
     getVoteStaples: (transaction: any, voteBlockHashes: VoteBlockHash[], from: LedgerSelector) => Promise<VoteBlockHashMap<VoteStaple | null>>;
     /**
-     * Get the history for a specific account
+     * Get the history for a specific account or all accounts if account is null
      */
-    getHistory: (transaction: any, account: GenericAccount, start: VoteBlockHash | null, limit?: number) => Promise<VoteBlockHash[]>;
+    getHistory: (transaction: any, account: GenericAccount | null, start: VoteBlockHash | null, limit?: number) => Promise<VoteBlockHash[]>;
     /**
      * Get multiple head blocks at the same time for a set of accounts
      */
@@ -250,7 +254,7 @@ export interface LedgerStorageAPI {
     /**
      * Perform Garbage Collection
      */
-    gc: (transaction: any) => Promise<boolean>;
+    gc: (transaction: any, timeLimitMS?: number) => Promise<boolean>;
     /**
      * Get the next serial number for a representative
      */
@@ -276,7 +280,8 @@ declare class LedgerAtomicInterface {
     constructor(transaction: LedgerStorageTransactionBase, storage: LedgerStorageAPI, config: LedgerConfig, ledger: Ledger);
     commit(): Promise<void>;
     abort(): Promise<void>;
-    vote(blocks: Block[], otherVotes?: Vote[]): Promise<Vote>;
+    vote(blocks: Block[], otherVotes?: Vote[], quote?: VoteQuote): Promise<Vote>;
+    quote(blocks: Block[]): Promise<VoteQuote>;
     add(votesAndBlocks: VoteStaple, from?: 'bootstrap' | string): Promise<VoteStaple[]>;
     getBalance(account: GenericAccount, token: TokenAddress): Promise<bigint>;
     getAllBalances(account: GenericAccount): Promise<GetAllBalancesResponse>;
@@ -299,10 +304,11 @@ declare class LedgerAtomicInterface {
     getBlock(blockhash: BlockHash, from?: LedgerSelector): Promise<Block | null>;
     getVoteStaple(stapleBlockHash: VoteBlockHash, from?: LedgerSelector): Promise<VoteStaple | null>;
     getVoteStaples(stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
-    getHistory(account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteStaple[]>;
+    getHistory(account: GenericAccount | null, start: VoteBlockHash | null, limit?: number): Promise<VoteStaple[]>;
     getStaplesFromBlockHashes(hashes: BlockHash[]): Promise<VoteStaple[]>;
     getVoteStaplesAfter(moment: Date, limit?: number, options?: GetVotesAfterOptions): Promise<VoteStaple[]>;
-    gc(): Promise<boolean>;
+    gc(timeLimitMS?: number): Promise<boolean>;
+    getFee(blocks: Block[], effectsInput?: ComputedEffectOfBlocks): Promise<FeeAmountAndToken | null>;
     _testingRunStorageFunction<T>(code: (storage: LedgerStorageAPI, transaction: LedgerStorageTransactionBase) => Promise<T>): Promise<T>;
 }
 /**
@@ -319,6 +325,7 @@ export declare class Ledger implements Omit<LedgerAtomicInterface, 'commit' | 'a
     constructor(config: LedgerConfig, node?: Node, existingStorage?: LedgerStorageAPI);
     get ledgerWriteMode(): NonNullable<LedgerConfig['ledgerWriteMode']>;
     copy(newNode: Node): Ledger;
+    getFeePayToAndToken(accounts?: (Account | StorageAddress)[], token?: TokenAddress): Partial<FeeAmountAndToken>;
     /**
      * Execute some code with a transaction held, if the code fails the
      * transaction is aborted, otherwise it is committed
@@ -330,6 +337,7 @@ export declare class Ledger implements Omit<LedgerAtomicInterface, 'commit' | 'a
     runReadOnly<T>(identifier: string, code: (transaction: LedgerAtomicInterface) => Promise<T>): ReturnType<typeof code>;
     beginTransaction(identifier: string, readOnly?: boolean): Promise<LedgerAtomicInterface>;
     vote(...args: Parameters<LedgerAtomicInterface['vote']>): ReturnType<LedgerAtomicInterface['vote']>;
+    quote(...args: Parameters<LedgerAtomicInterface['quote']>): ReturnType<LedgerAtomicInterface['quote']>;
     add(...args: Parameters<LedgerAtomicInterface['add']>): ReturnType<LedgerAtomicInterface['add']>;
     listACLsByPrincipal(...args: Parameters<LedgerAtomicInterface['listACLsByPrincipal']>): ReturnType<LedgerAtomicInterface['listACLsByPrincipal']>;
     listACLsByEntity(...args: Parameters<LedgerAtomicInterface['listACLsByEntity']>): ReturnType<LedgerAtomicInterface['listACLsByEntity']>;
@@ -352,6 +360,7 @@ export declare class Ledger implements Omit<LedgerAtomicInterface, 'commit' | 'a
     getStaplesFromBlockHashes(...args: Parameters<LedgerAtomicInterface['getStaplesFromBlockHashes']>): ReturnType<LedgerAtomicInterface['getStaplesFromBlockHashes']>;
     getVoteStaplesAfter(...args: Parameters<LedgerAtomicInterface['getVoteStaplesAfter']>): ReturnType<LedgerAtomicInterface['getVoteStaplesAfter']>;
     gc(...args: Parameters<LedgerAtomicInterface['gc']>): ReturnType<LedgerAtomicInterface['gc']>;
+    getFee(...args: Parameters<LedgerAtomicInterface['getFee']>): ReturnType<LedgerAtomicInterface['getFee']>;
     stats(): Promise<LedgerStatistics>;
     _testingRunStorageFunction<T>(code: (storage: LedgerStorageAPI, transaction: LedgerStorageTransactionBase) => Promise<T>): Promise<T>;
 }

package/lib/ledger/types.d.ts

@@ -1,8 +1,12 @@
-import type { GenericAccount, TokenAddress } from '../account';
+import type { Account, GenericAccount, MultisigAddress, TokenAddress } from '../account';
 import type { AdjustMethod } from '../block';
 import type { Permissions } from '../permissions';
 import type { DbStats, TimeStats } from '../stats';
 import type { Certificate, CertificateBundle } from '../utils/certificate';
+export interface MultisigConfig {
+    signers: (Account | MultisigAddress)[];
+    quorum: bigint;
+}
 /**
  * Account info entry
  */
@@ -27,7 +31,12 @@ export interface AccountInfo {
      * The default permissions for the account
      */
     defaultPermission?: Permissions;
+    /**
+     * If this is a multisig account, the number of signers required
+     */
+    multisigQuorum?: bigint;
 }
+export type UserEditableAccountInfo = Omit<AccountInfo, 'supply'>;
 /**
  * Permissions types
  */

package/lib/node/utils.d.ts

@@ -1,4 +1,9 @@
+import Account, { type StorageAddress, type TokenAddress } from '../account';
 import type { NodeConfig } from '.';
 export declare function getConfigFromEnv(type: 'local' | 'lambda'): Partial<Omit<NodeConfig, 'ledger'> & {
     ledger: Partial<NodeConfig['ledger']>;
 }>;
+export declare function getFeeConfigFromEnv(type: 'local' | 'lambda'): {
+    feeAccounts: (Account | StorageAddress)[];
+    feeToken: TokenAddress | undefined;
+};

package/lib/p2p.d.ts

@@ -48,6 +48,10 @@ export interface P2PConfig {
      * Forget about seen message ids after this many milliseconds
      */
     seenMessageTTL?: number;
+    /**
+     * Whether to republish over http or p2p websockets
+     */
+    useHTTPRepublish?: boolean;
 }
 /**
  * Shape of statistics
@@ -66,6 +70,7 @@ export interface P2PSwitchStatistics {
 interface P2PPeerBase {
     kind: NodeKind;
 }
+export type P2PUpdateOptions = 'http' | 'websocket';
 /**
  * Peering information for a Representative (Basic, unsigned information)
  */
@@ -82,6 +87,10 @@ interface P2PPeerRepBase extends P2PPeerBase {
      * Public key of the representative (used as the ID)
      */
     key: Account;
+    /**
+     * Prefer to receive updates over http or websocket
+     */
+    preferUpdates: P2PUpdateOptions;
 }
 /**
  * Peering information for a Representative
@@ -200,6 +209,23 @@ type JSONMessage = {
 };
 export declare function randomizeReps(reps: Representative[]): Representative[];
 export declare function formatRepEndpoints(peers: P2PPeer[]): Representative[];
+export declare class P2PHttpConnection implements P2PConnection {
+    #private;
+    abort: boolean;
+    peer: P2PPeer;
+    validatedPeer: P2PPeer | null;
+    timeout: number;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is P2PHttpConnection;
+    /**
+     * Initiate an outbound http connection and attach it to the specified switch
+     */
+    static initiate(peer: P2PPeer, p2pSwitch: P2PSwitch): Promise<P2PHttpConnection | null>;
+    constructor(peer: P2PPeer, p2pSwitch: P2PSwitch);
+    get connString(): string;
+    get peerString(): string | null;
+    send(messageBuffer: Buffer): Promise<boolean>;
+    close(): Promise<void>;
+}
 /**
  * A P2PConnection using the "ws" package
  */
@@ -275,6 +301,7 @@ export declare class P2PSwitch {
      * Our own peer information
      */
     selfPeer(): Promise<P2PPeer | null>;
+    getOutgoingGreetingInfo(): Promise<JSONSerializableObject>;
     /**
      * Receive a message from a connection
      *
@@ -299,5 +326,10 @@ export declare class P2PSwitch {
      * @returns If the message could be delivered to at least one peer
      */
     sendMessage(to: P2PConnection | Account | P2PPeer | null, id: string, type: string, data: any, ttl?: number, exclude?: (string | P2PConnection)[], skipConnectToPeers?: boolean): Promise<boolean>;
+    /**
+     * TODO - make this private after refactoring websockets to handle higher load
+     * https://github.com/KeetaNetwork/node/issues/785
+     */
+    haveAnyFilter(data: any): Promise<boolean>;
 }
 export default P2PSwitch;

package/lib/permissions.d.ts

@@ -18,7 +18,8 @@ declare enum BaseFlag {
     TOKEN_ADMIN_MODIFY_BALANCE = 7,/* 0x0080 */
     PERMISSION_DELEGATE_ADD = 11,/* 0x0800 */
     PERMISSION_DELEGATE_REMOVE = 12,/* 0x1000 */
-    MANAGE_CERTIFICATE = 13
+    MANAGE_CERTIFICATE = 13,/* 0x2000 */
+    MULTISIG_SIGNER = 14
 }
 type ExternalFlagName = `${typeof externalFlagPrefix}${string}`;
 export type BaseFlagName = keyof typeof BaseFlag;
@@ -42,7 +43,9 @@ declare enum BasePermissionGroup {
     NONIDENTIFIER = 2,
     NETWORK = 3,
     TOKEN = 4,
-    STORAGE = 5
+    STORAGE = 5,
+    NONIDENTIFIER_OR_MULTISIG = 6,
+    MULTISIG = 7
 }
 interface BaseFlagRule {
     canBeDefault: boolean;

package/lib/utils/asn1.d.ts

@@ -59,7 +59,7 @@ declare function jsASN1toJS(input: ArrayBuffer): ASN1AnyJS;
 declare const ASN1toJS: typeof jsASN1toJS, JStoASN1: typeof jsJStoASN1, ASN1IntegerToBigInt: typeof jsIntegerToBigInt, ASN1BigIntToBuffer: typeof jsBigIntToBuffer;
 export declare namespace ValidateASN1 {
     export type Schema = keyof BasicSchemaMap | {
-        choice: Schema[];
+        choice: Schema[] | readonly Schema[];
     } | {
         sequenceOf: Schema;
     } | {
@@ -87,7 +87,7 @@ export declare namespace ValidateASN1 {
     } | {
         type: 'date';
         kind: 'general';
-    } | readonly [Schema, ...Schema[]];
+    } | readonly [Schema, ...Schema[]] | (() => Schema);
     type BasicSchemaMap = {
         [ValidateASN1.IsAny]: ASN1AnyJS;
         [ValidateASN1.IsUnknown]: unknown;
@@ -103,7 +103,7 @@ export declare namespace ValidateASN1 {
         [ValidateASN1.IsSet]: ASN1Set;
         [ValidateASN1.IsNull]: null;
     };
-    export type SchemaMap<T extends Schema> = T extends keyof BasicSchemaMap ? BasicSchemaMap[T] : T extends {
+    export type SchemaMap<T extends Schema> = T extends () => infer U ? U extends Schema ? SchemaMap<U> : never : T extends keyof BasicSchemaMap ? BasicSchemaMap[T] : T extends {
         choice: Schema[];
     } ? SchemaMap<T['choice'][number]> : T extends {
         choice: readonly Schema[];
@@ -163,7 +163,7 @@ export declare class ValidateASN1<T extends ValidateASN1.Schema> {
      * Given a schema, validate the ASN.1 object against it and return the
      * object as the validated type
      */
-    static againstSchema<T extends ValidateASN1.Schema>(input: ASN1AnyJS, schema: T): ValidateASN1.SchemaMap<T>;
+    static againstSchema<T extends ValidateASN1.Schema>(input: ASN1AnyJS, schemaIn: T): ValidateASN1.SchemaMap<T>;
     constructor(schema: T);
     validate(input: ASN1AnyJS): ValidateASN1.SchemaMap<T>;
 }

package/lib/utils/certificate.d.ts

@@ -44,6 +44,7 @@ type CertificateSchema = [
     signatureAlgorithm: ASN1.ASN1OID[],
     signature: ASN1.ASN1BitString
 ];
+type HashNames = 'sha256' | 'sha3-256';
 type CertificateBuilderParams = {
     /**
      * Subject for the certificate, to store as the public key within the certificate
@@ -93,15 +94,45 @@ type CertificateBuilderParams = {
     includeCommonExts?: boolean;
     /**
      * Hashing library to use
+     *
+     * Because several different things are hashed this is
+     * @deprecated Use `hashParams` instead
      */
-    hashLib: {
+    hashLib?: {
         hash: (...args: Parameters<typeof HashLib.Hash>) => ReturnType<typeof HashLib.Hash>;
         name: string;
     };
+    /**
+     * This option lets you control the hashing method used for the
+     * certificate signature as well as provide alternative implementations
+     */
+    hashParams: {
+        functions?: {
+            [name in HashNames]?: (...args: Parameters<typeof HashLib.Hash>) => ReturnType<typeof HashLib.Hash>;
+        };
+        defaults?: {
+            /**
+             * Default hashing function to use for the certificate signature
+             */
+            signature?: HashNames;
+            /**
+             * Default hashing function to use for the Subject Key Identifier
+             */
+            ski?: HashNames;
+            /**
+             * Default hashing function to use for the Authority Key Identifier
+             * (must match the issuer certificate's Subject Key Identifier
+             * hashing function)
+             */
+            aki?: HashNames;
+        };
+    };
 };
 export declare class CertificateBuilder {
     #private;
     constructor(params?: Partial<CertificateBuilderParams>);
+    private static hashName;
+    private static hash;
     /**
      * Construct an extension
      */
@@ -367,6 +398,12 @@ export declare class Certificate {
      * Get the issuer account
      */
     getIssuerAccount(): Account | null;
+    /**
+     * Get the extensions present in the certificate -- this is the raw
+     * extensions as they were parsed from the certificate, and may
+     * contain extensions that are not processed by this class.
+     */
+    getExtensions(): NonNullable<CertificateSchema[0][7]>['contains'] | undefined;
     private assertConstructed;
     /**
      * Compare the certificate with another certificate and return true if they

package/lib/utils/helper.d.ts

@@ -2,6 +2,7 @@ import _crypto from 'crypto';
 import type { JSONSerializable } from './conversion';
 export type DistributiveOmit<T, P extends PropertyKey> = T extends T ? Omit<T, P> : never;
 export declare function bufferToArrayBuffer(input: Buffer): ArrayBuffer;
+export declare function bufferToBigInt(buffer: Buffer): bigint;
 /**
  * Check if a value is an integer or a bigint.
  */
@@ -73,7 +74,7 @@ interface InstanceSet<Instance, Encoded = string> extends Set<Instance> {
  */
 export declare const AsyncDisposableStack: AsyncDisposableStackConstructor;
 export interface InstanceSetConstructor<Instance, Encoded = string> {
-    new (data?: (Instance)[]): InstanceSet<Instance, Encoded>;
+    new (data?: Iterable<(Instance)>): InstanceSet<Instance, Encoded>;
 }
 export declare function setGenerator<P extends WithIsInstance<Instance>, E extends EncodeFunc<Instance, Encoded>, D extends DecodeFunc<Instance, Encoded>, Instance = InstanceType<P>, Encoded = ReturnType<E>>(parent: P, rawEncode: E, rawDecode: D): InstanceSetConstructor<Instance, Encoded>;
 export declare const crypto: {

package/lib/vote.d.ts

@@ -1,5 +1,5 @@
 import { Block, BlockHash } from './block';
-import type { BlockJSON, BlockJSONOutput } from './block';
+import type { BlockJSON, BlockJSONOutput, BlockJSONOutputSerialized } from './block';
 import Account, { AccountKeyAlgorithm, type StorageAddress, type TokenAddress } from './account';
 import type { ASN1Date } from './utils/asn1';
 import { type ToJSONSerializableOptions, type ToJSONSerializable } from './utils/conversion';
@@ -28,14 +28,15 @@ export interface VoteJSON {
     validityTo: string | Date;
     signature: string | ArrayBuffer;
     fee?: FeeAmountAndTokenJSON;
+    quote?: boolean;
 }
 type VoteJSONOutput = ToJSONSerializable<ReturnType<Vote['toJSON']>>;
 export interface VoteStapleJSON {
-    blocks: BlockJSON[] | BlockJSONOutput[];
+    blocks: BlockJSON[] | BlockJSONOutput[] | BlockJSONOutputSerialized[];
     votes: VoteJSON[] | VoteJSONOutput[];
 }
 declare class VoteHash extends BufferStorage {
-    static isInstance: (obj: any, strict?: boolean) => obj is VoteHash;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is VoteHash;
     readonly storageKind = "VoteHash";
     constructor(blockhash: ConstructorParameters<typeof BufferStorage>[0]);
 }
@@ -64,6 +65,7 @@ type CertificatePublicKeyInfo = [CertificateOID[], {
     value: Buffer;
 }];
 export type CertificateExtensionFeeEntry = [
+    quote: boolean,
     amount: bigint,
     payTo?: {
         type: 'context';
@@ -127,7 +129,7 @@ export declare class VoteBlockHashMap<ValueType = unknown> implements Map<VoteBl
  * VoteBlockHash.
  */
 export declare class VoteBlockHash extends BufferStorage {
-    static isInstance: (obj: any, strict?: boolean) => obj is VoteBlockHash;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is VoteBlockHash;
     static readonly Map: typeof VoteBlockHashMap;
     readonly storageKind = "VoteBlockHash";
     get hashFunctionName(): string;
@@ -154,7 +156,7 @@ type VoteBuilderOptions = {
      */
     fee?: FeeAmountAndToken;
 };
-export declare class PossiblyExpiredVote {
+declare class VoteLikeBase {
     #private;
     readonly issuer: Account;
     readonly serial: bigint;
@@ -163,6 +165,8 @@ export declare class PossiblyExpiredVote {
     readonly validityTo: Date;
     readonly signature: ArrayBuffer;
     readonly fee: FeeAmountAndToken | undefined;
+    readonly quote: boolean | undefined;
+    protected static expectedQuoteValue: boolean;
     readonly $trusted: boolean;
     readonly $permanent: boolean;
     readonly $uid: string;
@@ -170,12 +174,14 @@ export declare class PossiblyExpiredVote {
     protected static allowedSlop: number;
     protected static permanentVoteThreshold: number;
     static Staple: typeof VoteStaple;
-    static Builder: typeof VoteBuilder;
+    static Builder: typeof BaseVoteBuilder;
     static readonly VoteBlocksHash: typeof VoteBlockHash;
-    static isInstance: (obj: any, strict?: boolean) => obj is PossiblyExpiredVote;
+    static Quote: typeof VoteQuote;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is VoteLikeBase;
+    protected getClass<T extends typeof VoteLikeBase>(): T;
     static isValidJSON(voteJSON: VoteJSON | VoteJSONOutput): voteJSON is VoteJSON | VoteJSONOutput;
-    static fromJSON(voteJSON: VoteJSON | VoteJSONOutput, options?: VoteOptions): PossiblyExpiredVote | Vote;
-    constructor(vote: Buffer | ArrayBuffer | PossiblyExpiredVote | Uint8Array | string | VoteJSON | VoteJSONOutput, options?: VoteOptions);
+    static fromJSON<T extends typeof VoteLikeBase = typeof VoteLikeBase>(this: T, voteJSON: VoteJSON | VoteJSONOutput, options?: VoteOptions): InstanceType<T>;
+    constructor(vote: Buffer | ArrayBuffer | VoteLikeBase | Uint8Array | string | VoteJSON | VoteJSONOutput, options?: VoteOptions);
     toBytes(): ArrayBuffer;
     get hash(): VoteHash;
     get blocksHash(): VoteBlockHash;
@@ -183,6 +189,7 @@ export declare class PossiblyExpiredVote {
     toJSON(options?: ToJSONSerializableOptions): {
         $binary?: string;
         fee?: FeeAmountAndTokenJSON;
+        quote?: boolean;
         issuer: Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1>;
         serial: bigint;
         blocks: BlockHash[];
@@ -197,21 +204,36 @@ export declare class PossiblyExpiredVote {
     protected expirationCheckMoment(): number;
     get expired(): boolean;
 }
+export declare class PossiblyExpiredVote extends VoteLikeBase {
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is PossiblyExpiredVote;
+    constructor(vote: Buffer | ArrayBuffer | VoteLikeBase | string | VoteJSON | VoteJSONOutput, options?: VoteOptions);
+}
 /**
  * A vote is a certificate issued indicating that the issuer "vouches" for the
  * blocks specified will fit into the ledger of the operator/issuer.
  */
 export declare class Vote extends PossiblyExpiredVote {
+    static Builder: typeof VoteBuilder;
     readonly possiblyExpired = false;
-    static isInstance: (obj: any, strict?: boolean) => obj is Vote;
-    constructor(vote: Buffer | ArrayBuffer | Vote | PossiblyExpiredVote | string | VoteJSON | VoteJSONOutput, options?: VoteOptions);
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is Vote;
+    constructor(vote: Buffer | ArrayBuffer | VoteLikeBase | string | VoteJSON | VoteJSONOutput, options?: VoteOptions);
+}
+/**
+ * A VoteQuote is a certificate issued indicating what the issuer will charge for fees
+ */
+export declare class VoteQuote extends VoteLikeBase {
+    static Builder: typeof VoteQuoteBuilder;
+    protected static expectedQuoteValue: boolean;
+    readonly isVoteQuote = true;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is VoteQuote;
+    constructor(vote: Buffer | ArrayBuffer | VoteLikeBase | string | VoteJSON | VoteJSONOutput, options?: VoteOptions);
 }
 /**
  * A vote staple is a distributable block consisting of one or more blocks
  * and one or more votes.
  */
 declare class VoteStapleHash extends BufferStorage {
-    static isInstance: (obj: any, strict?: boolean) => obj is VoteStapleHash;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is VoteStapleHash;
     readonly storageKind = "VoteStapleHash";
     get hashFunctionName(): string;
     constructor(stapleHash: ConstructorParameters<typeof BufferStorage>[0]);
@@ -230,7 +252,7 @@ export declare class VoteBlockBundle {
     readonly votes: Vote[];
     readonly blocks: Block[];
     static readonly VoteBlockHash: typeof VoteBlockHash;
-    static isInstance: (obj: any, strict?: boolean) => obj is VoteBlockBundle;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is VoteBlockBundle;
     /**
      * Construct a new vote bundle from votes and blocks
      */
@@ -283,6 +305,7 @@ export declare class VoteBlockBundle {
         votes: {
             $binary?: string;
             fee?: FeeAmountAndTokenJSON;
+            quote?: boolean;
             issuer: Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1>;
             serial: bigint;
             blocks: BlockHash[];
@@ -296,12 +319,14 @@ export declare class VoteBlockBundle {
         }[];
         blocks: {
             $binary?: string;
-            version: 1;
+            signature?: string;
+            signatures?: string[];
+            version: 1 | 2;
             date: Date;
             previous: BlockHash;
             account: import("./account").GenericAccount;
-            signer: Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1>;
-            signature: string;
+            purpose: import("./block").BlockPurpose;
+            signer: Account | [import("./account").MultisigAddress, any[]];
             network: bigint;
             subnet: bigint | undefined;
             operations: import("./block/operations").ExportedJSONOperation[];
@@ -311,12 +336,13 @@ export declare class VoteBlockBundle {
     };
 }
 export declare class VoteStaple extends VoteBlockBundle {
-    static isInstance: (obj: any, strict?: boolean) => obj is VoteStaple;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is VoteStaple;
     constructor(votesStapled: ArrayBuffer | Buffer | VoteStapleJSON | string, voteOptions?: VoteOptions);
 }
-export declare class VoteBuilder {
+export declare class BaseVoteBuilder {
     #private;
-    static isInstance: (obj: any, strict?: boolean) => obj is VoteBuilder;
+    protected quote: boolean;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is BaseVoteBuilder;
     constructor(account: Account, blocks?: (Block | BlockHash)[], options?: VoteBuilderOptions);
     addBlocks(blocks: (Block | BlockHash | string)[]): void;
     addBlock(block: Block | BlockHash | string): void;
@@ -326,7 +352,16 @@ export declare class VoteBuilder {
         tbsCertificate: CertificateSchema;
         signatureInfo: CertificateOID[];
     };
-    createVote(voteData: ArrayBuffer, tbsCertificate: CertificateSchema, signatureInfo: CertificateOID[], signature: BufferStorage, voteOptions?: VoteOptions): Vote;
+    createVote(voteData: ArrayBuffer, tbsCertificate: CertificateSchema, signatureInfo: CertificateOID[], signature: BufferStorage): ArrayBuffer;
+    protected generate(serial: bigint, validTo: Date | null, validFrom?: Date): Promise<ArrayBuffer>;
+}
+export declare class VoteBuilder extends BaseVoteBuilder {
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is VoteBuilder;
     seal(serial: bigint, validTo: Date | null, validFrom?: Date, voteOptions?: VoteOptions): Promise<Vote>;
 }
+export declare class VoteQuoteBuilder extends BaseVoteBuilder {
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is VoteQuoteBuilder;
+    protected quote: boolean;
+    seal(serial: bigint, validTo: Date | null, validFrom?: Date, voteOptions?: VoteOptions): Promise<VoteQuote>;
+}
 export default Vote;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@keetanetwork/keetanet-client",
 	"repository": "https://github.com/keetanetwork/node.git",
-	"version": "0.12.2",
+	"version": "0.14.0",
 	"description": "KeetaNet Client TypeScript Reference Implementation",
 	"files": [
 		"**/*.js",

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "0.12.2+g77a8a16ada9dfab5604b605cbe69d373a414d204";
+export declare const version = "0.14.0+g8b0bdc16c0cba85135437a9ffb3a8cea2dae170d";
 export default version;