@keetanetwork/keetanet-client 0.16.2 → 0.18.0

package/lib/ledger/db_spanner_helper.d.ts

@@ -6,7 +6,17 @@ import Vote, { PossiblyExpiredVote, VoteBlockHash } from '../vote';
 import type { BaseSet, ExternalSet } from '../permissions';
 import type { SpannerTransaction } from './db_spanner';
 import { Certificate, CertificateBundle, CertificateHash } from '../utils/certificate';
+import type { ACLPrincipalType } from './types';
 declare const ColumnTypes: {
+    readonly GENERIC_ACCOUNT_OR_CERTIFICATE_HASH: {
+        readonly fromSpanner: (value: string) => GenericAccount | CertificateHash;
+        readonly toSpanner: (value: CertificateHash | GenericAccount) => import("../account").TokenPublicKeyString | import("../account").NetworkPublicKeyString | import("../account").StoragePublicKeyString | import("../account").MultisigPublicKeyString | import("../account").Secp256K1PublicKeyString | import("../account").Secp256R1PublicKeyString | import("../account").ED25519PublicKeyString | (string & {
+            readonly __certificateHash: never;
+        });
+        readonly toComparable: (name: string | CertificateHash | GenericAccount) => string;
+        readonly dbType: string;
+        readonly dbSize: number;
+    };
     readonly LEDGER: {
         readonly dbType: "STRING";
         readonly dbSize: 4;
@@ -212,6 +222,13 @@ declare const ColumnTypes: {
         fromSpanner: (value: Buffer) => bigint;
         toComparable: (val: Buffer | bigint | string) => bigint;
     };
+    readonly ACL_ROW_TYPE: {
+        dbType: string;
+        dbSize: number;
+        toComparable: (input: string | ACLPrincipalType) => "ACCOUNT" | "CERTIFICATE";
+        fromSpanner: (input: string) => "ACCOUNT" | "CERTIFICATE";
+        toSpanner: (input: ACLPrincipalType) => "ACCOUNT" | "CERTIFICATE";
+    };
 };
 type ColumnTypeName = keyof typeof ColumnTypes;
 type ColumnOutputTypeArg<T extends ColumnTypeName> = Parameters<typeof ColumnTypes[T]['fromSpanner']>[0];
@@ -221,6 +238,7 @@ type ColumnOutputTypeInfer<X> = X extends ColumnInterface<infer TR, infer Nullab
 type ColumnInputTypeArg<T extends ColumnTypeName> = Parameters<typeof ColumnTypes[T]['toSpanner']>[0];
 type ColumnInputTypeReturn<T extends ColumnTypeName> = ReturnType<typeof ColumnTypes[T]['toSpanner']>;
 interface ColumnInterface<T extends ColumnTypeName, Nullable extends boolean = boolean> {
+    default: (value: ColumnOutputTypeReturn<T>) => ColumnInterface<T, Nullable>;
     nullable: <SetNullable extends boolean>(nullable: SetNullable) => ColumnInterface<T, SetNullable>;
     fromSpanner: (value: ColumnOutputTypeArg<T>, transaction: SpannerTransaction) => ColumnOutputTypeReturn<T>;
     toSpanner: (value: ColumnInputTypeArg<T>, transaction: SpannerTransaction) => ColumnInputTypeReturn<T>;
@@ -247,7 +265,7 @@ declare const schema: {
     readonly accountInfo: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
+            readonly account: ColumnInterface<"GENERIC_ACCOUNT_OR_CERTIFICATE_HASH", false>;
             readonly name: ColumnInterface<"INFO_NAME", true>;
             readonly description: ColumnInterface<"INFO_DESCRIPTION", true>;
             readonly metadata: ColumnInterface<"INFO_METADATA", true>;
@@ -261,11 +279,13 @@ declare const schema: {
     readonly permissions: {
         readonly type: "TABLE";
         readonly columns: {
-            readonly account: ColumnInterface<"GENERIC_ACCOUNT", false>;
+            readonly account: ColumnInterface<"GENERIC_ACCOUNT_OR_CERTIFICATE_HASH", false>;
             readonly entity: ColumnInterface<"GENERIC_ACCOUNT", false>;
             readonly target: ColumnInterface<"GENERIC_ACCOUNT", false>;
             readonly basePermission: ColumnInterface<"BASE_PERMISSION", false>;
             readonly externalPermission: ColumnInterface<"EXTERNAL_PERMISSION", false>;
+            readonly principalType: ColumnInterface<"ACL_ROW_TYPE", false>;
+            readonly certificateAccount: ColumnInterface<"GENERIC_ACCOUNT", true>;
         };
         readonly key: readonly [Key, Key, Key];
         readonly interleave: Interleave;
@@ -391,7 +411,7 @@ declare const schema: {
         readonly type: "INDEX";
         readonly table: "permissions";
         readonly key: readonly [Key];
-        readonly storing: readonly [Key, Key];
+        readonly storing: readonly [Key, Key, Key, Key];
     };
     readonly permissionsEntityBasePerm: {
         readonly type: "INDEX";

package/lib/ledger/db_sqlite.d.ts

@@ -4,7 +4,7 @@ import { BlockHash } from '../block';
 import { Block } from '../block';
 import type { GenericAccount, IdentifierAddress, TokenAddress } from '../account';
 import Account, { AccountKeyAlgorithm } from '../account';
-import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBaseOptions } from '../ledger';
+import type { Ledger, LedgerConfig, LedgerStorageAPI, LedgerSelector, PaginatedVotes, GetVotesAfterOptions, LedgerStorageTransactionBaseOptions, ListACLsByEntityFilters } from '../ledger';
 import { IdempotentKey, LedgerStorageTransactionBase } from '../ledger';
 import type { ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates, AccountInfoForType } from './types';
 import { LedgerStorageBase } from './common';
@@ -40,8 +40,8 @@ export declare class DBSqlite extends LedgerStorageBase implements LedgerStorage
      */
     protected adjustDefer(transaction: DBSqliteTransaction, input: VoteStaple): Promise<void>;
     listOwners(transaction: DBSqliteTransaction, entity: IdentifierAddress): Promise<Account<AccountKeyAlgorithm.TOKEN>[]>;
-    listACLsByEntity(transaction: DBSqliteTransaction, entity: GenericAccount): Promise<ACLRow[]>;
-    listACLsByPrincipal(transaction: DBSqliteTransaction, principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
+    listACLsByEntity(transaction: DBSqliteTransaction, entity: GenericAccount, options?: ListACLsByEntityFilters): Promise<ACLRow[]>;
+    listACLsByPrincipal(transaction: DBSqliteTransaction, principal: ACLRow['principal'], entityList?: GenericAccount[]): Promise<ACLRow[]>;
     getAccountInfo<T extends AccountKeyAlgorithm = AccountKeyAlgorithm>(transaction: DBSqliteTransaction, account: Account<T> | string): Promise<AccountInfoForType<T>>;
     adjust(transaction: DBSqliteTransaction, input: VoteStaple, changes: ComputedEffectOfBlocks, mayDefer?: boolean, completedStaples?: Set<string>): Promise<VoteStaple[]>;
     getBlock(transaction: DBSqliteTransaction, block: BlockHash, from: LedgerSelector): Promise<Block | null>;

package/lib/ledger/effects.d.ts

@@ -3,7 +3,7 @@ import Account from '../account';
 import type { AdjustMethod } from '../block';
 import { Block } from '../block';
 import type * as Operations from '../block/operations';
-import type { ACLEntry, ACLUpdate, AccountInfo } from '../ledger/types';
+import type { AccountInfo, ACLUpdate, ACLPermissionRequirement } from '../ledger/types';
 import type { Certificate, CertificateBundle } from '../utils/certificate';
 import { CertificateHash } from '../utils/certificate';
 import type { DistributiveOmit } from '../utils/helper';
@@ -56,27 +56,35 @@ interface ComputedBlocksEffectFields {
     supply?: NumericValueEntry[];
     info?: Partial<UserEditableAccountInfo>;
     permissions?: ACLUpdate[];
-    permissionRequirements?: ACLEntry[];
+    permissionRequirements?: ACLPermissionRequirement[];
     createRequests?: CreateIdentifierRequest[];
     delegation?: DelegationUpdate;
     certificate?: CertificateUpdate[];
     minSignerSetLength?: bigint;
 }
-/**
- * Which accounts and fields are affected by a set of block
- */
-interface ComputedBlockEffect {
+interface CertificateComputedEffect {
+    type: 'CERTIFICATE';
+    certificateHash: CertificateHash;
+    certificateAccount: GenericAccount;
+    fields: ComputedBlocksEffectFields;
+}
+interface AccountComputedEffect {
+    type: 'ACCOUNT';
     account: GenericAccount;
     fields: ComputedBlocksEffectFields;
 }
+/**
+ * Which accounts and fields are affected by a set of block
+ */
+type ComputedBlockEffect = CertificateComputedEffect | AccountComputedEffect;
 /**
  * A breakdown of computed effects by account public key
  */
-export type ComputedEffectOfBlocksByAccount = {
-    [accountPubKey: string]: ComputedBlockEffect;
+export type ComputedEffectOfBlocksByEntity = {
+    [entityKey: string]: ComputedBlockEffect;
 };
 export type ComputedEffectOfBlocks = {
-    accounts: ComputedEffectOfBlocksByAccount;
+    accounts: ComputedEffectOfBlocksByEntity;
     touched: InstanceType<typeof Account.Set>;
     possibleNewAccounts: InstanceType<typeof Account.Set>;
     metadata: {

package/lib/ledger/index.d.ts

@@ -6,7 +6,7 @@ import Account from '../account';
 import type Node from '../node';
 import type { BloomFilter } from '../utils/bloom';
 import type { ComputedEffectOfBlocks } from './effects';
-import type { ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates, AccountInfoForType } from './types';
+import type { ACLRow, GetAllBalancesResponse, LedgerStatistics, CertificateWithIntermediates, AccountInfoForType, ACLPrincipalType } from './types';
 import LedgerRequestCache from './cache';
 import type { Logger } from '../log';
 import type { CertificateHash } from '../utils/certificate';
@@ -109,6 +109,15 @@ export type GetVotesAfterOptions = {
      */
     timeout?: number;
 };
+/**
+ * Filters for listing ACLs by entity
+ */
+export interface ListACLsByEntityFilters {
+    /**
+     * If provided, only return ACL rows of this type
+     */
+    principalType?: ACLPrincipalType;
+}
 type IdempotentKeyString = string & {
     readonly __idempotentKey: never;
 };
@@ -197,11 +206,11 @@ export interface LedgerStorageAPI {
     /**
      * List permissions principal has on all provided entity's
      */
-    listACLsByPrincipal: (transaction: any, principal: GenericAccount, entityList?: GenericAccount[]) => Promise<ACLRow[]>;
+    listACLsByPrincipal: (transaction: any, principal: ACLRow['principal'], entityList?: GenericAccount[]) => Promise<ACLRow[]>;
     /**
      * List permissions any principal has on provided entity
      */
-    listACLsByEntity: (transaction: any, entity: GenericAccount) => Promise<ACLRow[]>;
+    listACLsByEntity: (transaction: any, entity: GenericAccount, options?: ListACLsByEntityFilters) => Promise<ACLRow[]>;
     /**
      * Adjust the ledger by performing a set of changes based on some blocks and votes
      */
@@ -338,8 +347,8 @@ declare class LedgerAtomicInterface {
     getAllBalances(account: GenericAccount): Promise<GetAllBalancesResponse>;
     getAccountCertificates(account: GenericAccount): Promise<CertificateWithIntermediates[]>;
     getAccountCertificateByHash(account: GenericAccount, hash: CertificateHash): Promise<CertificateWithIntermediates | null>;
-    listACLsByPrincipal(principal: GenericAccount, entityList?: GenericAccount[]): Promise<ACLRow[]>;
-    listACLsByEntity(entity: GenericAccount): Promise<ACLRow[]>;
+    listACLsByPrincipal(principal: ACLRow['principal'], entityList?: GenericAccount[]): Promise<ACLRow[]>;
+    listACLsByEntity(entity: GenericAccount, options?: ListACLsByEntityFilters): Promise<ACLRow[]>;
     votingPower(rep?: Account): Promise<bigint>;
     getVotes(block: BlockHash, from?: LedgerStorage): Promise<Vote[] | null>;
     getVotesFromMultiplePrevious(prevBlocks: BlockHash[], from?: LedgerSelector, issuer?: Account): Promise<{

package/lib/ledger/types.d.ts

@@ -2,7 +2,7 @@ import type { Account, AccountKeyAlgorithm, GenericAccount, IdentifierKeyAlgorit
 import type { AdjustMethod } from '../block';
 import type { Permissions } from '../permissions';
 import type { DbStats, TimeStats } from '../stats';
-import type { Certificate, CertificateBundle } from '../utils/certificate';
+import type { Certificate, CertificateBundle, CertificateHash } from '../utils/certificate';
 import type { DistributiveOmit } from '../utils/helper';
 export interface MultisigConfig {
     signers: (Account | MultisigAddress)[];
@@ -70,14 +70,21 @@ export declare function isKeyPairAccountInfo(info: AccountInfo): info is KeyPair
 export declare function isAccountInfoOfType<T extends AccountKeyAlgorithm>(info: AccountInfo, type: T): info is Extract<AccountInfo, {
     account: Account<T>;
 }>;
-/**
- * Permissions types
- */
-export interface ACLRow {
+declare const aclPrincipalType: readonly ["ACCOUNT", "CERTIFICATE"];
+export type ACLPrincipalType = typeof aclPrincipalType[number];
+export declare function isACLPrincipalType(type: string): type is ACLPrincipalType;
+export declare function assertACLPrincipalType(type: string): asserts type is ACLPrincipalType;
+export declare function asACLPrincipalType(type: string): ACLPrincipalType;
+interface CertificateACLPrincipal {
+    usingCertificate: true;
+    certificate: CertificateHash;
+    certificateAccount: GenericAccount;
+}
+interface BaseACLRow<PrincipalType extends ACLPrincipalType> {
     /**
-     * The account that these permissions apply to
+     * The type of ACL row, which determines the shape of the principal
      */
-    principal: GenericAccount;
+    principalType: PrincipalType;
     /**
      * The account that this row is for
      */
@@ -91,19 +98,36 @@ export interface ACLRow {
      */
     permissions: Permissions;
 }
+interface AccountACLRow extends BaseACLRow<'ACCOUNT'> {
+    /**
+     * The account that these permissions apply to
+     */
+    principal: GenericAccount;
+}
+interface CertificateACLRow extends BaseACLRow<'CERTIFICATE'> {
+    /**
+     * Accounts having certificate issued by this certificate will be granted the permissions in this ACL row
+     */
+    principal: CertificateACLPrincipal;
+}
 /**
- * An entry for the ACL
- * @expandType ACLRow
+ * Permissions types
  */
-export interface ACLEntry extends Omit<ACLRow, 'target'> {
+export type ACLRow = AccountACLRow | CertificateACLRow;
+/**
+ * A permission requirement for ledger effects
+ * @expandType AccountACLRow
+ */
+export type ACLPermissionRequirement = Omit<AccountACLRow, 'target' | 'principalType'> & {
     target?: GenericAccount;
     method?: AdjustMethod.SET;
-}
+};
 /**
  * Update an ACL for an account
- * @expandType ACLEntry
+ * @expandType ACLRow
  */
-export interface ACLUpdate extends Omit<ACLEntry, 'method' | 'permissions'> {
+export type ACLUpdate = DistributiveOmit<ACLRow, 'method' | 'permissions' | 'target'> & {
+    target?: GenericAccount;
     /**
      * The method to use to update the ACL
      */
@@ -114,7 +138,7 @@ export interface ACLUpdate extends Omit<ACLEntry, 'method' | 'permissions'> {
      * If this is set to null, the permissions will be unset
      */
     permissions: Permissions | null;
-}
+};
 /**
  * All balances for each token on an account
  */

package/lib/log/target_gcp.js

@@ -274,7 +274,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _LogTargetGCP_instances, _LogTargetGCP_googleCloudLoggingOptions, _LogTargetGCP_googleCloudLogging, _LogTargetGCP_consoleLoggingTarget, _LogTargetGCP_console, _LogTargetGCP_gcpLoggingTarget_get;
+var _LogTargetGCP_instances, _LogTargetGCP_googleCloudLoggingOptions, _LogTargetGCP_googleCloudLogging, _LogTargetGCP_consoleLoggingTarget, _LogTargetGCP_console, _LogTargetGCP_getLabels, _LogTargetGCP_logStartupInformationToConsole, _LogTargetGCP_gcpLoggingTarget_get;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.Testing = void 0;
 const common_1 = __webpack_require__(364);
@@ -403,6 +403,7 @@ class LogTargetGCP {
             instance: instance,
             log: instance.log(__classPrivateFieldGet(this, _LogTargetGCP_instances, "a", _LogTargetGCP_gcpLoggingTarget_get))
         }, "f");
+        __classPrivateFieldGet(this, _LogTargetGCP_instances, "m", _LogTargetGCP_logStartupInformationToConsole).call(this);
     }
     /**
      * This function tries to log a test message to GCP Logging, and if it fails,
@@ -413,8 +414,7 @@ class LogTargetGCP {
      */
     async test(canRun, elseRun) {
         const gcpLogging = __classPrivateFieldGet(this, _LogTargetGCP_googleCloudLogging, "f");
-        const [vendor, product] = __classPrivateFieldGet(this, _LogTargetGCP_instances, "a", _LogTargetGCP_gcpLoggingTarget_get).split('/');
-        const environment = __classPrivateFieldGet(this, _LogTargetGCP_googleCloudLoggingOptions, "f").environment;
+        const labels = __classPrivateFieldGet(this, _LogTargetGCP_instances, "m", _LogTargetGCP_getLabels).call(this);
         try {
             await gcpLogging.log.write(gcpLogging.instance.entry({
                 jsonPayload: {
@@ -427,11 +427,7 @@ class LogTargetGCP {
                 resource: {
                     type: 'global'
                 },
-                labels: {
-                    vendor: vendor,
-                    product: product,
-                    environment: environment
-                },
+                labels: labels,
                 severity: 'DEBUG'
             }));
             await canRun();
@@ -450,8 +446,7 @@ class LogTargetGCP {
         if (logs.length === 0) {
             return;
         }
-        const [vendor, product] = __classPrivateFieldGet(this, _LogTargetGCP_instances, "a", _LogTargetGCP_gcpLoggingTarget_get).split('/');
-        const environment = __classPrivateFieldGet(this, _LogTargetGCP_googleCloudLoggingOptions, "f").environment;
+        const labels = __classPrivateFieldGet(this, _LogTargetGCP_instances, "m", _LogTargetGCP_getLabels).call(this);
         const logEntries = logs.map((log) => {
             const addLogFields = {};
             if (log.trace !== undefined) {
@@ -479,12 +474,7 @@ class LogTargetGCP {
                 resource: {
                     type: 'global'
                 },
-                labels: {
-                    vendor: vendor,
-                    product: product,
-                    environment: environment,
-                    ...(this.context ?? {})
-                },
+                labels: labels,
                 severity: log.level
             }));
         });
@@ -497,7 +487,19 @@ class LogTargetGCP {
         }
     }
 }
-_LogTargetGCP_googleCloudLoggingOptions = new WeakMap(), _LogTargetGCP_googleCloudLogging = new WeakMap(), _LogTargetGCP_consoleLoggingTarget = new WeakMap(), _LogTargetGCP_console = new WeakMap(), _LogTargetGCP_instances = new WeakSet(), _LogTargetGCP_gcpLoggingTarget_get = function _LogTargetGCP_gcpLoggingTarget_get() {
+_LogTargetGCP_googleCloudLoggingOptions = new WeakMap(), _LogTargetGCP_googleCloudLogging = new WeakMap(), _LogTargetGCP_consoleLoggingTarget = new WeakMap(), _LogTargetGCP_console = new WeakMap(), _LogTargetGCP_instances = new WeakSet(), _LogTargetGCP_getLabels = function _LogTargetGCP_getLabels() {
+    const [vendor, product] = __classPrivateFieldGet(this, _LogTargetGCP_instances, "a", _LogTargetGCP_gcpLoggingTarget_get).split('/');
+    const environment = __classPrivateFieldGet(this, _LogTargetGCP_googleCloudLoggingOptions, "f").environment;
+    return ({
+        vendor: vendor,
+        product: product,
+        environment: environment,
+        ...this.context
+    });
+}, _LogTargetGCP_logStartupInformationToConsole = function _LogTargetGCP_logStartupInformationToConsole() {
+    const labels = __classPrivateFieldGet(this, _LogTargetGCP_instances, "m", _LogTargetGCP_getLabels).call(this);
+    __classPrivateFieldGet(this, _LogTargetGCP_console, "f").info(`[LogTargetGCP] Initializing Google Cloud Logging with ${JSON.stringify(labels)}`);
+}, _LogTargetGCP_gcpLoggingTarget_get = function _LogTargetGCP_gcpLoggingTarget_get() {
     return (`${__classPrivateFieldGet(this, _LogTargetGCP_googleCloudLoggingOptions, "f").vendor}/${__classPrivateFieldGet(this, _LogTargetGCP_googleCloudLoggingOptions, "f").product}`);
 };
 /** @internal */

package/lib/utils/external-keys/gcp-kms-wrapped.d.ts

@@ -0,0 +1,85 @@
+/**
+ * ExternalKeyPair for the Keeta Network which uses Google Cloud KMS
+ * to wrap private key operations. This allows users to leverage GCP KMS for
+ * decrypting an encrypted private key and performing signing and encryption
+ * operations without exposing the private key material to the application.
+ *
+ * Internally, it uses RSA keys on GCP KMS to support decrypting the
+ * supplied encrypted keying material.
+ */
+import type { KeyManagementServiceClient } from '@google-cloud/kms';
+import type * as KeetaNet from '../../../client';
+import type { AccountKeyAlgorithm } from '../../../lib/account';
+import type * as crypto from 'node:crypto';
+import type { GCPKMSKeyConfig } from './gcp-kms.common';
+type KeetaGCPKMSWrappedKeyPairPackages = {
+    /**
+     * GCP KMS Key Management Service Client, used to interact with GCP KMS
+     * for key lookups and decryption operations
+     */
+    KeyManagementServiceClient: typeof KeyManagementServiceClient;
+    /**
+     * Keeta Network client library
+     */
+    KeetaNet: {
+        lib: {
+            Account: typeof KeetaNet.lib.Account;
+            Utils: {
+                Helper: {
+                    bufferToArrayBuffer: typeof KeetaNet.lib.Utils.Helper.bufferToArrayBuffer;
+                };
+                Buffer: typeof KeetaNet.lib.Utils.Buffer;
+            };
+        };
+    };
+    /**
+     * NodeJS Crypto module, only required for encrypting the seed material
+     * not required otherwise
+     */
+    crypto?: {
+        createPublicKey: typeof crypto.createPublicKey;
+        publicEncrypt: typeof crypto.publicEncrypt;
+        constants: {
+            RSA_PKCS1_OAEP_PADDING: typeof crypto.constants.RSA_PKCS1_OAEP_PADDING;
+        };
+    };
+};
+type AccountKeyAlgorithmNumberOrString = AccountKeyAlgorithm | keyof typeof AccountKeyAlgorithm;
+type KeetaGCPKMSWrappedKeyPairOptions = {
+    /**
+     * The GCP KMS key resource name or config object.
+     * Format: projects/<project>/locations/<location>/keyRings/<keyRing>/cryptoKeys/<key>
+     */
+    kmsKey: string | GCPKMSKeyConfig;
+    /**
+     * The encrypted seed to use for account creation
+     */
+    encryptedSeed: ArrayBuffer;
+    /**
+     * The index of the key to use for account creation (default is 0)
+     */
+    index?: number;
+    /**
+     * Key type for this key
+     */
+    keyType: AccountKeyAlgorithmNumberOrString;
+};
+interface KeetaGCPKMSWrappedKeyPairClass {
+    encryptSeed: (input: ArrayBuffer, options: Omit<KeetaGCPKMSWrappedKeyPairOptions, 'encryptedSeed'>) => Promise<ArrayBuffer>;
+    lookup: (options: KeetaGCPKMSWrappedKeyPairOptions) => Promise<InstanceType<typeof KeetaNet.lib.Account>>;
+    lookupFromJSON: ((input: Pick<KeetaGCPKMSWrappedKeyPairOptions, 'kmsKey' | 'keyType' | 'index'> & {
+        encryptedSeed: string;
+        type: 'gcpkmswrapped';
+    }) => Promise<InstanceType<typeof KeetaNet.lib.Account>>) | ((input: unknown) => Promise<InstanceType<typeof KeetaNet.lib.Account>>);
+    lookupFromString: (input: string) => Promise<InstanceType<typeof KeetaNet.lib.Account>>;
+    getJSONFromOptions: (options: KeetaGCPKMSWrappedKeyPairOptions) => Promise<{
+        type: 'gcpkmswrapped';
+        kmsKey: string;
+        keyType: string;
+        encryptedSeed: string;
+        index: number;
+    }>;
+    getStringFromOptions: (options: KeetaGCPKMSWrappedKeyPairOptions) => Promise<string>;
+}
+export declare function KeetaGCPKMSWrappedKeyPairFactory(packages: KeetaGCPKMSWrappedKeyPairPackages): Omit<KeetaGCPKMSWrappedKeyPairClass, '_Testing'>;
+export {};