@keetanetwork/keetanet-client 0.14.14 → 0.16.1

package/client/builder.d.ts

@@ -2,11 +2,12 @@ import type { GenericAccount, IdentifierKeyAlgorithm } from '../lib/account';
 import { Account, AccountKeyAlgorithm } from '../lib/account';
 import type { AdjustMethod, BlockHash } from '../lib/block';
 import { Block } from '../lib/block';
-import { type BlockJSONOperations } from '../lib/block/operations';
-import type { AccountInfo } from '../lib/ledger/types';
+import type { IdentifierCreateArguments, BlockJSONOperations } from '../lib/block/operations';
+import type { AccountInfo, AccountInfoWithoutAccount } from '../lib/ledger/types';
 import type { AcceptedPermissionTypes } from '../lib/permissions';
 import type { UserClient, Client } from '.';
 import { Permissions } from '../lib/permissions';
+import type { ToJSONSerializable } from '../lib/utils/conversion';
 import { Certificate, CertificateBundle } from '../lib/utils/certificate';
 import type { VoteStaple } from '../lib/vote';
 type GetPrevFunction = (acct: GenericAccount | string) => Promise<BlockHash | string | null | undefined>;
@@ -53,6 +54,7 @@ type PerAccount<T> = {
 interface IdentifierCreateRequest {
     type: IdentifierKeyAlgorithm;
     toResolve?: PendingAccount;
+    createArguments?: IdentifierCreateArguments;
 }
 type AccountOrPending<Type extends AccountKeyAlgorithm = AccountKeyAlgorithm> = Account<Type> | PendingAccount<Type>;
 type TokenOrPending = AccountOrPending<AccountKeyAlgorithm.TOKEN>;
@@ -89,7 +91,7 @@ export interface PendingOperations {
         method: AdjustMethod;
         permissions: Permissions;
     }[]>>;
-    info?: AccountInfo;
+    info?: AccountInfoWithoutAccount;
     setRep?: Account;
 }
 export interface PendingOperationsJSON {
@@ -108,6 +110,7 @@ export interface PendingOperationsJSON {
     }[];
     createIdentifiers?: {
         type: IdentifierKeyAlgorithm;
+        createArguments?: ToJSONSerializable<IdentifierCreateArguments>;
     }[];
     tokenSupply?: string;
     adminModifyBalance?: {
@@ -159,7 +162,7 @@ export declare class PendingAccount<AccountType extends AccountKeyAlgorithm = Ac
     static GetValue<T extends AccountKeyAlgorithm>(data: AccountOrPending<T>): Account<T>;
     set account(account: Account<AccountType>);
     get account(): Account<AccountType>;
-    toJSON(): Account<AccountType>;
+    toJSON(): import("../lib/account").PublicKeyStringMapping[AccountType];
 }
 type AllPending = [AccountSignerOptions, PendingOperations][];
 export declare class UserClientBuilder {
@@ -184,9 +187,32 @@ export declare class UserClientBuilder {
     modifyCertificate(method: ManageCertificateMethod, certificate: Certificate, intermediateCertificates?: CertificateBundle | null, options?: BuilderBlockOptions): void;
     modifyTokenSupply(amount: bigint, options?: BuilderBlockOptions): void;
     modifyTokenBalance(token: TokenOrPending, amount: bigint, isSet?: boolean, options?: BuilderBlockOptions): void;
-    setInfo(info: AccountInfo, options?: BuilderBlockOptions): void;
+    setInfo(info: AccountInfoWithoutAccount, options?: BuilderBlockOptions): void;
     setRep(to: Account, options?: BuilderBlockOptions): void;
-    generateIdentifier<Algo extends IdentifierKeyAlgorithm>(type: Algo, options?: BuilderBlockOptions): PendingAccount<Algo>;
+    /**
+     * Create a new identifier for the given arguments and add to the pending operations
+     *
+     * @param toCreate The arguments used to create the identifier (ex: multisig configuration)
+     * @param options The options to use for the request
+     * @return The identifier that was generated
+     */
+    generateIdentifier<CreateArguments extends IdentifierCreateArguments>(toCreate: CreateArguments, options?: BuilderBlockOptions): PendingAccount<CreateArguments['type']>;
+    /**
+     * Create a new identifier with the given type and add to the pending operations
+     *
+     * @param type The type of identifier to generate
+     * @param options The options to use for the request
+     * @return The identifier that was generated
+     */
+    generateIdentifier<CreateKeyType extends Exclude<IdentifierKeyAlgorithm, IdentifierCreateArguments['type']>>(type: CreateKeyType, options?: BuilderBlockOptions): PendingAccount<CreateKeyType>;
+    /**
+     * Create a new identifier and add to the pending operations
+     *
+     * @param toCreate The type of identifier or the arguments to create an identifier
+     * @param options The options to use for the request
+     * @return The identifier that was generated
+     */
+    generateIdentifier(toCreate: Exclude<IdentifierKeyAlgorithm, IdentifierCreateArguments['type']> | IdentifierCreateArguments, options?: BuilderBlockOptions): PendingAccount<IdentifierKeyAlgorithm>;
     get blocks(): Block[];
     get rendered(): boolean;
 }

package/client/client_common_tests.d.ts

@@ -29,7 +29,7 @@ export type NodeCreationOptions = {
 };
 export declare function setup(options?: NodeCreationOptions): Promise<{
     trustedKey: Account<AccountKeyAlgorithm.ECDSA_SECP256K1>;
-    repKeys: Account<AccountKeyAlgorithm.ECDSA_SECP256K1 | AccountKeyAlgorithm.ED25519 | AccountKeyAlgorithm.ECDSA_SECP256R1>[];
+    repKeys: Account<import("../lib/account").KeyPairKeyAlgorithm>[];
     accounts: Account<AccountKeyAlgorithm.ECDSA_SECP256K1>[];
     nodes: LocalNode[];
     trustedClients: KeetaNet.UserClient[];
@@ -40,7 +40,8 @@ export declare function setup(options?: NodeCreationOptions): Promise<{
     cleanupFunctions: (() => Promise<void>)[];
 }>;
 declare function runBasicTests(nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
-declare function runFeeBlockTests(_ignore_nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
+declare function runSingleFeeTests(_ignore_nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
+declare function runMultipleFeeTests(_ignore_nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
 declare function runBuilderStorageTests(_ignoreNodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
 declare function runMultiSigTests(nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
 declare function runRecoverAccountTest(nodes: LocalNode[], userClient: UserClient, trustedClient: UserClient, params: ClientParams, expect: any, ExpectErrorCode: any): Promise<void>;
@@ -62,8 +63,8 @@ export declare const clientTests: {
             count: number;
         };
     };
-    'Fee Block Tests': {
-        test: typeof runFeeBlockTests;
+    'Single Fee Tests': {
+        test: typeof runSingleFeeTests;
         options: {
             p2pTested: boolean;
             count: number;
@@ -76,6 +77,24 @@ export declare const clientTests: {
             }[];
         };
     };
+    'Multiple Fee Tests': {
+        test: typeof runMultipleFeeTests;
+        options: {
+            p2pTested: boolean;
+            count: number;
+            customNodeOptions: {
+                ledger: {
+                    computeFeeFromBlocks: (ledger: Ledger, blocks: Block[], effects: ComputedEffectOfBlocks) => ({
+                        amount: bigint;
+                        token?: undefined;
+                    } | {
+                        amount: bigint;
+                        token: Account<AccountKeyAlgorithm.TOKEN>;
+                    })[];
+                };
+            }[];
+        };
+    };
     'Builder/Storage Test': {
         test: typeof runBuilderStorageTests;
         options: {

package/client/index-browser.d.ts

@@ -13,16 +13,17 @@ import type { GenericAccount, IdentifierKeyAlgorithm, NetworkAddress, TokenAddre
 import Account, { AccountKeyAlgorithm } from '../lib/account';
 import type { AdjustMethod } from '../lib/block';
 import Block, { BlockHash } from '../lib/block';
+import type { DistributiveOmit } from '../lib/utils/helper';
 import type { P2PSwitchStatistics } from '../lib/p2p';
 import * as Config from '../config';
 import type { BaseNetworkInfo, BaseTokenInfo } from '../lib/utils/initial';
-import type { BuilderOptions, ManageCertificateMethod } from './builder';
+import type { BuilderOptions, ManageCertificateMethod, PendingAccount } from './builder';
 import { UserClientBuilder } from './builder';
 import { KeetaNetError } from '../lib/error';
-import type { AccountInfo, GetAllBalancesResponse, ACLRow, LedgerStatistics } from '../lib/ledger/types';
+import type { GetAllBalancesResponse, ACLRow, LedgerStatistics, AccountInfoForType, AccountInfoWithoutAccount } from '../lib/ledger/types';
 import type { LedgerSelector, LedgerStorage } from '../lib/ledger';
 import type { AcceptedPermissionTypes } from '../lib/permissions';
-import { type BlockOperations } from '../lib/block/operations';
+import type { IdentifierCreateArguments, BlockOperations } from '../lib/block/operations';
 import { Certificate } from '../lib/utils/certificate';
 import { CertificateBundle, type CertificateHash } from '../lib/utils/certificate';
 import { VoteStaple, type VoteQuote } from '../lib/vote';
@@ -33,11 +34,11 @@ type VoteBlocksHash = Vote['blocksHash'];
  * @expandType AccountInfo
  * @expandType GetAllBalancesResponse
  */
-type GetAccountStateAPIResponseFormatted = {
+type GetAccountStateAPIResponseFormatted<AccountType extends AccountKeyAlgorithm = AccountKeyAlgorithm> = {
     /**
      * The account for which this information is for
      */
-    account: GenericAccount;
+    account: Account<AccountType>;
     /**
      * The current head block for the account, if there is one
      * this will be null if the account is not open
@@ -58,7 +59,7 @@ type GetAccountStateAPIResponseFormatted = {
      * Metadata for the account which can be set with the
      * {@link UserClient['setInfo']}() method
      */
-    info: AccountInfo;
+    info: DistributiveOmit<AccountInfoForType<AccountType>, 'account'>;
     /**
      * The balances for the account
      * Each token will have a balance, even if it is 0
@@ -115,7 +116,7 @@ interface PrincipalACLWithInfoParsed {
     /**
      * Metadata for the `entity`
      */
-    info: AccountInfo;
+    info: AccountInfoWithoutAccount;
     /**
      * The balances for the `entity`
      */
@@ -242,7 +243,7 @@ export declare class Client {
      * is defined by the `Client.DefaultLogger` property, but can be overridden
      * by the application.
      */
-    logger: Pick<Console, "log" | "warn" | "error">;
+    logger: Pick<Console, "warn" | "error" | "log">;
     /**
      * Indication of whether or not this client has been destroyed.
      */
@@ -410,7 +411,7 @@ export declare class Client {
      * @param account The account to fetch the information for
      * @return The account information
      */
-    getAccountInfo(account: GenericAccount | string, rep?: ClientRepresentative | 'ANY'): Promise<GetAccountStateAPIResponseFormatted>;
+    getAccountInfo<AccountType extends AccountKeyAlgorithm>(account: Account<AccountType> | string, rep?: ClientRepresentative | 'ANY'): Promise<GetAccountStateAPIResponseFormatted<AccountType>>;
     /**
      * Fetch the account information for multiple accounts.  This will return
      * the account information including the current head block, representative,
@@ -672,14 +673,14 @@ export declare class Client {
             representativeCount: number;
             db: import("../lib/stats").DbStats;
             settlementTimes: import("../lib/stats").TimeStats;
-        };
+        } & {};
         switch: {
             incomingMessages: number;
             outgoingMessagesPeerSuccess: number;
             outgoingMessagesPeerFailure: number;
             outgoingMessagesPeerFiltered: number;
             outgoingMessagesPeerFailureUngreeted: number;
-        };
+        } & {};
     })[]>;
     /**
      * Update this client's view of the network representatives.
@@ -765,7 +766,7 @@ export declare class Client {
         moment: string;
         momentRange: number;
         checksum: string;
-    }>;
+    } & {}>;
     /**
      * Get the version of the node for a given representative, if no
      * representative is specified then the version of the "best"
@@ -1084,7 +1085,7 @@ export declare class UserClient {
      * @param options The options to use for the request
      * @return The vote staple that was generated and whether it was able to be published
      */
-    setInfo(info: AccountInfo, options?: UserClientOptions): Promise<{
+    setInfo(info: AccountInfoWithoutAccount, options?: UserClientOptions): Promise<{
         voteStaple: VoteStaple;
         publish: boolean;
         from: "direct";
@@ -1168,6 +1169,14 @@ export declare class UserClient {
      * @returns A list of quotes from representatives the client knows about
      */
     getQuotes(blocks: Block[]): Promise<VoteQuote[]>;
+    /**
+     * Generate a new identifier for the given type and publish the blocks
+     *
+     * @param toCreate The arguments used to create the identifier (ex: multisig configuration)
+     * @param options The options to use for the request
+     * @return The identifier that was generated
+     */
+    generateIdentifier<CreateArguments extends IdentifierCreateArguments>(toCreate: CreateArguments, options?: UserClientOptions): Promise<PendingAccount<CreateArguments['type']>>;
     /**
      * Generate a new identifier for the given type and publish the blocks
      *
@@ -1175,7 +1184,15 @@ export declare class UserClient {
      * @param options The options to use for the request
      * @return The identifier that was generated
      */
-    generateIdentifier(type: IdentifierKeyAlgorithm, options?: UserClientOptions): Promise<import("./builder").PendingAccount<AccountKeyAlgorithm.NETWORK | AccountKeyAlgorithm.TOKEN | AccountKeyAlgorithm.STORAGE | AccountKeyAlgorithm.MULTISIG>>;
+    generateIdentifier<CreateKeyType extends Exclude<IdentifierKeyAlgorithm, IdentifierCreateArguments['type']>>(type: CreateKeyType, options?: UserClientOptions): Promise<PendingAccount<CreateKeyType>>;
+    /**
+     * Generate a new identifier and publish the blocks
+     *
+     * @param toCreate The type of identifier or the arguments to create an identifier
+     * @param options The options to use for the request
+     * @return The identifier that was generated
+     */
+    generateIdentifier(toCreate: Exclude<IdentifierKeyAlgorithm, IdentifierCreateArguments['type']> | IdentifierCreateArguments, options?: UserClientOptions): Promise<PendingAccount<IdentifierKeyAlgorithm>>;
     /**
      * Update the permissions for a given account.  This will publish the
      * changes to the network.