@keetanetwork/keetanet-client 0.12.2 → 0.14.0

package/lib/block/index.d.ts

@@ -1,15 +1,19 @@
-import type { GenericAccount } from '../account';
-import Account from '../account';
+import type { GenericAccount, MultisigAddress } from '../account';
+import Account, { AccountKeyAlgorithm } from '../account';
 import { BufferStorage } from '../utils/buffer';
 import * as ASN1 from '../utils/asn1';
 import type { ToJSONSerializable, ToJSONSerializableOptions } from '../utils/conversion';
 import * as Operations from './operations';
+export declare enum BlockPurpose {
+    GENERIC = 0,
+    FEE = 1
+}
 export declare enum AdjustMethod {
     ADD = 0,
     SUBTRACT = 1,
     SET = 2
 }
-export declare function assertAdjustMethod(value: any, bigintOkay?: boolean): AdjustMethod;
+export declare function toAdjustMethod(value: unknown): AdjustMethod;
 type BlockHashString = string & {
     readonly __blockhash: never;
 };
@@ -41,8 +45,9 @@ type BlockSignature = Buffer;
 /**
  * Representation of the block
  */
-export interface BlockJSON {
+export interface BlockV1JSON {
     version: 1;
+    purpose?: BlockPurpose.GENERIC;
     date: string | Date;
     previous: string | BlockHash;
     network: string | NetworkID;
@@ -52,16 +57,37 @@ export interface BlockJSON {
     signature: string | BlockSignature;
     operations: Operations.BlockJSONOperations[] | Operations.BlockOperations[];
 }
-export type BlockJSONIncomplete = Partial<BlockJSON>;
+export type BlockV1JSONIncomplete = Partial<BlockV1JSON>;
 /**
  * Output of block suitable to JSON serialization
  */
-export type BlockJSONOutput = ToJSONSerializable<ReturnType<Block['toJSON']>>;
-export type BlockJSONOutputIncomplete = Partial<BlockJSONOutput>;
+/**
+ * Representation of the block V2
+ */
+export interface BlockV2JSON {
+    version: 2;
+    purpose: BlockPurpose;
+    date: string | Date;
+    previous: string | BlockHash;
+    network: string | NetworkID;
+    subnet?: string | SubnetID;
+    account: string | GenericAccount;
+    signer: BlockSignerFieldJSON;
+    signatures: (string | BlockSignature)[];
+    operations: (Operations.BlockJSONOperations | Operations.BlockOperations)[];
+}
+export type BlockV2JSONIncomplete = Partial<BlockV2JSON>;
+export type BlockJSONOutput = ReturnType<Block['toJSON']>;
+export type BlockJSONOutputSerialized = ToJSONSerializable<BlockJSONOutput>;
+export type BlockJSONOutputIncomplete = Partial<BlockJSONOutputSerialized>;
+export type BlockJSON = (Omit<BlockV1JSON, 'version'> | Omit<BlockV2JSON, 'version'>) & {
+    version: number;
+};
+export type BlockJSONIncomplete = Partial<BlockJSON>;
 /**
  * Map input to our values
  */
-interface BlockUnsignedCanonical {
+interface BlockV1UnsignedCanonical {
     version: 1;
     date: Date;
     previous: BlockHash;
@@ -70,17 +96,45 @@ interface BlockUnsignedCanonical {
     operations: Operations.BlockOperations[];
     network: NetworkID;
     subnet: SubnetID | undefined;
-    signature: never;
+    signature?: never;
 }
-interface BlockCanonical extends Omit<BlockUnsignedCanonical, 'signature'> {
+interface BlockV1Canonical extends Omit<BlockV1UnsignedCanonical, 'signature'> {
     signature: BlockSignature;
 }
-type BlockASN1WithoutSignature = ASN1.ValidateASN1.SchemaMap<[typeof BlockASN1Schema[0], typeof BlockASN1Schema[1], typeof BlockASN1Schema[2], typeof BlockASN1Schema[3], typeof BlockASN1Schema[4], typeof BlockASN1Schema[5], typeof BlockASN1Schema[6], typeof BlockASN1Schema[7]]>;
+interface BlockV2UnsignedCanonical {
+    version: 2;
+    date: Date;
+    purpose: BlockPurpose;
+    previous: BlockHash;
+    account: GenericAccount;
+    signer: BlockSignerField;
+    operations: Operations.BlockOperations[];
+    network: NetworkID;
+    subnet: SubnetID | undefined;
+    signatures?: never;
+}
+interface BlockV2Canonical extends Omit<BlockV2UnsignedCanonical, 'signatures'> {
+    signatures: BlockSignature[];
+}
+type OmitLastArrayValue<T> = Required<T> extends [...infer Head, any] ? Head : never;
+type BlockV1ASN1WithoutSignature = ASN1.ValidateASN1.SchemaMap<OmitLastArrayValue<typeof BlockV1ASN1Schema>>;
+type BlockV2ASN1WithoutSignature = ASN1.ValidateASN1.SchemaMap<OmitLastArrayValue<typeof BlockV2ASN1Schema.contains>>;
+type MultisigSignerFieldJSON = [MultisigAddress | string, (MultisigSignerField | Account | string)[]];
+type BlockSignerFieldJSON = Account | string | MultisigSignerFieldJSON;
+type BlockASN1SchemaWithoutSignature = BlockV1ASN1WithoutSignature | {
+    type: 'context';
+    kind: 'explicit';
+    value: 1;
+    contains: BlockV2ASN1WithoutSignature;
+};
+type MultisigSignerField = [MultisigAddress, (MultisigSignerField | Account)[]];
+type BlockSignerField = Account | [MultisigAddress, BlockSignerField[]];
+type BlockSignatureField = [BlockSignature, ...BlockSignature[]];
 /**
  * Block:  An item which contains a number of operations (transactions) which
  * originated from an account at a particular instant
  */
-export declare class Block implements BlockCanonical {
+export declare class Block implements Omit<BlockV2Canonical, 'version'> {
     #private;
     static isInstance: (obj: any, strict?: boolean) => obj is Block;
     static Hash: typeof BlockHash;
@@ -98,32 +152,41 @@ export declare class Block implements BlockCanonical {
     };
     static NO_PREVIOUS: string;
     static AdjustMethod: typeof AdjustMethod;
+    static Purpose: typeof BlockPurpose;
     static Builder: typeof BlockBuilder;
-    readonly version: 1;
+    readonly version: 1 | 2;
+    readonly purpose: BlockPurpose;
     readonly date: Date;
     readonly previous: BlockHash;
     readonly account: GenericAccount;
-    readonly signer: Account;
-    readonly operations: BlockCanonical['operations'];
+    readonly operations: BlockV2Canonical['operations'];
     readonly network: NetworkID;
     readonly subnet: SubnetID | undefined;
-    readonly signature: BlockSignature;
-    readonly $signatureValid: boolean;
+    readonly signer: BlockSignerField;
+    readonly signatures: BlockSignatureField;
+    get principal(): Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1> | MultisigAddress;
     readonly $opening: boolean;
-    static fromUnsignedJSON(input: BlockUnsignedCanonical): Promise<Block>;
-    static isValidJSON(block: BlockJSON | BlockJSONOutput | BlockJSONIncomplete): block is BlockJSON;
-    constructor(input: Buffer | ArrayBuffer | BlockJSON | BlockJSONOutput | Block | string);
+    static fromUnsignedJSON(input: BlockV1UnsignedCanonical | BlockV2UnsignedCanonical): Promise<Block>;
+    static isValidJSON<Version extends 1 | 2>(block: unknown, version?: Version): block is ({
+        1: BlockV1JSON;
+        2: BlockV2JSON;
+    }[Version]);
+    constructor(input: Buffer | ArrayBuffer | BlockJSON | BlockJSONOutput | BlockJSONOutputSerialized | Block | string);
     static getAccountOpeningHash(account: GenericAccount): BlockHash;
-    toBytes(includeSignature?: boolean): ArrayBuffer;
-    protected static getASN1ContainerWithoutSignature(input: BlockUnsignedCanonical | BlockCanonical): BlockASN1WithoutSignature;
+    toBytes(includeSignatures?: boolean): ArrayBuffer;
+    protected static getV1ASN1ContainerWithoutSignature(input: BlockV1UnsignedCanonical | BlockV1Canonical): BlockV1ASN1WithoutSignature;
+    protected static getV2ASN1ContainerWithoutSignature(input: BlockV2UnsignedCanonical | BlockV2Canonical): BlockV2ASN1WithoutSignature;
+    protected static getASN1ContainerWithoutSignature(input: BlockV1UnsignedCanonical | BlockV1Canonical | BlockV2UnsignedCanonical | BlockV2Canonical): BlockASN1SchemaWithoutSignature;
     toJSON(options?: ToJSONSerializableOptions): {
         $binary?: string;
-        version: 1;
+        signature?: string;
+        signatures?: string[];
+        version: 1 | 2;
         date: Date;
         previous: BlockHash;
         account: GenericAccount;
-        signer: Account<import("../account").AccountKeyAlgorithm.ECDSA_SECP256K1 | import("../account").AccountKeyAlgorithm.ED25519 | import("../account").AccountKeyAlgorithm.ECDSA_SECP256R1>;
-        signature: string;
+        purpose: BlockPurpose;
+        signer: Account | [MultisigAddress, any[]];
         network: bigint;
         subnet: bigint | undefined;
         operations: Operations.ExportedJSONOperation[];
@@ -140,7 +203,7 @@ export declare class Block implements BlockCanonical {
      */
     get hash(): BlockHash;
 }
-export declare class BlockBuilder implements BlockJSONIncomplete {
+export declare class BlockBuilder {
     #private;
     static isInstance: (obj: any, strict?: boolean) => obj is BlockBuilder;
     static OperationType: typeof Operations.OperationType;
@@ -157,32 +220,35 @@ export declare class BlockBuilder implements BlockJSONIncomplete {
         MANAGE_CERTIFICATE: typeof Operations.BlockOperationMANAGE_CERTIFICATE;
     };
     static NO_PREVIOUS: string;
-    constructor(block?: BlockJSONIncomplete | BlockJSON | Block | ArrayBuffer | string);
+    constructor(block?: BlockJSON | BlockJSONIncomplete | BlockJSONOutputSerialized | ReturnType<Block['toJSON']> | Block | ArrayBuffer | string);
     protected get currentBlock(): Block | BlockJSONIncomplete;
     protected get currentWIP(): BlockJSONIncomplete;
     protected get currentBlockSealed(): Block;
     toJSON(opts?: ToJSONSerializableOptions): {
         $binary?: string;
-        version: 1;
+        signature?: string;
+        signatures?: string[];
+        version: 1 | 2;
         date: Date;
         previous: BlockHash;
         account: GenericAccount;
-        signer: Account<import("../account").AccountKeyAlgorithm.ECDSA_SECP256K1 | import("../account").AccountKeyAlgorithm.ED25519 | import("../account").AccountKeyAlgorithm.ECDSA_SECP256R1>;
-        signature: string;
+        purpose: BlockPurpose;
+        signer: Account | [MultisigAddress, any[]];
         network: bigint;
         subnet: bigint | undefined;
         operations: Operations.ExportedJSONOperation[];
         $hash: BlockHash;
         $opening: boolean;
     } | {
-        version: 1 | undefined;
+        version: number | undefined;
         date: Date | undefined;
         previous: BlockHash | undefined;
         account: GenericAccount | undefined;
-        signer: Account<import("../account").AccountKeyAlgorithm.ECDSA_SECP256K1 | import("../account").AccountKeyAlgorithm.ED25519 | import("../account").AccountKeyAlgorithm.ECDSA_SECP256R1> | undefined;
+        signer: BlockSignerFieldJSON | undefined;
         network: bigint | undefined;
         subnet: bigint | undefined;
         operations: Operations.BlockOperations[] | undefined;
+        purpose: BlockPurpose;
         $opening: boolean | undefined;
     };
     seal(): Promise<Block>;
@@ -190,8 +256,8 @@ export declare class BlockBuilder implements BlockJSONIncomplete {
     get sealed(): boolean;
     get block(): Block | undefined;
     get hash(): BlockHash | undefined;
-    set signer(signer: string | Account | undefined);
-    get signer(): Account | undefined;
+    set signer(signer: BlockV2JSONIncomplete['signer'] | BlockV2JSON['signer']);
+    get signer(): BlockV2JSON['signer'] | undefined;
     set account(account: string | GenericAccount | undefined);
     get account(): GenericAccount | undefined;
     set previous(blockhash: string | BlockHash | undefined);
@@ -199,8 +265,10 @@ export declare class BlockBuilder implements BlockJSONIncomplete {
     get $opening(): boolean | undefined;
     set date(date: Date | string | undefined);
     get date(): Date | undefined;
-    set version(version: 1 | undefined);
-    get version(): 1 | undefined;
+    set version(version: number | undefined);
+    get version(): number | undefined;
+    set purpose(purpose: BlockPurpose | undefined);
+    get purpose(): BlockPurpose;
     set network(network: NetworkID | string | undefined);
     get network(): NetworkID | undefined;
     set subnet(subnet: SubnetID | string | undefined);

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_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"];
+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 = {