@keetanetwork/keetanet-client 0.18.0 → 0.18.2

package/client/builder.d.ts

@@ -3,7 +3,7 @@ import { Account, AccountKeyAlgorithm } from '../lib/account';
 import type { AdjustMethod, BlockHash } from '../lib/block';
 import { Block } from '../lib/block';
 import type { IdentifierCreateArguments, BlockJSONOperations } from '../lib/block/operations';
-import type { AccountInfo, AccountInfoWithoutAccount } from '../lib/ledger/types';
+import type { AccountInfo, AccountInfoWithoutAccount, ACLRow } from '../lib/ledger/types';
 import type { AcceptedPermissionTypes } from '../lib/permissions';
 import type { UserClient, Client } from '.';
 import { Permissions } from '../lib/permissions';
@@ -87,10 +87,15 @@ export interface PendingOperations {
         certificate: Certificate;
         intermediateCertificates: CertificateBundle | null;
     }[];
-    permissionsChanges?: PerAccount<PerAccount<{
-        method: AdjustMethod;
-        permissions: Permissions;
-    }[]>>;
+    permissionsChanges?: {
+        [principalOrCertificate: string]: {
+            principal: ACLRow['principal'];
+            targets: PerAccount<{
+                method: AdjustMethod;
+                permissions: Permissions;
+            }[]>;
+        };
+    };
     info?: AccountInfoWithoutAccount;
     setRep?: Account;
 }
@@ -123,10 +128,18 @@ export interface PendingOperationsJSON {
         certificate: string;
         intermediateCertificates: string | null;
     }[];
-    permissionsChanges?: PerAccount<PerAccount<{
-        method: AdjustMethod;
-        permissions: [string, string];
-    }[]>>;
+    permissionsChanges?: {
+        [principalOrCertificate: string]: {
+            principal: string | {
+                certificate: string;
+                certificateAccount: string;
+            };
+            targets: PerAccount<{
+                method: AdjustMethod;
+                permissions: [string, string];
+            }[]>;
+        };
+    };
     info?: Pick<AccountInfo, 'name' | 'description' | 'metadata'> & {
         defaultPermission?: [string, string];
     };
@@ -183,7 +196,7 @@ export declare class UserClientBuilder {
     computeBlocks(renderOptions: RenderOptions): Promise<ComputeBlocksResponse>;
     send(recipient: AccountOrPending, amount: bigint, token: TokenOrPending, external?: string, options?: BuilderBlockOptions): void;
     receive(from: AccountOrPending, amount: bigint, token: TokenOrPending, exact?: boolean, forward?: GenericAccount, options?: BuilderBlockOptions): void;
-    updatePermissions(principal: GenericAccount, permissions: AcceptedPermissionTypes, target?: GenericAccount, method?: AdjustMethod, options?: BuilderBlockOptions): void;
+    updatePermissions(principal: ACLRow['principal'], permissions: AcceptedPermissionTypes, target?: GenericAccount, method?: AdjustMethod, options?: BuilderBlockOptions): void;
     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;

package/client/index-browser.d.ts

@@ -1204,7 +1204,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
      */
-    updatePermissions(principal: GenericAccount | string, permissions: AcceptedPermissionTypes, target?: GenericAccount | string, method?: AdjustMethod, options?: UserClientOptions): Promise<{
+    updatePermissions(principal: GenericAccount | string | ACLRow['principal'], permissions: AcceptedPermissionTypes, target?: GenericAccount | string, method?: AdjustMethod, options?: UserClientOptions): Promise<{
         voteStaple: VoteStaple;
         publish: boolean;
         from: "direct";

package/client/index-browser.js

@@ -117365,7 +117365,22 @@ class src_client_Certificate {
    * Verify against a given certificate store
    */
 
-  verifyChain(store, _ignore_seenCerts) {
+  /** @internal */
+
+  verifyChain(store) {
+    let seenHashes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new src_client_CertificateHash.Set();
+    /**
+     * Loop detection: reject any certificate already on the current
+     * verification path, per RFC 4158 Section 2.4.1 (no certificate may
+     * repeat in a path) and Section 5.2 (detection guidance).
+     *
+     * @see {@link https://datatracker.ietf.org/doc/html/rfc4158#section-5.2 RFC 4158 Section 5.2}
+     * @see {@link https://datatracker.ietf.org/doc/html/rfc4158#section-2.4.1 RFC 4158 Section 2.4.1}
+     */
+    if (seenHashes.has(client_certificate_assertClassBrand(client_Certificate_brand, this, client_computeHash).call(this))) {
+      return null;
+    }
+
     /*
      * Check to see if the certificate is signed by any of the Root CAs
      */
@@ -117397,6 +117412,8 @@ class src_client_Certificate {
      * Check to see if the certificate is signed by any of the specified intermediates
      */
     if (store.intermediate !== undefined) {
+      const nextSeen = new src_client_CertificateHash.Set(seenHashes);
+      nextSeen.add(client_certificate_assertClassBrand(client_Certificate_brand, this, client_computeHash).call(this));
       store.intermediate.forEach(intermediateCertificate => {
         if (retval !== null) {
           return;
@@ -117404,7 +117421,7 @@ class src_client_Certificate {
         const checkIssued = client_certificate_assertClassBrand(client_Certificate_brand, this, client_checkIssued).call(this, intermediateCertificate);
         if (checkIssued.issued) {
           if (intermediateCertificate.checkValid(this.moment)) {
-            const moreChain = intermediateCertificate.verifyChain(store, undefined /* seenCerts XXX:TODO */);
+            const moreChain = intermediateCertificate.verifyChain(store, nextSeen);
             if (moreChain !== null) {
               const checkRetval = [...moreChain, intermediateCertificate];
               const validChain = src_client_Certificate.verifyChainDepth([...checkRetval, this]);
@@ -117581,12 +117598,13 @@ class src_client_Certificate {
    */
   hash() {
     this.assertConstructed();
-    if (!client_certificate_classPrivateFieldGet(client_hash, this)) {
-      client_certificate_classPrivateFieldSet(client_hash, this, src_client_CertificateHash.fromData(client_certificate_Buffer.from(client_certificate_classPrivateFieldGet(client_raw2, this))));
-    }
-    return client_certificate_classPrivateFieldGet(client_hash, this);
+    return client_certificate_assertClassBrand(client_Certificate_brand, this, client_computeHash).call(this);
   }
 
+  /*
+   * Compute the hash without asserting full construction.
+   */
+
   /**
    * Get a JSON representation of the certificate
    */
@@ -117890,6 +117908,12 @@ function client_checkIssued(issuer) {
     issued: true
   };
 }
+function client_computeHash() {
+  if (!client_certificate_classPrivateFieldGet(client_hash, this)) {
+    client_certificate_classPrivateFieldSet(client_hash, this, src_client_CertificateHash.fromData(client_certificate_Buffer.from(client_certificate_classPrivateFieldGet(client_raw2, this))));
+  }
+  return client_certificate_classPrivateFieldGet(client_hash, this);
+}
 /**
  * The Certificate Builder
  */
@@ -118301,11 +118325,14 @@ async function client_computeLedgerEffect(options, effects, storageProvider, net
         }
       }
     }
-    if (prefetchPromises.length > 70) {
+
+    // Process promises in batches to avoid spanner's 100 concurrent read per session limit
+    if (prefetchPromises.length > 50) {
       const toAwait = prefetchPromises.splice(0);
       await Promise.all(toAwait);
     }
   }
+  // Wait for the final batch to complete
   await Promise.all(prefetchPromises);
   const supplies = {};
   const balances = {};
@@ -127079,6 +127106,48 @@ class client_LedgerRequestCache {
   }
 }
 /* harmony default export */ const client_cache = (client_LedgerRequestCache);
+;// ./src/lib/log/common.ts
+const client_numericLogLevels = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3
+};
+
+/* XXX:TODO -- Do something with this */
+
+function client_canLogForLevel(level, currentLevel) {
+  return client_numericLogLevels[level] >= client_numericLogLevels[currentLevel];
+}
+function client_canLogForTargetLevel(level, targetLevel) {
+  if (targetLevel === 'ALL') {
+    return true;
+  }
+  if (targetLevel === 'NONE') {
+    return false;
+  }
+  return client_canLogForLevel(level, targetLevel);
+}
+function client_filterLog(target, message) {
+  var _message$options$user, _message$options$curr, _message$options$curr2;
+  if (!client_canLogForTargetLevel(message.level, target.logLevel)) {
+    return null;
+  }
+  if (target.filter && !target.filter.test(message.from)) {
+    return null;
+  }
+  return {
+    ...message,
+    options: {
+      userVisible: (_message$options$user = message.options.userVisible) !== null && _message$options$user !== void 0 ? _message$options$user : true,
+      currentRequestInfo: {
+        id: (_message$options$curr = (_message$options$curr2 = message.options.currentRequestInfo) === null || _message$options$curr2 === void 0 ? void 0 : _message$options$curr2.id) !== null && _message$options$curr !== void 0 ? _message$options$curr : '<NO_REQUEST_ID>',
+        ...message.options.currentRequestInfo
+      },
+      ...message.options
+    }
+  };
+}
 // EXTERNAL MODULE: ./node_modules/typia/lib/internal/_assertGuard.js
 var client_assertGuard = __webpack_require__(7422);
 ;// ./src/lib/log/helper.generated.ts
@@ -127156,48 +127225,6 @@ const client_assertLogTargetLevel = (() => {
     return input;
   };
 })();
-;// ./src/lib/log/common.ts
-const client_numericLogLevels = {
-  DEBUG: 0,
-  INFO: 1,
-  WARN: 2,
-  ERROR: 3
-};
-
-/* XXX:TODO -- Do something with this */
-
-function client_canLogForLevel(level, currentLevel) {
-  return client_numericLogLevels[level] >= client_numericLogLevels[currentLevel];
-}
-function client_canLogForTargetLevel(level, targetLevel) {
-  if (targetLevel === 'ALL') {
-    return true;
-  }
-  if (targetLevel === 'NONE') {
-    return false;
-  }
-  return client_canLogForLevel(level, targetLevel);
-}
-function client_filterLog(target, message) {
-  var _message$options$user, _message$options$curr, _message$options$curr2;
-  if (!client_canLogForTargetLevel(message.level, target.logLevel)) {
-    return null;
-  }
-  if (target.filter && !target.filter.test(message.from)) {
-    return null;
-  }
-  return {
-    ...message,
-    options: {
-      userVisible: (_message$options$user = message.options.userVisible) !== null && _message$options$user !== void 0 ? _message$options$user : true,
-      currentRequestInfo: {
-        id: (_message$options$curr = (_message$options$curr2 = message.options.currentRequestInfo) === null || _message$options$curr2 === void 0 ? void 0 : _message$options$curr2.id) !== null && _message$options$curr !== void 0 ? _message$options$curr : '<NO_REQUEST_ID>',
-        ...message.options.currentRequestInfo
-      },
-      ...message.options
-    }
-  };
-}
 ;// ./src/lib/log/target_console.ts
 function client_target_console_classPrivateFieldInitSpec(e, t, a) { client_target_console_checkPrivateRedeclaration(e, t), t.set(e, a); }
 function client_target_console_checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
@@ -127260,11 +127287,13 @@ function client_log_checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new Ty
 function client_log_defineProperty(e, r, t) { return (r = client_log_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function client_log_toPropertyKey(t) { var i = client_log_toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function client_log_toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function client_log_classPrivateGetter(s, r, a) { return a(client_log_assertClassBrand(s, r)); }
 function client_log_classPrivateFieldSet(s, a, r) { return s.set(client_log_assertClassBrand(s, a), r), r; }
 function client_log_classPrivateFieldGet(s, a) { return s.get(client_log_assertClassBrand(s, a)); }
 function client_log_assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
 
 
+
 /**
  * Maximum number of logs to enqueue when there are no targets assigned to a
  * Log instance
@@ -127290,6 +127319,8 @@ var client_destroyed = /*#__PURE__*/new WeakMap();
 var client_emitOnLog = /*#__PURE__*/new WeakMap();
 var client_logDebugTracing = /*#__PURE__*/new WeakMap();
 var client_targets = /*#__PURE__*/new WeakMap();
+var client_filter = /*#__PURE__*/new WeakMap();
+var client_logLevel = /*#__PURE__*/new WeakMap();
 var client_Log_brand = /*#__PURE__*/new WeakSet();
 class client_Log {
   /**
@@ -127379,19 +127410,37 @@ class client_Log {
     /**
      * Whether or not to generate debug tracing information for each log entry
      */
-    client_log_classPrivateFieldInitSpec(this, client_logDebugTracing, false);
+    client_log_classPrivateFieldInitSpec(this, client_logDebugTracing, void 0);
+    /**
+     * Registered log targets (sinks) to send logs to, keyed by a unique
+     * ID returned by `registerTarget()`
+     */
     client_log_classPrivateFieldInitSpec(this, client_targets, new Map());
     /**
-     * The maximum number of log entries to send to each target at a time
+     * Filter to apply before sending to targets
      */
-    client_log_defineProperty(this, "batchSize", 10);
+    client_log_classPrivateFieldInitSpec(this, client_filter, void 0);
+    /**
+     * Log-level to filter for at the logger level
+     */
+    client_log_classPrivateFieldInitSpec(this, client_logLevel, void 0);
     /**
      * Parent logger, if any -- used for creating hierarchical loggers
      */
     client_log_defineProperty(this, "parent", null);
+    /**
+     * The maximum number of log entries to send to each target at a time
+     */
+    client_log_defineProperty(this, "batchSize", 10);
     if ((_options === null || _options === void 0 ? void 0 : _options.logDebugTracing) !== undefined) {
       client_log_classPrivateFieldSet(client_logDebugTracing, this, _options.logDebugTracing);
     }
+    if ((_options === null || _options === void 0 ? void 0 : _options.filter) !== undefined) {
+      client_log_classPrivateFieldSet(client_filter, this, _options.filter);
+    }
+    if ((_options === null || _options === void 0 ? void 0 : _options.logLevel) !== undefined) {
+      client_log_classPrivateFieldSet(client_logLevel, this, _options.logLevel);
+    }
   }
   log() {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
@@ -127504,6 +127553,7 @@ class client_Log {
     }
     return Array.from(client_log_classPrivateFieldGet(client_targets, this).values());
   }
+
   /**
    * Create a child logger instance that shares the same targets as this instance
    * but has its own log queue, this is useful for creating hierarchical loggers
@@ -127512,11 +127562,9 @@ class client_Log {
    * Since the child shares the same targets, registering or unregistering targets
    * from either the parent or child will affect both.
    */
-  createChild() {
+  createChild(options) {
     var _this$parent;
-    const child = new client_Log({
-      logDebugTracing: client_log_classPrivateFieldGet(client_logDebugTracing, this)
-    });
+    const child = new client_Log(options);
 
     /**
      * Attach child nodes to our own parent to collapse
@@ -127642,6 +127690,33 @@ class client_Log {
     client_log_classPrivateFieldSet(client_destroyed, this, true);
   }
 }
+function client_get_logDebugTracing(_this) {
+  if (client_log_classPrivateFieldGet(client_logDebugTracing, _this) !== undefined) {
+    return client_log_classPrivateFieldGet(client_logDebugTracing, _this);
+  }
+  if (_this.parent) {
+    return client_log_classPrivateGetter(client_Log_brand, _this.parent, client_get_logDebugTracing);
+  }
+  return false;
+}
+function client_get_filter(_this2) {
+  if (client_log_classPrivateFieldGet(client_filter, _this2) !== undefined) {
+    return client_log_classPrivateFieldGet(client_filter, _this2);
+  }
+  if (_this2.parent) {
+    return client_log_classPrivateGetter(client_Log_brand, _this2.parent, client_get_filter);
+  }
+  return null;
+}
+function client_get_logLevel(_this3) {
+  if (client_log_classPrivateFieldGet(client_logLevel, _this3) !== undefined) {
+    return client_log_classPrivateFieldGet(client_logLevel, _this3);
+  }
+  if (_this3.parent) {
+    return client_log_classPrivateGetter(client_Log_brand, _this3.parent, client_get_logLevel);
+  }
+  return 'ALL';
+}
 function client_log_log(level, options, from) {
   if (client_log_classPrivateFieldGet(client_destroyed, this)) {
     return;
@@ -127655,7 +127730,13 @@ function client_log_log(level, options, from) {
     from,
     args
   };
-  if (client_log_classPrivateFieldGet(client_logDebugTracing, this)) {
+  if (client_filterLog({
+    logLevel: client_log_classPrivateGetter(client_Log_brand, this, client_get_logLevel),
+    filter: client_log_classPrivateGetter(client_Log_brand, this, client_get_filter)
+  }, log) === null) {
+    return;
+  }
+  if (client_log_classPrivateGetter(client_Log_brand, this, client_get_logDebugTracing)) {
     var _Error$stack$split$sl, _Error$stack;
     log.trace = (_Error$stack$split$sl = (_Error$stack = new Error().stack) === null || _Error$stack === void 0 ? void 0 : _Error$stack.split('\n').slice(2).join('\n')) !== null && _Error$stack$split$sl !== void 0 ? _Error$stack$split$sl : '[No stack trace available]';
   }
@@ -129477,13 +129558,18 @@ async function client_checkPermissionRequirements(effects) {
       throw new client_ledger_KeetaNetLedgerError('LEDGER_INVALID_PERMISSIONS', `Quorum of ${foundInfo.multisigQuorum} not reached for ${multisigPubKey} -- got ${foundSingerLength}`);
     }
   }
-  const checkPromises = [];
-  for (const principalPubKey in requirementsByPrincipal) {
-    const accountRequirements = requirementsByPrincipal[principalPubKey];
-    const principal = client_lib_account.fromPublicKeyString(principalPubKey);
-    checkPromises.push(client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_checkSingleAccountPermissions).call(this, principal, accountRequirements, foundAccountInfo));
+
+  // Process promises in batches to avoid spanner's 100 concurrent read per session limit
+  const batchSize = 50;
+  const principalPubKeys = Object.keys(requirementsByPrincipal);
+  for (let i = 0; i < principalPubKeys.length; i += batchSize) {
+    const batch = principalPubKeys.slice(i, i + batchSize).map(principalPubKey => {
+      const accountRequirements = requirementsByPrincipal[principalPubKey];
+      const principal = client_lib_account.fromPublicKeyString(principalPubKey);
+      return client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_checkSingleAccountPermissions).call(this, principal, accountRequirements, foundAccountInfo);
+    });
+    await Promise.all(batch);
   }
-  await Promise.all(checkPromises);
   return {
     newOwners
   };
@@ -130232,7 +130318,7 @@ client_lib_ledger_defineProperty(src_client_Ledger, "isInstance", client_checkab
 // EXTERNAL MODULE: ws (ignored)
 var client_ws_ignored_ = __webpack_require__(4708);
 ;// ./src/version.ts
-const client_version = '0.18.0+g5417d9af948be899fcebb75694edb492ff971891';
+const client_version = '0.18.2+gac0baac4139da80613edd4a1ebc7532f37fc834a';
 /* harmony default export */ const client_src_version = ((/* unused pure expression or super */ null && (client_version)));
 ;// ./src/lib/p2p.ts
 /* provided dependency */ var client_p2p_Buffer = __webpack_require__(8287)["Buffer"];
@@ -133131,20 +133217,33 @@ class src_client_UserClientBuilder {
         }
         if (operations.permissionsChanges !== undefined) {
           pendingOperations.permissionsChanges = {};
-          for (const accountPubKey in operations.permissionsChanges) {
-            pendingOperations.permissionsChanges[accountPubKey] = {};
-            for (const targetPubKey in operations.permissionsChanges[accountPubKey]) {
+          for (const [certificateOrAccountKey, changes] of Object.entries(operations.permissionsChanges)) {
+            pendingOperations.permissionsChanges[certificateOrAccountKey] = {
+              principal: (() => {
+                if (typeof changes.principal === 'string') {
+                  return src_client_Account.toAccount(changes.principal);
+                } else {
+                  return {
+                    usingCertificate: true,
+                    certificate: new src_client_Certificate.Hash(changes.principal.certificate),
+                    certificateAccount: src_client_Account.toAccount(changes.principal.certificateAccount)
+                  };
+                }
+              })(),
+              targets: {}
+            };
+            for (const targetPubKey in changes.targets) {
               const updateArray = [];
               for (const {
                 method,
                 permissions
-              } of operations.permissionsChanges[accountPubKey][targetPubKey]) {
+              } of changes.targets[targetPubKey]) {
                 updateArray.push({
                   method,
                   permissions: client_permissions_Permissions.FromAcceptedTypes(permissions)
                 });
               }
-              pendingOperations.permissionsChanges[accountPubKey][targetPubKey] = updateArray;
+              pendingOperations.permissionsChanges[certificateOrAccountKey].targets[targetPubKey] = updateArray;
             }
           }
         }
@@ -133594,9 +133693,13 @@ class src_client_UserClientBuilder {
           amount: amount
         });
       }
-      for (const principalPubKey in pending.permissionsChanges) {
-        for (const targetPubKey in pending.permissionsChanges[principalPubKey]) {
-          for (const change of pending.permissionsChanges[principalPubKey][targetPubKey]) {
+      for (const {
+        targets,
+        principal
+      } of Object.values((_pending$permissionsC = pending.permissionsChanges) !== null && _pending$permissionsC !== void 0 ? _pending$permissionsC : {})) {
+        var _pending$permissionsC;
+        for (const targetPubKey in targets) {
+          for (const change of targets[targetPubKey]) {
             const {
               method,
               permissions
@@ -133607,7 +133710,17 @@ class src_client_UserClientBuilder {
             }
             operations.push({
               type: src_client_Block.OperationType.MODIFY_PERMISSIONS,
-              principal: src_client_Account.fromPublicKeyString(principalPubKey),
+              principal: (() => {
+                if (src_client_Account.isInstance(principal)) {
+                  return principal;
+                } else {
+                  return {
+                    usingCertificate: true,
+                    certificateHash: principal.certificate,
+                    certificateAccount: principal.certificateAccount
+                  };
+                }
+              })(),
               target: target,
               method: method,
               permissions: permissions
@@ -133673,18 +133786,26 @@ class src_client_UserClientBuilder {
     let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     client_builder_assertClassBrand(client_UserClientBuilder_brand, this, client_useOptions).call(this, options);
     method = method !== null && method !== void 0 ? method : src_client_Block.AdjustMethod.SET;
-    const principalPubKey = principal.publicKeyString.get();
-    const targetPubKey = (target !== null && target !== void 0 ? target : client_builder_classPrivateFieldGet(client_pendingOptions, this).account).publicKeyString.get();
+    let principalKey;
+    if (typeof principal === 'string' || src_client_Account.isInstance(principal)) {
+      principalKey = src_client_Account.toAccount(principal).publicKeyString.get();
+    } else {
+      principalKey = principal.certificate.toString();
+    }
     if (!client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges) {
       client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges = {};
     }
-    if (!client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges[principalPubKey]) {
-      client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges[principalPubKey] = {};
+    if (!client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges[principalKey]) {
+      client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges[principalKey] = {
+        principal,
+        targets: {}
+      };
     }
-    if (!client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges[principalPubKey][targetPubKey]) {
-      client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges[principalPubKey][targetPubKey] = [];
+    const targetPubKey = (target !== null && target !== void 0 ? target : client_builder_classPrivateFieldGet(client_pendingOptions, this).account).publicKeyString.get();
+    if (!client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges[principalKey].targets[targetPubKey]) {
+      client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges[principalKey].targets[targetPubKey] = [];
     }
-    client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges[principalPubKey][targetPubKey].push({
+    client_builder_classPrivateFieldGet(client_pendingOperations, this).permissionsChanges[principalKey].targets[targetPubKey].push({
       method: method,
       permissions: client_permissions_Permissions.FromAcceptedTypes(permissions)
     });
@@ -136710,7 +136831,13 @@ class src_client_UserClient {
   async updatePermissions(principal, permissions, target, method) {
     let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     const builder = this.initBuilder(options);
-    builder.updatePermissions(client_lib_account.toAccount(principal), permissions, client_lib_account.toAccount(target), method, options);
+    let principalValue;
+    if (typeof principal === 'string' || client_lib_account.isInstance(principal)) {
+      principalValue = client_lib_account.toAccount(principal);
+    } else {
+      principalValue = principal;
+    }
+    builder.updatePermissions(principalValue, permissions, client_lib_account.toAccount(target), method, options);
     return await this.publishBuilder(builder);
   }
 

package/client/index.d.ts

@@ -1204,7 +1204,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
      */
-    updatePermissions(principal: GenericAccount | string, permissions: AcceptedPermissionTypes, target?: GenericAccount | string, method?: AdjustMethod, options?: UserClientOptions): Promise<{
+    updatePermissions(principal: GenericAccount | string | ACLRow['principal'], permissions: AcceptedPermissionTypes, target?: GenericAccount | string, method?: AdjustMethod, options?: UserClientOptions): Promise<{
         voteStaple: VoteStaple;
         publish: boolean;
         from: "direct";