@keetanetwork/keetanet-client 0.12.0 → 0.14.0

package/lib/block/operations.d.ts

@@ -1,12 +1,13 @@
 import { ValidateASN1 } from '../utils/asn1';
 import type { DeepMutable } from '../utils/helper';
-import type { GenericAccount, IdentifierAddress, TokenAddress, TokenPublicKeyString } from '../account';
-import Account from '../account';
+import type { GenericAccount, IdentifierAddress, IdentifierKeyAlgorithm, TokenAddress, TokenPublicKeyString } from '../account';
+import Account, { AccountKeyAlgorithm } from '../account';
 import type { AcceptedPermissionTypes } from '../permissions';
 import { Permissions } from '../permissions';
 import type { ToJSONSerializable } from '../utils/conversion';
 import Block, { AdjustMethod } from '.';
 import { Certificate, CertificateBundle, CertificateHash } from '../utils/certificate';
+import type { MultisigConfig } from '../ledger/types';
 /**
  * All supported operations
  */
@@ -110,6 +111,20 @@ declare const BlockOperationASN1SchemaBase: {
     readonly CREATE_IDENTIFIER: [{
         readonly name: "identifier";
         readonly schema: typeof ValidateASN1.IsOctetString;
+    }, {
+        readonly name: "createArguments";
+        readonly schema: {
+            readonly optional: {
+                readonly choice: [{
+                    readonly type: "context";
+                    readonly kind: "explicit";
+                    readonly value: 7;
+                    readonly contains: readonly [{
+                        readonly sequenceOf: typeof ValidateASN1.IsOctetString;
+                    }, typeof ValidateASN1.IsInteger];
+                }];
+            };
+        };
     }];
     readonly TOKEN_ADMIN_SUPPLY: [{
         readonly name: "amount";
@@ -264,9 +279,16 @@ declare class BlockOperationSET_REP extends BlockOperation implements BlockJSONO
 /**
  * TokenCreate Operation
  */
+interface BaseIdentifierCreateArguments<KeyType extends IdentifierKeyAlgorithm> {
+    type: KeyType;
+}
+interface MultiSigIdentifierCreateArguments extends BaseIdentifierCreateArguments<AccountKeyAlgorithm.MULTISIG>, MultisigConfig {
+}
+export type IdentifierCreateArguments = MultiSigIdentifierCreateArguments;
 export interface BlockJSONOperationCREATE_IDENTIFIER extends BlockJSONOperation {
     type: OperationType.CREATE_IDENTIFIER;
     identifier: IdentifierAddress | string;
+    createArguments?: ToJSONSerializable<IdentifierCreateArguments> | IdentifierCreateArguments;
 }
 declare class BlockOperationCREATE_IDENTIFIER extends BlockOperation implements BlockJSONOperationCREATE_IDENTIFIER {
     #private;
@@ -275,6 +297,8 @@ declare class BlockOperationCREATE_IDENTIFIER extends BlockOperation implements
     constructor(input: BlockJSONOperationCREATE_IDENTIFIER);
     set identifier(identifier: string | IdentifierAddress);
     get identifier(): IdentifierAddress;
+    set createArguments(input: IdentifierCreateArguments | ToJSONSerializable<IdentifierCreateArguments> | undefined);
+    get createArguments(): IdentifierCreateArguments | undefined;
     validate(context: BlockOperationValidateContext): void;
     toJSON(): BlockJSONOperationCREATE_IDENTIFIER;
 }
@@ -441,7 +465,11 @@ export declare function ExportBlockOperations(operations: BlockOperations[]): ((
     value: OperationType.MODIFY_PERMISSIONS;
     kind: "explicit";
 }) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
-    contains: [Buffer];
+    contains: [Buffer, (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {
+        contains: [Buffer[], bigint];
+        value: 7;
+        kind: "explicit";
+    }) | undefined];
     value: OperationType.CREATE_IDENTIFIER;
     kind: "explicit";
 }) | (Omit<import("../utils/asn1").ASN1ContextTag, "kind" | "value" | "contains"> & {

package/lib/error/block.d.ts

@@ -1,6 +1,6 @@
 import { KeetaNetError } from '.';
 declare const BlockErrorType: "BLOCK";
-declare const BlockErrorCodes: readonly ["INVALID_TYPE", "INVALID_VERSION", "NO_MULTIPLE_SET_REP", "IDENTIFIER_NEED_DEFAULT_PERMISSIONS", "CANNOT_SEND_NON_TOKEN", "TOKEN_RECEIVE_DIFFERS", "ONLY_TOKEN_OP", "ONLY_IDENTIFIER_OP", "NO_TOKEN_OP", "NO_IDENTIFIER_OP", "NO_MULTISIG_OP", "IDENTIFIER_INVALID", "GENERAL_FIELD_INVALID", "PERMISSIONS_INVALID_DEFAULT", "PERMISSIONS_INVALID_ENTITY", "PERMISSIONS_INVALID_PRINCIPAL", "PERMISSIONS_INVALID_TARGET", "INVALID_ACCOUNT_TYPE", "NO_ADMIN_ON_TARGET", "PREVIOUS_SELF", "NO_DELEGATE_ADMIN", "NO_MODIFY_PERMISSION_DUPE", "CANNOT_FORWARD_TO_SELF", "EXACT_TRUE_WHEN_FORWARDING", "CERTIFICATE_SUBJECT_MISMATCH", "NO_DUPLICATE_CERTIFICATE_OPERATION", "INTERMEDIATE_CERTIFICATES_ONLY_ADD", "INVALID_CERTIFICATE_VALUE", "EXTERNAL_TOO_LONG", "EXTERNAL_INVALID", "EXTERNAL_MISSING", "SUPPLY_INVALID"];
+declare const BlockErrorCodes: readonly ["INVALID_TYPE", "INVALID_VERSION", "NO_MULTIPLE_SET_REP", "IDENTIFIER_NEED_DEFAULT_PERMISSIONS", "CANNOT_SEND_NON_TOKEN", "TOKEN_RECEIVE_DIFFERS", "ONLY_TOKEN_OP", "ONLY_IDENTIFIER_OP", "NO_TOKEN_OP", "NO_IDENTIFIER_OP", "INVALID_SIGNER", "INVALID_PURPOSE_VALIDATION", "INVALID_MULTISIG_QUORUM", "INVALID_MULTISIG_SIGNER_DEPTH", "INVALID_MULTISIG_SIGNER_COUNT", "INVALID_MULTISIG_SIGNER_DUPLICATE", "INVALID_CREATE_IDENTIFIER_ARGS", "NO_MULTISIG_OP", "IDENTIFIER_INVALID", "GENERAL_FIELD_INVALID", "PERMISSIONS_INVALID_DEFAULT", "PERMISSIONS_INVALID_ENTITY", "PERMISSIONS_INVALID_PRINCIPAL", "PERMISSIONS_INVALID_TARGET", "INVALID_ACCOUNT_TYPE", "NO_ADMIN_ON_TARGET", "PREVIOUS_SELF", "NO_DELEGATE_ADMIN", "NO_MODIFY_PERMISSION_DUPE", "CANNOT_FORWARD_TO_SELF", "EXACT_TRUE_WHEN_FORWARDING", "CERTIFICATE_SUBJECT_MISMATCH", "NO_DUPLICATE_CERTIFICATE_OPERATION", "INTERMEDIATE_CERTIFICATES_ONLY_ADD", "INVALID_CERTIFICATE_VALUE", "EXTERNAL_TOO_LONG", "EXTERNAL_INVALID", "EXTERNAL_MISSING", "SUPPLY_INVALID"];
 export type BlockErrorCode = `${typeof BlockErrorType}_${typeof BlockErrorCodes[number]}`;
 export default class KeetaNetBlockError extends KeetaNetError {
     static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetBlockError;

package/lib/error/ledger.d.ts

@@ -1,6 +1,6 @@
 import { KeetaNetError } from '.';
 declare const LedgerErrorType: "LEDGER";
-declare const LedgerErrorCodes: readonly ["TRANSACTION_ABORTED", "INVALID_CHAIN", "INVALID_NETWORK", "INVALID_SUBNET", "NOT_EMPTY", "NOT_OPENING", "NOT_SUCCESSOR", "INVALID_PERMISSIONS", "INVALID_OWNER_COUNT", "INVALID_BALANCE", "PREVIOUS_ALREADY_USED", "PREVIOUS_NOT_SEEN", "SUCCESSOR_VOTE_EXISTS", "INSUFFICIENT_VOTING_WEIGHT", "INVALID_ACCOUNT_INFO_KEY", "RECEIVE_NOT_MET", "DUPLICATE_VOTE_FOUND", "CANNOT_EXCHANGE_PERM_VOTE", "BLOCKS_DIFFER_FROM_VOTED_ON", "NO_PERM_WITHOUT_SELF_TEMP", "DUPLICATE_VOTE_ISSUER_FOUND", "OTHER"];
+declare const LedgerErrorCodes: readonly ["TRANSACTION_ABORTED", "INVALID_CHAIN", "INVALID_NETWORK", "INVALID_SUBNET", "NOT_EMPTY", "NOT_OPENING", "NOT_SUCCESSOR", "INVALID_PERMISSIONS", "INVALID_OWNER_COUNT", "INVALID_BALANCE", "PREVIOUS_ALREADY_USED", "PREVIOUS_NOT_SEEN", "SUCCESSOR_VOTE_EXISTS", "INSUFFICIENT_VOTING_WEIGHT", "INVALID_ACCOUNT_INFO_KEY", "RECEIVE_NOT_MET", "DUPLICATE_VOTE_FOUND", "CANNOT_EXCHANGE_PERM_VOTE", "BLOCKS_DIFFER_FROM_VOTED_ON", "NO_PERM_WITHOUT_SELF_TEMP", "DUPLICATE_VOTE_ISSUER_FOUND", "OTHER", "MISSING_BLOCKS", "FEE_AMOUNT_MISMATCH", "FEE_TOKEN_MISMATCH", "FEE_MISSING", "MISSING_REQUIRED_FEE_BLOCK", "PERM_VOTE_WITH_QUOTE", "QUOTE_MISMATCH", "REQUIRED_FEE_MISMATCH"];
 export type LedgerErrorCode = `${typeof LedgerErrorType}_${typeof LedgerErrorCodes[number]}`;
 export declare class KeetaNetLedgerError extends KeetaNetError {
     static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetLedgerError;

package/lib/error/vote.d.ts

@@ -1,6 +1,6 @@
 import { KeetaNetError } from '.';
 declare const VoteErrorType: "VOTE";
-declare const VoteErrorCodes: readonly ["SERIAL_MISMATCH", "INVALID_VERSION", "INVALID_CONSTRUCTION", "INVALID_CONSTRUCTION_JSON", "SIGNATURE_INVALID", "EXPIRED", "INVALID_VALIDITY", "MOMENT_BEFORE_VALIDITY_FROM", "STAPLE_INVALID_CONSTRUCTION", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_COUNT", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_MISSING", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_ORDER", "STAPLE_DUPLICATE_VOTE_ISSUER", "STAPLE_PERMANENCE_MISMATCH", "BUILDER_INVALID_CONSTRUCTION", "BUILDER_INVALID_BLOCK_TYPE", "BUILDER_INVALID_SERIAL", "BUILDER_INVALID_VALID_TO_FROM", "MALFORMED_WRAPPER", "MALFORMED_VOTE_WRAPPER", "MALFORMED_VOTE_CONTENT", "MALFORMED_VOTE_CONTENT_EXTRA_DATA", "MALFORMED_VOTE_VERSION", "MALFORMED_VOTE_SERIAL", "MALFORMED_VOTE_SIGNATURE_INFORMATION", "MALFORMED_VOTE_ISSUER_INFORMATION", "MALFORMED_VOTE_SUBJECT_INFORMATION", "MALFORMED_VOTE_VALIDITY_INFORMATION", "MALFORMED_VOTE_SERIAL", "MALFORMED_VOTE_EXTENSIONS", "MALFORMED_VOTE_EXTENSIONS_VALUE", "MALFORMED_VOTE_EXTENSIONS_VALUE_OID", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE", "MALFORMED_VOTE_EXTENSIONS_VALUE_HASH_DATA", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_WRAPPER", "MALFORMED_VOTE_SIGNATURE_SCHEME_ECDSA_INVALID_CURVE", "MALFORMED_VOTE_SIGNATURE_UNSUPPORTED_SCHEME", "MALFORMED_VOTE_SUBJECT_PUBLIC_KEY_INFORMATION", "MALFORMED_VOTE_SIGNATURE_VALUE", "MALFORMED_VOTE_NO_BLOCKS_FOUND", "MALFORMED_STAPLE", "MALFORMED_STAPLE_BLOCKS", "MALFORMED_STAPLE_BLOCKS_AT_LEAST_ONE", "MALFORMED_STAPLE_VOTES", "MALFORMED_STAPLE_VOTES_AT_LEAST_ONE", "MALFORMED_FIND_RDN_INVALID_TYPE", "MALFORMED_FIND_RDN_MUST_HAVE_ONE", "MALFORMED_FIND_RDN_PART_WELL_FORMED", "MALFORMED_FIND_RDN_MUST_BE_SET", "MALFORMED_FIND_RDN_TYPE_MUST_BE_OID", "MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT", "MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE", "MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC", "MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID", "MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE", "MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE", "MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE"];
+declare const VoteErrorCodes: readonly ["SERIAL_MISMATCH", "INVALID_VERSION", "INVALID_CONSTRUCTION", "INVALID_CONSTRUCTION_JSON", "SIGNATURE_INVALID", "EXPIRED", "INVALID_VALIDITY", "MOMENT_BEFORE_VALIDITY_FROM", "STAPLE_INVALID_CONSTRUCTION", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_COUNT", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_MISSING", "STAPLE_ALL_VOTES_MUST_HAVE_SAME_BLOCKS_ORDER", "STAPLE_DUPLICATE_VOTE_ISSUER", "STAPLE_PERMANENCE_MISMATCH", "BUILDER_INVALID_CONSTRUCTION", "BUILDER_INVALID_BLOCK_TYPE", "BUILDER_INVALID_SERIAL", "BUILDER_INVALID_VALID_TO_FROM", "MALFORMED_WRAPPER", "MALFORMED_VOTE_WRAPPER", "MALFORMED_VOTE_CONTENT", "MALFORMED_VOTE_CONTENT_EXTRA_DATA", "MALFORMED_VOTE_VERSION", "MALFORMED_VOTE_SERIAL", "MALFORMED_VOTE_SIGNATURE_INFORMATION", "MALFORMED_VOTE_ISSUER_INFORMATION", "MALFORMED_VOTE_SUBJECT_INFORMATION", "MALFORMED_VOTE_VALIDITY_INFORMATION", "MALFORMED_VOTE_SERIAL", "MALFORMED_VOTE_EXTENSIONS", "MALFORMED_VOTE_EXTENSIONS_DATA", "MALFORMED_VOTE_EXTENSIONS_VALUE", "MALFORMED_VOTE_EXTENSIONS_VALUE_OID", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL", "MALFORMED_VOTE_EXTENSIONS_VALUE_CRITICAL_TYPE", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER", "MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_WRAPPER", "MALFORMED_VOTE_SIGNATURE_SCHEME_ECDSA_INVALID_CURVE", "MALFORMED_VOTE_SIGNATURE_UNSUPPORTED_SCHEME", "MALFORMED_VOTE_SUBJECT_PUBLIC_KEY_INFORMATION", "MALFORMED_VOTE_SIGNATURE_VALUE", "MALFORMED_VOTE_NO_BLOCKS_FOUND", "MALFORMED_STAPLE", "MALFORMED_STAPLE_BLOCKS", "MALFORMED_STAPLE_BLOCKS_AT_LEAST_ONE", "MALFORMED_STAPLE_VOTES", "MALFORMED_STAPLE_VOTES_AT_LEAST_ONE", "MALFORMED_FIND_RDN_INVALID_TYPE", "MALFORMED_FIND_RDN_MUST_HAVE_ONE", "MALFORMED_FIND_RDN_PART_WELL_FORMED", "MALFORMED_FIND_RDN_MUST_BE_SET", "MALFORMED_FIND_RDN_TYPE_MUST_BE_OID", "MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT", "MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE", "MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC", "MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID", "MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE", "MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC", "MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE", "MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE", "MALFORMED_FEES_AMOUNT", "MALFORMED_FEES_FROM_VOTE_INVALID_INPUT", "MALFORMED_FEES_IN_PERMANENT_VOTE", "MALFORMED_FEES_PAY_TO_INVALID", "MALFORMED_FEES_TOKEN_NOT_TOKEN", "FEE_IS_QUOTE", "FEE_QUOTE_MISSING_FEES", "FEE_NOT_QUOTE", "MALFORMED_FEES_KIND_MISSING", "MALFORMED_FEES_QUOTE_INVALID"];
 export type VoteErrorCode = `${typeof VoteErrorType}_${typeof VoteErrorCodes[number]}`;
 export default class KeetaNetVoteError extends KeetaNetError {
     static isInstance: (obj: any, strict?: boolean) => obj is KeetaNetVoteError;

package/lib/ledger/common.d.ts

@@ -57,6 +57,8 @@ interface ComputeLedgerEffectOptions<T extends boolean, P extends boolean, W ext
     baseToken: TokenAddress;
 }
 export declare function validateSupply(amount: bigint, network: bigint): void;
+export declare function validateBlockSignerCount(amount: bigint, network: bigint): void;
+export declare function validateBlockSignerDepth(depth: bigint, network: bigint): void;
 /**
  * Compute effects on the ledger from block effects
  */
@@ -87,6 +89,7 @@ type AccountInfoUnparsedRow = {
     description?: string;
     metadata?: string;
     supply?: bigint | string;
+    multisigQuorum?: bigint | string;
     defaultBasePermission?: string | bigint | BaseSet;
     defaultExternalPermission?: string | bigint | ExternalSet;
 };
@@ -116,10 +119,20 @@ export declare abstract class LedgerStorageBase {
     }>;
     _formatAccountInfoFromRow(account: GenericAccount, row?: AccountInfoUnparsedRow | undefined): AccountInfo;
     _validateAccountInfoKeys(account: GenericAccount, info: Partial<AccountInfo>): void;
+    /**
+     * @param moment - The date to use as the base for the timestamp.
+     * @param momentBits - The number of bits to use for the timestamp
+     * @param totalLength - The total length of the generated number in bits
+     * @param randomData - A hexadecimal string to use as the random data.
+     * @param timestampFuzzMS - The number of milliseconds to fuzz the timestamp by, defaults to 1n (precise).
+     * @param optimistic - If true, the timestamp will be incremented by 1 quanta, defaults to false.
+     * @returns A bigint representing the noisy timestamp.
+     */
+    _generateNoisyTimestamp(moment: Date, momentBits: bigint, totalLength: bigint, randomData: Buffer, timestampFuzzMS?: number | bigint, optimistic?: boolean): bigint;
     getHeadBlock(transaction: any, account: GenericAccount, from: LedgerSelector): Promise<Block | null>;
     getVotesFromPrevious(transaction: any, prevBlock: BlockHash, from: LedgerSelector, issuer?: Account): Promise<Vote[] | null>;
     protected abstract gcBatch(transaction: any): Promise<boolean>;
-    gc(transaction: any): Promise<boolean>;
+    gc(transaction: any, timeLimitMS?: number): Promise<boolean>;
 }
 export declare function assertLedgerStorage(value: string): LedgerStorage;
 export {};

package/lib/ledger/db_dynamodb.d.ts

@@ -41,7 +41,7 @@ declare class DynamoDBTransaction implements LedgerStorageTransactionBase {
     getBlockHeight(blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
     getVotes(block: BlockHash, from: LedgerSelector, issuer?: Account, transactionAlreadyVerifiedActiveByCaller?: boolean): Promise<Vote[] | null>;
     getVoteStaple(stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
-    getHistory(account: GenericAccount, start: VoteBlockHash | null, limit: number): Promise<VoteBlockHash[]>;
+    getHistory(account: GenericAccount | null, start: VoteBlockHash | null, limit: number): Promise<VoteBlockHash[]>;
     getVotesFromMultiplePrevious(prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
         [hash: string]: Vote[] | null;
     }>;
@@ -86,7 +86,7 @@ export declare class DBDynamoDB extends LedgerStorageBase implements LedgerStora
     getBlockHeight(transaction: DynamoDBTransaction, blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
     getVotes(transaction: DynamoDBTransaction, block: BlockHash, from: LedgerSelector): Promise<Vote[] | null>;
     getVoteStaples(transaction: DynamoDBTransaction, stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
-    getHistory(transaction: DynamoDBTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
+    getHistory(transaction: DynamoDBTransaction, account: GenericAccount | null, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
     getVotesFromMultiplePrevious(transaction: DynamoDBTransaction, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
         [hash: string]: Vote[] | null;
     }>;

package/lib/ledger/db_postgres.d.ts

@@ -47,7 +47,7 @@ export declare class DBPostgres extends LedgerStorageBase implements LedgerStora
     getBlockHeight(transaction: PostgresTransaction, blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
     getVotes(transaction: PostgresTransaction, block: BlockHash, from: LedgerSelector, issuer?: GenericAccount): Promise<Vote[] | null>;
     getVoteStaples(transaction: PostgresTransaction, stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
-    getHistory(transaction: PostgresTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
+    getHistory(transaction: PostgresTransaction, account: GenericAccount | null, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
     getBlockFromPrevious(transaction: PostgresTransaction, prevBlock: BlockHash, from: LedgerSelector): Promise<Block | null>;
     getVotesFromMultiplePrevious(transaction: PostgresTransaction, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
         [hash: string]: Vote[] | null;

package/lib/ledger/db_spanner.d.ts

@@ -93,7 +93,7 @@ export declare class DBSpanner extends LedgerStorageBase implements LedgerStorag
     getBlockHeight(transaction: SpannerTransaction, blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
     getVotes(transaction: SpannerTransaction, blockHash: BlockHash, from: LedgerSelector): Promise<Vote[] | null>;
     getVoteStaples(transaction: SpannerTransaction, stapleBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
-    getHistory(transaction: SpannerTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
+    getHistory(transaction: SpannerTransaction, account: GenericAccount | null, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
     getBlockFromPrevious(transaction: SpannerTransaction, prevBlock: BlockHash, from: LedgerSelector): Promise<Block | null>;
     getVotesFromMultiplePrevious(transaction: SpannerTransaction, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: Account): Promise<{
         [hash: string]: Vote[] | null;

package/lib/ledger/db_spanner_helper.d.ts

@@ -184,7 +184,21 @@ declare const ColumnTypes: {
         fromSpanner: (pubKey: string) => GenericAccount;
         toSpanner: (account: GenericAccount) => import("../account").TokenPublicKeyString | import("../account").NetworkPublicKeyString | import("../account").StoragePublicKeyString | import("../account").MultisigPublicKeyString | import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString;
     };
-    readonly BUFFER_BIGINT: {
+    readonly BUFFER_BIGINT_39: {
+        dbType: string;
+        dbSize: string;
+        toSpanner: (buf: bigint) => Buffer;
+        fromSpanner: (value: Buffer) => bigint;
+        toComparable: (val: Buffer | bigint | string) => bigint;
+    };
+    readonly BUFFER_BIGINT_16: {
+        dbType: string;
+        dbSize: string;
+        toSpanner: (buf: bigint) => Buffer;
+        fromSpanner: (value: Buffer) => bigint;
+        toComparable: (val: Buffer | bigint | string) => bigint;
+    };
+    readonly BUFFER_BIGINT_8: {
         dbType: string;
         dbSize: string;
         toSpanner: (buf: bigint) => Buffer;
@@ -231,6 +245,7 @@ declare const schema: {
             readonly description: ColumnInterface<"INFO_DESCRIPTION", true>;
             readonly metadata: ColumnInterface<"INFO_METADATA", true>;
             readonly supply: ColumnInterface<"SUPPLY", true>;
+            readonly multisigQuorum: ColumnInterface<"BIGINT", true>;
             readonly defaultBasePermission: ColumnInterface<"BASE_PERMISSION", true>;
             readonly defaultExternalPermission: ColumnInterface<"EXTERNAL_PERMISSION", true>;
         };
@@ -274,7 +289,7 @@ declare const schema: {
         readonly columns: {
             readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
             readonly voteBlockHash: ColumnInterface<"VOTEBLOCKHASH", false>;
-            readonly orderIndex: ColumnInterface<"BUFFER_BIGINT", false>;
+            readonly orderIndex: ColumnInterface<"BUFFER_BIGINT_39", false>;
         };
         readonly key: readonly [Key, Key];
         readonly interleave: Interleave;
@@ -295,9 +310,10 @@ declare const schema: {
             readonly onLedger: ColumnInterface<"LEDGER", false>;
             readonly vote: ColumnInterface<"VOTE", false>;
             readonly timestamp: ColumnInterface<"TIMESTAMP", false>;
-            readonly expires: ColumnInterface<"TIMESTAMP", false>;
             readonly issuer: ColumnInterface<"ACCOUNT", false>;
             readonly voteBlockHash: ColumnInterface<"VOTEBLOCKHASH", false>;
+            readonly orderIndex: ColumnInterface<"BUFFER_BIGINT_16", false>;
+            readonly expiresIndex: ColumnInterface<"BUFFER_BIGINT_8", true>;
         };
         readonly key: readonly [Key, Key];
     };
@@ -370,6 +386,12 @@ declare const schema: {
         readonly table: "history";
         readonly key: readonly [Key, Key];
     };
+    readonly historyOrdered: {
+        readonly type: "INDEX";
+        readonly table: "history";
+        readonly key: readonly [Key];
+        readonly storing: readonly [Key];
+    };
     readonly chainAccountHash: {
         readonly type: "INDEX";
         readonly table: "chain";
@@ -383,15 +405,16 @@ declare const schema: {
         readonly key: readonly [Key];
         readonly storing: readonly [Key];
     };
-    readonly votesTimestamp: {
+    readonly votesOrderIndex: {
         readonly type: "INDEX";
         readonly table: "votes";
         readonly key: readonly [Key, Key];
         readonly storing: readonly [Key];
     };
-    readonly votesOnLedgerExpired: {
+    readonly votesExpiredIndex: {
         readonly type: "INDEX";
         readonly table: "votes";
+        readonly nullFiltered: true;
         readonly key: readonly [Key, Key];
         readonly storing: readonly [Key];
     };

package/lib/ledger/db_sqlite.d.ts

@@ -46,7 +46,7 @@ export declare class DBSqlite extends LedgerStorageBase implements LedgerStorage
     getBlockHeight(transaction: DBSqliteTransaction, blockHash: BlockHash, account: GenericAccount): Promise<bigint | null>;
     getVotes(transaction: DBSqliteTransaction, block: BlockHash, from: LedgerSelector): Promise<Vote[] | null>;
     getVoteStaples(transaction: DBSqliteTransaction, voteBlockHashes: VoteBlockHash[], from?: LedgerSelector): Promise<VoteBlockHashMap<VoteStaple | null>>;
-    getHistory(transaction: DBSqliteTransaction, account: GenericAccount, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
+    getHistory(transaction: DBSqliteTransaction, account: GenericAccount | null, start: VoteBlockHash | null, limit?: number): Promise<VoteBlockHash[]>;
     getBlockFromPrevious(transaction: DBSqliteTransaction, prevBlock: BlockHash, from: LedgerSelector): Promise<Block | null>;
     getVotesFromMultiplePrevious(transaction: DBSqliteTransaction, prevBlocks: BlockHash[], from: LedgerSelector, issuer?: GenericAccount): Promise<{
         [hash: string]: Vote[] | null;

package/lib/ledger/effects.d.ts

@@ -1,8 +1,9 @@
 import type { GenericAccount, IdentifierAddress, NetworkAddress, TokenAddress } from '../account';
 import Account from '../account';
-import type { AdjustMethod, BlockHash } from '../block';
+import type { AdjustMethod } from '../block';
 import { Block } from '../block';
-import type { AccountInfo, ACLEntry, ACLUpdate } from '../ledger/types';
+import type * as Operations from '../block/operations';
+import type { UserEditableAccountInfo, ACLEntry, ACLUpdate } from '../ledger/types';
 import type { Certificate, CertificateBundle } from '../utils/certificate';
 import { CertificateHash } from '../utils/certificate';
 interface NumericValueEntry {
@@ -41,24 +42,23 @@ interface ComputedBlocksEffectTokenChangesField {
 /**
  * Which fields may be affected by blocks
  */
-type CreateIdentifierRequest = {
-    previousBlockHash: BlockHash;
-    requestedIdentifier: IdentifierAddress;
-    operationIndex: number;
-    account: GenericAccount;
-};
+interface CreateIdentifierRequest {
+    createdIdentifier: IdentifierAddress;
+    createArguments?: Operations.IdentifierCreateArguments;
+}
 type DelegationUpdate = {
     delegateTo: Account;
 };
 interface ComputedBlocksEffectFields {
     balance?: ComputedBlocksEffectTokenChangesField;
     supply?: NumericValueEntry[];
-    info?: AccountInfo;
+    info?: Partial<UserEditableAccountInfo>;
     permissions?: ACLUpdate[];
     permissionRequirements?: ACLEntry[];
     createRequests?: CreateIdentifierRequest[];
     delegation?: DelegationUpdate;
     certificate?: CertificateUpdate[];
+    minSignerSetLength?: bigint;
 }
 /**
  * Which accounts and fields are affected by a set of block
@@ -80,6 +80,7 @@ export type ComputedEffectOfBlocks = {
     metadata: {
         operationCount: number;
         blockCount: number;
+        feeUnits: bigint;
     };
 };
 type LedgerOptions = {

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

@@ -44,6 +44,7 @@ export interface ASN1String extends ASN1Object {
     kind: 'printable' | 'ia5' | 'utf8';
     value: string;
 }
+export declare function isASN1Object(input: unknown): input is ASN1Object;
 /**
  * Validation function for {@link isValidSequenceSchema}
  */
@@ -58,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;
     } | {
@@ -86,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;
@@ -102,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[];
@@ -162,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/buffer.d.ts

@@ -1,3 +1,4 @@
+import { Buffer } from 'buffer';
 import zlib from 'zlib';
 /**
  * RFC 4648 Base32 Decoder
@@ -11,6 +12,8 @@ export declare function DecodeBase64(data: string): ArrayBuffer;
 export declare function EncodeBase64(data: ArrayBuffer): string;
 export declare function ZlibInflate(data: ArrayBuffer, options?: zlib.ZlibOptions): ArrayBuffer;
 export declare function ZlibDeflate(data: ArrayBuffer, options?: zlib.ZlibOptions): ArrayBuffer;
+export declare function ZlibInflateAsync(data: ArrayBuffer, options?: zlib.ZlibOptions): Promise<ArrayBuffer>;
+export declare function ZlibDeflateAsync(data: ArrayBuffer, options?: zlib.ZlibOptions): Promise<ArrayBuffer>;
 export declare class BufferStorage {
     #private;
     readonly storageKind: string;
@@ -24,3 +27,4 @@ export declare class BufferStorage {
     compare(compareWith: typeof this | undefined | null): boolean;
     compareHexString(compareWith: BufferStorage | string | undefined | null): boolean;
 }
+export { Buffer };