@keetanetwork/keetanet-client 0.14.0 → 0.14.3

package/client/index-browser.js

@@ -101264,6 +101264,7 @@ var client_utils_asn1_namespaceObject = {};
 __webpack_require__.r(client_utils_asn1_namespaceObject);
 __webpack_require__.d(client_utils_asn1_namespaceObject, {
   ASN1BigIntToBuffer: () => (client_ASN1BigIntToBuffer),
+  ASN1CheckUtilities: () => (client_ASN1CheckUtilities),
   ASN1IntegerToBigInt: () => (client_ASN1IntegerToBigInt),
   ASN1toJS: () => (client_ASN1toJS),
   BufferStorageASN1: () => (client_BufferStorageASN1),
@@ -113180,7 +113181,16 @@ function client_isASN1Set(input) {
   }
   return true;
 }
-function client_isASN1ContextTag(input) {
+function client_isASN1ContextTagKind(input) {
+  if (typeof input !== 'string') {
+    return false;
+  }
+  if (!['explicit', 'implicit'].includes(input)) {
+    return false;
+  }
+  return true;
+}
+function client_isASN1ContextTag(input, tagKind) {
   if (!client_isASN1Object(input)) {
     return false;
   }
@@ -113193,6 +113203,12 @@ function client_isASN1ContextTag(input) {
   if (!('contains' in input) || input.contains === undefined) {
     return false;
   }
+  if (!('kind' in input) || !client_isASN1ContextTagKind(input.kind)) {
+    return false;
+  }
+  if (tagKind !== undefined && input.kind !== tagKind) {
+    return false;
+  }
   return true;
 }
 function client_isASN1BitString(input) {
@@ -113249,6 +113265,15 @@ function client_isStringValidForKind(input, kind) {
   }
   return false;
 }
+const client_ASN1CheckUtilities = {
+  isASN1Object: client_isASN1Object,
+  isASN1OID: client_isASN1OID,
+  isASN1String: client_isASN1String,
+  isASN1Set: client_isASN1Set,
+  isASN1ContextTag: client_isASN1ContextTag,
+  isASN1BitString: client_isASN1BitString,
+  isASN1Date: client_isASN1Date
+};
 
 /**
  * Validation function for {@link isValidSequenceSchema}
@@ -115300,7 +115325,7 @@ function client_certificate_toPrimitive(t, r) { if ("object" != typeof t || !t)
 
 
 const client_CertificateErrorType = 'CERTIFICATE';
-const client_certificate_BlockErrorCodes = ['DUPLICATE_INCLUDED', 'ORPHAN_FOUND', 'CYCLE_FOUND', 'SECONDARY_GRAPH'];
+const client_certificate_BlockErrorCodes = ['DUPLICATE_INCLUDED', 'ORPHAN_FOUND', 'CYCLE_FOUND', 'SECONDARY_GRAPH', 'MISSING_FIELD', 'SIGNATURE_ALGORITHM_MISMATCH', 'SELF_SIGNED_VALIDATION_FAILED', 'CHAIN_VERIFICATION_FAILED', 'DUPLICATE_EXTENSION', 'EXTENSION_NOT_PROCESSED', 'INVALID_SIGNATURE_ALGORITHM', 'INVALID_GRAPH_COUNT', 'MOMENT_INVALID', 'INVALID_VERSION'];
 class src_client_KeetaNetCertificateError extends src_client_KeetaNetError {
   constructor(code, message) {
     super(code, message, {
@@ -115473,7 +115498,7 @@ class client_CertificateBuilder {
         case 'sha3-256':
           return hashLib.name;
         default:
-          throw new Error(`Unsupported hash algorithm "${hashLib.name}"`);
+          throw new Error(`internal error: Unsupported hash algorithm "${hashLib.name}"`);
       }
     }
     const hashName = (_params$hashParams$de = (_params$hashParams = params.hashParams) === null || _params$hashParams === void 0 || (_params$hashParams = _params$hashParams.defaults) === null || _params$hashParams === void 0 ? void 0 : _params$hashParams[purpose]) !== null && _params$hashParams$de !== void 0 ? _params$hashParams$de : client_defaultHashName;
@@ -115496,7 +115521,7 @@ class client_CertificateBuilder {
     const hashName = this.hashName(params, purpose);
     const hashFunction = (_params$hashParams$fu = params.hashParams.functions) === null || _params$hashParams$fu === void 0 ? void 0 : _params$hashParams$fu[hashName];
     if (hashFunction === undefined) {
-      throw new Error(`Hash function "${hashName}" not found for purpose "${purpose}"`);
+      throw new Error(`internal error: Hash function "${hashName}" not found for purpose "${purpose}"`);
     }
     return hashFunction(...data);
   }
@@ -115604,28 +115629,28 @@ class client_CertificateBuilder {
     /* Validate that required parameters are set */
     const issuer = finalParams.issuer;
     if (issuer === undefined) {
-      throw new Error('"issuer" not set');
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_MISSING_FIELD', '"issuer" not set');
     }
     const subjectPublicKey = finalParams.subjectPublicKey;
     if (subjectPublicKey === undefined) {
-      throw new Error('"subject" not set');
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_MISSING_FIELD', '"subject" not set');
     }
     const validFrom = finalParams.validFrom;
     if (validFrom === undefined) {
-      throw new Error('"validFrom" not set');
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_MISSING_FIELD', '"validFrom" not set');
     }
     const validTo = finalParams.validTo;
     if (validTo === undefined) {
-      throw new Error('"validTo" not set');
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_MISSING_FIELD', '"validTo" not set');
     }
     const serial = finalParams.serial;
     if (serial === undefined) {
-      throw new Error('"serialNumber" not set');
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_MISSING_FIELD', '"serialNumber" not set');
     }
     const hashLib = finalParams.hashLib;
     const hashParams = finalParams.hashParams;
     if (hashParams === undefined) {
-      throw new Error('"hashParams" not set');
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_MISSING_FIELD', '"hashParams" not set');
     }
     return {
       ...finalParams,
@@ -115967,7 +115992,7 @@ class src_client_Certificate {
     const tbsCertificate = parts[0];
     const [version, serialNumber, signatureAlgorithmSigned, _issuer, [notBefore, notAfter], subject, subjectPublicKey, _extensions] = tbsCertificate;
     if (version.contains !== 2n) {
-      throw new Error('Only X509v3 certificates are supported');
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_INVALID_VERSION', 'Only X509v3 certificates are supported');
     }
     const signatureAlgorithm = parts[1];
 
@@ -116012,7 +116037,7 @@ class src_client_Certificate {
     const signatureAlgorithmSignedBuffer = new client_BufferStorageASN1(signatureAlgorithmSigned).getDERBuffer();
     const signatureAlgorithmBuffer = new client_BufferStorageASN1(signatureAlgorithm).getDERBuffer();
     if (!signatureAlgorithmSignedBuffer.equals(signatureAlgorithmBuffer)) {
-      throw new Error('Signature algorithm mismatch');
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_SIGNATURE_ALGORITHM_MISMATCH', 'Signature algorithm mismatch between signature and certificate');
     }
 
     /*
@@ -116044,7 +116069,7 @@ class src_client_Certificate {
             }
           });
           if (!found) {
-            throw new Error('Self-signed certificate is not a root CA in the Root CA store');
+            throw new src_client_KeetaNetCertificateError('CERTIFICATE_SELF_SIGNED_VALIDATION_FAILED', 'Self-signed certificate is not a root CA in the Root CA store');
           }
           this.chain = [this];
         }
@@ -116053,7 +116078,7 @@ class src_client_Certificate {
         this.chain = [this];
       }
       if (!this.verify(this)) {
-        throw new Error('Self-signed certificate signature verification failed');
+        throw new src_client_KeetaNetCertificateError('CERTIFICATE_SELF_SIGNED_VALIDATION_FAILED', 'Self-signed certificate signature verification failed');
       }
     } else {
       /*
@@ -116062,7 +116087,7 @@ class src_client_Certificate {
       if ((options === null || options === void 0 ? void 0 : options.store) !== undefined) {
         const chain = this.verifyChain(options.store);
         if (chain === null || chain.length === 0) {
-          throw new Error('Certificate chain verification failed');
+          throw new src_client_KeetaNetCertificateError('CERTIFICATE_CHAIN_VERIFICATION_FAILED', 'Certificate chain verification failed');
         }
         this.chain = chain;
       }
@@ -116130,7 +116155,7 @@ class src_client_Certificate {
         compatibleKeyTypes = [client_lib_account.AccountKeyAlgorithm.ED25519];
         break;
       default:
-        throw new Error(`Unsupported signature algorithm ${signatureAlgorithm}`);
+        throw new src_client_KeetaNetCertificateError('CERTIFICATE_INVALID_SIGNATURE_ALGORITHM', `Unsupported signature algorithm ${signatureAlgorithm}`);
     }
     let hashAlgorithm;
     switch (signatureAlgorithm) {
@@ -116144,7 +116169,7 @@ class src_client_Certificate {
         hashAlgorithm = null;
         break;
       default:
-        throw new Error(`Unsupported signature algorithm ${signatureAlgorithm}`);
+        throw new src_client_KeetaNetCertificateError('CERTIFICATE_INVALID_SIGNATURE_ALGORITHM', `Unsupported signature algorithm ${signatureAlgorithm}`);
     }
     let accountIsCompatible = false;
     for (const checkCompatibleKeyType of compatibleKeyTypes) {
@@ -116154,7 +116179,7 @@ class src_client_Certificate {
       }
     }
     if (!accountIsCompatible) {
-      throw new Error(`Account does not have a compatible key type for signature algorithm ${signatureAlgorithm}`);
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_INVALID_SIGNATURE_ALGORITHM', `Account does not have a compatible key type for signature algorithm ${signatureAlgorithm}`);
     }
     let dataToVerify;
     if (hashAlgorithm !== null) {
@@ -116181,7 +116206,7 @@ class src_client_Certificate {
       return true;
     }
     if (certificates.size > 10) {
-      throw new Error('Cannot currently handle more than 10 certificates in a graph');
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_INVALID_GRAPH_COUNT', 'Cannot currently handle more than 10 certificates in a graph');
     }
     const issuersFrom = [];
     const issuersTo = [];
@@ -116302,7 +116327,7 @@ class src_client_Certificate {
   assertValid(moment) {
     const valid = this.checkValid(moment, true);
     if (!valid.valid) {
-      throw new Error(`Certificate is not valid: ${valid.reason}`);
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_MOMENT_INVALID', `Certificate is not valid: ${valid.reason}`);
     }
   }
 
@@ -116376,7 +116401,7 @@ class src_client_Certificate {
   }
   assertConstructed() {
     if (!client_certificate_classPrivateFieldGet(client_finalizeConstructionCalled, this)) {
-      throw new Error('finalizeConstruction not called');
+      throw new Error('internal error: finalizeConstruction not called');
     }
   }
 
@@ -116519,7 +116544,7 @@ function client_processBaseExtensions(extensionsObject) {
   for (const extension of extensions) {
     const id = extension[0].oid;
     if (seenExtensions.has(id)) {
-      throw new Error(`Duplicate extension ${id}`);
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_DUPLICATE_EXTENSION', `Duplicate extension ${id}`);
     }
     seenExtensions.add(id);
   }
@@ -116590,7 +116615,7 @@ function client_assertAllCriticalExtensionsProcessed() {
       [id] = extension;
     }
     if (critical && !client_certificate_classPrivateFieldGet(client_extensionsProcessed, this).has(id.oid)) {
-      throw new Error(`Critical extension ${id.oid} not processed`);
+      throw new src_client_KeetaNetCertificateError('CERTIFICATE_EXTENSION_NOT_PROCESSED', `Critical extension ${id.oid} not processed`);
     }
   }
 }
@@ -116718,7 +116743,7 @@ function client_ledger_toPrimitive(t, r) { if ("object" != typeof t || !t) retur
 
 
 const client_LedgerErrorType = 'LEDGER';
-const client_LedgerErrorCodes = ['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',
+const client_LedgerErrorCodes = ['BLOCK_ALREADY_EXISTS', '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 Errors
 'FEE_AMOUNT_MISMATCH', 'FEE_TOKEN_MISMATCH', 'FEE_MISSING', 'MISSING_REQUIRED_FEE_BLOCK', 'PERM_VOTE_WITH_QUOTE', 'QUOTE_MISMATCH', 'REQUIRED_FEE_MISMATCH'];
 class client_ledger_KeetaNetLedgerError extends src_client_KeetaNetError {
@@ -117247,10 +117272,36 @@ class client_LedgerStorageBase {
     }));
     return Object.fromEntries(response);
   }
+  async getAccountsBlockHeightInfo(transaction, toFetch) {
+    const response = await Promise.all(toFetch.map(async _ref2 => {
+      let {
+        blockHash,
+        account
+      } = _ref2;
+      if (blockHash === undefined) {
+        const block = await this.getHeadBlock(transaction, account, 'main');
+        if (block !== null) {
+          blockHash = block.hash;
+        }
+      }
+      const retval = [];
+      if (blockHash === undefined) {
+        retval.push(...[account.publicKeyString.get(), null]);
+      } else {
+        const height = await this.getBlockHeight(transaction, blockHash, account);
+        retval.push(...[account.publicKeyString.get(), {
+          blockHash,
+          height
+        }]);
+      }
+      return retval;
+    }));
+    return Object.fromEntries(response);
+  }
   async getHeadBlockHashes(transaction, accounts) {
     const received = await this.getHeadBlocks(transaction, accounts.toArray(), 'both');
-    return Object.fromEntries(Object.entries(received).map(function (_ref2) {
-      let [account, value] = _ref2;
+    return Object.fromEntries(Object.entries(received).map(function (_ref3) {
+      let [account, value] = _ref3;
       if (value) {
         return [account, value.hash];
       } else {
@@ -117261,6 +117312,20 @@ class client_LedgerStorageBase {
   async preAdjust(input) {
     let mayDefer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
     let transaction = arguments.length > 2 ? arguments[2] : undefined;
+    const allBlockHeightsToFetch = input.blocks.map(block => {
+      return {
+        blockHash: block.hash,
+        account: block.account
+      };
+    });
+    const allBlockHeights = await this.getBlockHeights(transaction, allBlockHeightsToFetch);
+
+    // Check if any blocks already exist on the ledger that would cause this staple to fail and exit early
+    for (const [blockHash, blockHeight] of Object.entries(allBlockHeights)) {
+      if (blockHeight !== null) {
+        throw new KeetaNetLedgerError('LEDGER_BLOCK_ALREADY_EXISTS', `Block Already Exists: ${blockHash.toString()}`);
+      }
+    }
     const seenBlockHashes = new BlockHash.Set();
     const blockHeights = {};
     const toFetch = [];
@@ -118688,37 +118753,18 @@ function client_ExportBlockOperations(operations) {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return container;
 }
-function client_assertExplicitContextValueLike(input) {
-  if (typeof input !== 'object' || input === null) {
-    throw new Error(`Found entry which is not a context ${String(input)}`);
-  }
-  if (!('type' in input) || input.type !== 'context') {
-    throw new Error(`Found entry which is not a context ${String(input)}`);
-  }
-  if (!('kind' in input) || input.kind !== 'explicit') {
-    throw new Error(`Found entry which is not an explicit context ${String(input)}`);
-  }
-  if (!('value' in input)) {
-    throw new Error(`Found entry which is not a numeric explicit context ${String(input)}`);
-  }
-  const typeInput = input.value;
-  if (typeof typeInput !== 'number') {
-    throw new Error(`Found entry which is not a numeric explicit context ${String(input)}`);
-  }
-  if (!('contains' in input)) {
-    throw new Error(`Found entry which which lacks contains ${JSON.stringify(input)}`);
-  }
-  if (!Array.isArray(input.contains)) {
-    throw new Error(`Found entry which is not a Sequence ${input.contains}`);
-  }
-}
 function client_ImportOperationsASN1(input, network) {
   const retval = [];
   for (const entryWrapper of input) {
     const operation = {};
-    client_assertExplicitContextValueLike(entryWrapper);
+    if (!client_ASN1CheckUtilities.isASN1ContextTag(entryWrapper, 'explicit')) {
+      throw new Error('Invalid createArgs type for CREATE_IDENTIFIER operation');
+    }
     const type = client_assertOperationType(entryWrapper.value);
     const entry = entryWrapper.contains;
+    if (!Array.isArray(entry)) {
+      throw new Error(`Found entry which is not a Sequence ${typeof entry}`);
+    }
     const typeStr = client_operationTypeToString(type);
     const operationSchema = client_BlockOperationASN1SchemaBase[typeStr];
     if (!operationSchema) {
@@ -118747,16 +118793,24 @@ function client_ImportOperationsASN1(input, network) {
         newKeyValue.validate(network);
         keyValueOut = newKeyValue;
       } else if (key === 'createArguments' && typeStr === 'CREATE_IDENTIFIER') {
-        client_assertExplicitContextValueLike(keyValueIn);
+        if (!client_ASN1CheckUtilities.isASN1ContextTag(keyValueIn, 'explicit')) {
+          throw new Error('Invalid createArgs type for CREATE_IDENTIFIER operation');
+        }
         if (keyValueIn.value !== client_AccountKeyAlgorithm.MULTISIG) {
           throw new Error('unrecognized type for multisig create arguments');
         }
-        if (keyValueIn.contains.length !== 2 || !Array.isArray(keyValueIn.contains[0])) {
+        if (!Array.isArray(keyValueIn.contains) || keyValueIn.contains.length !== 2) {
+          throw new Error('Invalid createArgs container');
+        }
+        if (!Array.isArray(keyValueIn.contains[0])) {
           throw new Error('Invalid createArgs container');
         }
         keyValueOut = {
           type: keyValueIn.value,
           signers: keyValueIn.contains[0].map(function (value) {
+            if (!client_operations_Buffer.isBuffer(value)) {
+              throw new Error(`Invalid signer value, expected Buffer, got ${typeof value}`);
+            }
             return client_lib_account.fromPublicKeyAndType(value);
           }),
           quorum: keyValueIn.contains[1]
@@ -125017,1855 +125071,1910 @@ class client_RequestTiming {
 }
 client_timing_defineProperty(client_RequestTiming, "defaultLogger", console);
 /* harmony default export */ const src_client_timing = (client_RequestTiming);
-;// ./src/lib/ledger/index.ts
-var client_Ledger;
-function client_usingCtx2() { var r = "function" == typeof SuppressedError ? SuppressedError : function (r, e) { var n = Error(); return n.name = "SuppressedError", n.error = r, n.suppressed = e, n; }, e = {}, n = []; function using(r, e) { if (null != e) { if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined."); if (r) var o = e[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")]; if (void 0 === o && (o = e[Symbol.dispose || Symbol.for("Symbol.dispose")], r)) var t = o; if ("function" != typeof o) throw new TypeError("Object is not disposable."); t && (o = function () { try { t.call(e); } catch (r) { return Promise.reject(r); } }), n.push({ v: e, d: o, a: r }); } else r && n.push({ d: e, a: r }); return e; } return { e: e, u: using.bind(null, !1), a: using.bind(null, !0), d: function () { var o, t = this.e, s = 0; function next() { for (; o = n.pop();) try { if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next); if (o.d) { var r = o.d.call(o.v); if (o.a) return s |= 2, Promise.resolve(r).then(next, err); } else s |= 1; } catch (r) { return err(r); } if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve(); if (t !== e) throw t; } function err(n) { return t = t !== e ? new r(n, t) : n, next(); } return next(); } }; }
-function client_lib_ledger_defineProperty(e, r, t) { return (r = client_lib_ledger_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function client_lib_ledger_toPropertyKey(t) { var i = client_lib_ledger_toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function client_lib_ledger_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_ledger_classPrivateMethodInitSpec(e, a) { client_ledger_checkPrivateRedeclaration(e, a), a.add(e); }
-function client_ledger_classPrivateFieldInitSpec(e, t, a) { client_ledger_checkPrivateRedeclaration(e, t), t.set(e, a); }
-function client_ledger_checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function client_ledger_classPrivateFieldGet(s, a) { return s.get(client_ledger_assertClassBrand(s, a)); }
-function client_ledger_classPrivateFieldSet(s, a, r) { return s.set(client_ledger_assertClassBrand(s, a), r), r; }
-function client_ledger_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"); }
-
-
-
-
-
-
-
-
-
-
-
-
-
-/**
- * Kind of ledger
- */
-let client_LedgerKind = /*#__PURE__*/function (LedgerKind) {
-  LedgerKind[LedgerKind["REPRESENTATIVE"] = 0] = "REPRESENTATIVE";
-  LedgerKind[LedgerKind["ACCOUNT"] = 1] = "ACCOUNT";
-  return LedgerKind;
-}({});
-
-/**
- * Ledger configuration
- */
-
-/**
- * Which ledger to store this data in
- */
-
-/**
- * Which ledger(s) to pull the data from
- */
-
-/**
- * A set of votes and a pointer to the next set/page
- */
-
-/**
- * Options for "getVotesAfter"
- */
-
-/**
- * Each transaction can contain the node object making the request to access things like timing information
- */
-
-/**
- * Each Ledger Storage backend must implement this interface
- */
-var client_network = /*#__PURE__*/new WeakMap();
-var client_subnet = /*#__PURE__*/new WeakMap();
-var client_kind = /*#__PURE__*/new WeakMap();
-var client_ledger_privateKey = /*#__PURE__*/new WeakMap();
-var client_computeFeeFromBlocks = /*#__PURE__*/new WeakMap();
-var client_ledger_storage = /*#__PURE__*/new WeakMap();
-var src_client_ledger = /*#__PURE__*/new WeakMap();
-var src_client_cache = /*#__PURE__*/new WeakMap();
-var client_transaction = /*#__PURE__*/new WeakMap();
-var client_LedgerAtomicInterface_brand = /*#__PURE__*/new WeakSet();
-/**
- * Atomic transactional interface to a storage backend
- */
-class client_LedgerAtomicInterface {
-  constructor(_transaction2, storage, config, ledger) {
-    client_ledger_classPrivateMethodInitSpec(this, client_LedgerAtomicInterface_brand);
-    client_ledger_classPrivateFieldInitSpec(this, client_network, void 0);
-    client_ledger_classPrivateFieldInitSpec(this, client_subnet, void 0);
-    client_ledger_classPrivateFieldInitSpec(this, client_kind, void 0);
-    client_ledger_classPrivateFieldInitSpec(this, client_ledger_privateKey, void 0);
-    client_ledger_classPrivateFieldInitSpec(this, client_computeFeeFromBlocks, void 0);
-    client_ledger_classPrivateFieldInitSpec(this, client_ledger_storage, void 0);
-    client_ledger_classPrivateFieldInitSpec(this, src_client_ledger, void 0);
-    client_ledger_classPrivateFieldInitSpec(this, src_client_cache, void 0);
-    client_ledger_classPrivateFieldInitSpec(this, client_transaction, void 0);
-    client_ledger_classPrivateFieldSet(client_network, this, config.network);
-    client_ledger_classPrivateFieldSet(client_subnet, this, config.subnet);
-    client_ledger_classPrivateFieldSet(client_kind, this, config.kind);
-    client_ledger_classPrivateFieldSet(client_ledger_privateKey, this, config.privateKey);
-    client_ledger_classPrivateFieldSet(client_computeFeeFromBlocks, this, config.computeFeeFromBlocks);
-    client_ledger_classPrivateFieldSet(src_client_ledger, this, ledger);
-    client_ledger_classPrivateFieldSet(client_ledger_storage, this, storage);
-    client_ledger_classPrivateFieldSet(client_transaction, this, _transaction2);
+;// ./src/lib/kv/index.ts
+function client_kv_defineProperty(e, r, t) { return (r = client_kv_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function client_kv_toPropertyKey(t) { var i = client_kv_toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function client_kv_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); }
 
-    /**
-     * Link the storage driver's cache to the transaction cache
-     */
-    let existingCache;
-    if ('cache' in storage && storage.cache !== undefined) {
-      existingCache = storage.cache(_transaction2);
-    }
-    if (existingCache !== undefined) {
-      client_ledger_classPrivateFieldSet(src_client_cache, this, existingCache);
-    } else {
-      client_ledger_classPrivateFieldSet(src_client_cache, this, new client_cache());
+class client_KVStorageProviderBase {
+  constructor() {
+    client_kv_defineProperty(this, "id", (0,client_lib_crypto.randomUUID)());
+  }
+  async xor(_ignored_arena, key, _ignored_change, _ignored_options) {
+    if (key.startsWith('@buffer:')) {
+      return;
     }
+    throw new Error('Key provided for XOR must begin with "@buffer"');
   }
-  async commit() {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    client_ledger_classPrivateFieldSet(client_transaction, this, null);
-    await client_ledger_classPrivateFieldGet(client_ledger_storage, this).commitTransaction(transaction);
+}
+;// ./src/lib/kv/kv_memory.ts
+function client_kv_memory_classPrivateMethodInitSpec(e, a) { client_kv_memory_checkPrivateRedeclaration(e, a), a.add(e); }
+function client_kv_memory_classPrivateFieldInitSpec(e, t, a) { client_kv_memory_checkPrivateRedeclaration(e, t), t.set(e, a); }
+function client_kv_memory_checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function client_kv_memory_classPrivateFieldGet(s, a) { return s.get(client_kv_memory_assertClassBrand(s, a)); }
+function client_kv_memory_classPrivateFieldSet(s, a, r) { return s.set(client_kv_memory_assertClassBrand(s, a), r), r; }
+function client_kv_memory_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"); }
+
+
+const client_nullArena = 'null:43c98976-2282-44c2-819a-769732ceb847';
+function client_deserialize(value) {
+  if (src_client_BufferStorage.isInstance(value)) {
+    value = value.toString('hex');
   }
-  async abort() {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    client_ledger_classPrivateFieldSet(client_transaction, this, null);
-    await client_ledger_classPrivateFieldGet(client_ledger_storage, this).abortTransaction(transaction);
+  return value;
+}
+var client_db = /*#__PURE__*/new WeakMap();
+var client_KVStorageProviderMemory_brand = /*#__PURE__*/new WeakSet();
+class client_KVStorageProviderMemory extends client_KVStorageProviderBase {
+  constructor() {
+    super();
+    client_kv_memory_classPrivateMethodInitSpec(this, client_KVStorageProviderMemory_brand);
+    client_kv_memory_classPrivateFieldInitSpec(this, client_db, void 0);
+    client_kv_memory_classPrivateFieldSet(client_db, this, {});
   }
-  async vote(blocks, otherVotes, quote) {
-    if (blocks.length === 0) {
-      throw new client_ledger('LEDGER_MISSING_BLOCKS', 'At least one block is required to issue a vote');
+  async set(arena, key, value, options) {
+    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, arena);
+    if (value !== undefined) {
+      if (options !== null && options !== void 0 && options.exclusiveCreate) {
+        if (storeArena[key] !== undefined) {
+          throw new Error('unable to exclusively create this item, already exists');
+        }
+      }
     }
-    if (!client_ledger_classPrivateFieldGet(client_ledger_privateKey, this)) {
-      throw new Error('Cannot vote on block, no private key loaded');
+    let expiry;
+    if ((options === null || options === void 0 ? void 0 : options.ttl) !== undefined) {
+      expiry = Date.now() + options.ttl;
     }
-    if (client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode !== 'read-write') {
-      throw new Error(`May not issue votes in read-only mode, in ${client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode} mode`);
+    if (value === undefined || value === null) {
+      delete storeArena[key];
+      return;
     }
-    const privateKey = client_ledger_classPrivateFieldGet(client_ledger_privateKey, this);
-    const ledgerPubKey = privateKey.publicKeyString.get();
-    if (quote !== undefined) {
-      if (otherVotes !== undefined) {
-        throw new client_ledger('LEDGER_PERM_VOTE_WITH_QUOTE', 'Quote should not be included when requesting permanent votes');
+    storeArena[key] = {
+      value,
+      expiry
+    };
+  }
+  async get(arena, key) {
+    if (arena === null) {
+      arena = client_nullArena;
+    }
+    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, arena);
+    if (!storeArena[key]) {
+      return undefined;
+    }
+    const {
+      expiry,
+      value
+    } = storeArena[key];
+    if (expiry !== undefined) {
+      if (expiry < Date.now()) {
+        delete storeArena[key];
+        return undefined;
       }
-      if (!quote.issuer.comparePublicKey(ledgerPubKey)) {
-        throw new client_ledger('LEDGER_QUOTE_MISMATCH', 'Provided quote does not match issuer public key');
+    }
+    const retval = client_deserialize(value);
+    return retval;
+  }
+  async getAll(arena) {
+    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, arena);
+    const retval = {};
+    for (const key in storeArena) {
+      const value = await this.get(arena, key);
+      if (value === undefined) {
+        continue;
       }
+      retval[key] = value;
     }
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-
-    /**
-     * If there are other votes, ensure one of them was issued by
-     * us and the blocks are in the same order as the set of
-     * blocks we are voting on now
-     */
-    if (otherVotes !== undefined) {
-      let foundOurVote = false;
-      const seenVoteUIDs = new Set();
-      const seenVoteIssuers = new client_lib_account.Set();
-      const possibleFeeBlock = blocks.at(-1);
-      let hasFeeBlock = false;
-      let blockCount = blocks.length;
-      if ((possibleFeeBlock === null || possibleFeeBlock === void 0 ? void 0 : possibleFeeBlock.purpose) === client_BlockPurpose.FEE) {
-        hasFeeBlock = true;
-        blockCount--;
-      }
-      const requiredFees = new Map();
-      for (const checkVote of otherVotes) {
-        if (checkVote.quote === true) {
-          throw new client_ledger('LEDGER_PERM_VOTE_WITH_QUOTE', 'Cannot request permanent votes with quotes');
-        }
-        if (seenVoteUIDs.has(checkVote.$id)) {
-          throw new client_ledger('LEDGER_DUPLICATE_VOTE_FOUND', 'Duplicate vote UID found');
-        }
-        if (seenVoteIssuers.has(checkVote.issuer)) {
-          throw new client_ledger('LEDGER_DUPLICATE_VOTE_ISSUER_FOUND', 'Multiple votes found from same issuer');
-        }
-        seenVoteIssuers.add(checkVote.issuer);
-        seenVoteUIDs.add(checkVote.$id);
-        if (checkVote.fee !== undefined) {
-          requiredFees.set(checkVote.issuer, checkVote.fee);
-        }
-        if (checkVote.$permanent) {
-          throw new client_ledger('LEDGER_CANNOT_EXCHANGE_PERM_VOTE', 'Asked to exchange a permanent vote for a permanent vote');
-        }
-        let blocksDifferFromVoteBlocks = checkVote.blocks.length !== blockCount;
-
-        /* If they do not differ from length alone, compare block hashes */
-        if (!blocksDifferFromVoteBlocks) {
-          for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
-            if (!blocks[blockIndex].hash.compareHexString(checkVote.blocks[blockIndex])) {
-              blocksDifferFromVoteBlocks = true;
-              break;
-            }
-          }
-        }
-        if (blocksDifferFromVoteBlocks) {
-          throw new client_ledger('LEDGER_BLOCKS_DIFFER_FROM_VOTED_ON', 'Asked to exchange different number of blocks for a permanent vote');
-        }
-        if (checkVote.issuer.comparePublicKey(ledgerPubKey)) {
-          foundOurVote = true;
-        }
-      }
-      if (requiredFees.size > 0) {
-        if (!hasFeeBlock) {
-          throw new client_ledger('LEDGER_MISSING_REQUIRED_FEE_BLOCK', 'Missing fee block but votes require it');
-        }
-        if (requiredFees.size !== (possibleFeeBlock === null || possibleFeeBlock === void 0 ? void 0 : possibleFeeBlock.operations.length)) {
-          throw new client_ledger('LEDGER_REQUIRED_FEE_MISMATCH', 'Fee Block Operations do not match required fees');
-        }
-      }
-
-      // Verify that all required fees have been included in the fee block
-      for (const [issuer, fee] of requiredFees) {
-        const foundFee = possibleFeeBlock === null || possibleFeeBlock === void 0 ? void 0 : possibleFeeBlock.operations.find(operation => {
-          var _fee$payTo, _fee$token;
-          const expectedPayTo = (_fee$payTo = fee.payTo) !== null && _fee$payTo !== void 0 ? _fee$payTo : issuer;
-          const expectedToken = (_fee$token = fee.token) !== null && _fee$token !== void 0 ? _fee$token : client_ledger_classPrivateFieldGet(src_client_ledger, this).baseToken;
-          if (operation.type === client_OperationType.SEND && operation.to.comparePublicKey(expectedPayTo)) {
-            if (operation.amount !== fee.amount) {
-              throw new client_ledger('LEDGER_FEE_AMOUNT_MISMATCH', `Fee Amount Mismatch, found: ${operation.amount} expected: ${fee.amount}`);
-            }
-            if (!operation.token.comparePublicKey(expectedToken)) {
-              throw new client_ledger('LEDGER_FEE_TOKEN_MISMATCH', `Fee Token Mismatch, found: ${operation.token.publicKeyString.get()} expected: ${expectedToken.publicKeyString.get()}`);
-            }
-            return true;
-          }
-          return false;
-        });
-        if (foundFee === undefined) {
-          var _fee$payTo$publicKeyS, _fee$payTo2;
-          throw new client_ledger('LEDGER_FEE_MISSING', `Missing Required Fee for ${(_fee$payTo$publicKeyS = (_fee$payTo2 = fee.payTo) === null || _fee$payTo2 === void 0 ? void 0 : _fee$payTo2.publicKeyString.get()) !== null && _fee$payTo$publicKeyS !== void 0 ? _fee$payTo$publicKeyS : issuer.publicKeyString.get()}`);
-        }
-      }
-      if (!foundOurVote) {
-        throw new client_ledger('LEDGER_NO_PERM_WITHOUT_SELF_TEMP', 'Asked to give a permanent vote without a temporary vote from us');
-      }
+    return retval;
+  }
+  async list(arena) {
+    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, arena);
+    return Object.keys(storeArena);
+  }
+  async incr(arena, key, change) {
+    var _previous$value;
+    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, arena);
+    const previous = storeArena[key];
+    let previousValue = (_previous$value = previous === null || previous === void 0 ? void 0 : previous.value) !== null && _previous$value !== void 0 ? _previous$value : 0;
+    if (typeof previousValue !== 'number') {
+      throw new Error('May not increment non-number');
     }
-    const allLedgerHeads = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_validateBlocksForVote).call(this, blocks);
-    const needToGetHeadFor = new client_lib_account.Set(allLedgerHeads.keys());
-    const allHeads = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getHeadBlockHashes(transaction, needToGetHeadFor);
-    for (const [account, expectedBlock] of allLedgerHeads.entries()) {
-      const accountHead = allHeads[account.publicKeyString.get()];
-      if (accountHead === null) {
-        if (!expectedBlock.$opening) {
-          throw new client_ledger('LEDGER_NOT_OPENING', 'Cannot vote on non-opening block for an empty account');
-        }
-        continue;
-      }
-      if (expectedBlock.$opening) {
-        throw new client_ledger('LEDGER_NOT_EMPTY', 'Cannot vote on opening block for a non-empty account');
-      }
-      if (expectedBlock.previous.toString() !== accountHead.toString()) {
-        throw new client_ledger('LEDGER_NOT_SUCCESSOR', 'The block is not the successor to the account head block');
+    let newExpiry;
+    if ((previous === null || previous === void 0 ? void 0 : previous.expiry) !== undefined) {
+      if (previous.expiry < Date.now()) {
+        previousValue = 0;
+      } else {
+        newExpiry = previous.expiry;
       }
     }
-
-    /**
-     * Ensure we have no active vote for another conflicting successor of this block's parent (previous),
-     * which could cause a fork
-     */
-    const previousToCheckFor = blocks.map(b => b.previous);
-    const allPrevious = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVotesFromMultiplePrevious(transaction, previousToCheckFor, 'both', client_lib_account.toAccount(ledgerPubKey));
-    for (const block of blocks) {
-      const previousVotes = allPrevious[block.previous.toString()];
-      if (previousVotes !== null && previousVotes.length > 0) {
-        /**
-         * If we do have a previous vote, we can
-         * replace it with a permanent vote if
-         * there is only 1 previous vote, issued by us,
-         * and it's a short vote
-         */
-
-        let mayReplace = false;
-        if (previousVotes.length === 1 && otherVotes !== undefined && otherVotes.length !== 0) {
-          const ourVote = previousVotes[0];
-          mayReplace = !ourVote.$permanent && ourVote.issuer.comparePublicKey(ledgerPubKey);
-        }
-        if (!mayReplace) {
-          throw new client_ledger('LEDGER_SUCCESSOR_VOTE_EXISTS', `We cannot vote for this block (hash=${block.hash.toString()}), we have an existing vote for a successor (previous votes = ${JSON.stringify(client_toJSONSerializable(previousVotes))})`);
-        }
-      }
+    const newVal = previousValue + change;
+    storeArena[key] = {
+      value: newVal,
+      expiry: newExpiry
+    };
+    return BigInt(newVal);
+  }
+  async xor(arena, key, change) {
+    await super.xor(arena, key, change);
+    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, client_nullArena);
+    const previous = storeArena[key];
+    const value = previous === null || previous === void 0 ? void 0 : previous.value;
+    if (value === undefined) {
+      storeArena[key] = {
+        value: change
+      };
+      return;
     }
-
-    /**
-     * If no other votes have been supplied, validate that the blocks are valid, and issue a short vote
-     */
-    if (otherVotes === undefined) {
-      const vote = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_voteOrQuoteWithFees).call(this, blocks, 'VOTE', quote);
-      const blocksAndVote = src_client_VoteStaple.fromVotesAndBlocks([vote], blocks);
-      await client_ledger_classPrivateFieldGet(client_ledger_storage, this).addPendingVote(transaction, blocksAndVote);
-      return vote;
+    if (!src_client_BufferStorage.isInstance(value) || previous.expiry !== undefined) {
+      throw new Error('May only use XOR on keys containing BufferStorage without expiry');
     }
+    const valueBigInt = value.toBigInt();
+    const changeBigInt = change.toBigInt();
+    const valueLength = Math.max(value.length, change.length);
+    const newValue = valueBigInt ^ changeBigInt;
+    storeArena[key] = {
+      value: new src_client_BufferStorage(newValue, valueLength)
+    };
+  }
+}
+function client_getArena(arena) {
+  if (client_kv_memory_classPrivateFieldGet(client_db, this)[arena] === undefined) {
+    client_kv_memory_classPrivateFieldGet(client_db, this)[arena] = {};
+  }
+  return client_kv_memory_classPrivateFieldGet(client_db, this)[arena];
+}
+/* harmony default export */ const client_kv_memory = (client_KVStorageProviderMemory);
+;// ./src/lib/stats.ts
+function client_stats_classPrivateFieldInitSpec(e, t, a) { client_stats_checkPrivateRedeclaration(e, t), t.set(e, a); }
+function client_stats_checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function client_stats_classPrivateFieldGet(s, a) { return s.get(client_stats_assertClassBrand(s, a)); }
+function client_stats_classPrivateFieldSet(s, a, r) { return s.set(client_stats_assertClassBrand(s, a), r), r; }
+function client_stats_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"); }
+function client_stats_defineProperty(e, r, t) { return (r = client_stats_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function client_stats_toPropertyKey(t) { var i = client_stats_toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function client_stats_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); }
 
-    /**
-     * Validate the votes are sufficient weight and grant
-     * our permanent vote
-     */
-    const votesSufficient = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_validateVotingWeight).call(this, otherVotes);
-    if (votesSufficient !== true) {
-      throw new client_ledger('LEDGER_INSUFFICIENT_VOTING_WEIGHT', 'Unable to create a vote from these votes, they do not represent enough voting power');
-    }
 
-    /**
-     * Serial number
-     */
-    const serial = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getNextSerialNumber(client_ledger_classPrivateFieldGet(client_transaction, this));
-    const wipVote = new src_client_VoteBuilder(privateKey);
-    for (const block of blocks) {
-      wipVote.addBlock(block);
-    }
-    const vote = await wipVote.seal(serial, null);
-    const blocksAndVote = src_client_VoteStaple.fromVotesAndBlocks([vote], blocks);
 
-    /**
-     * Add this pending vote to our side ledger;
-     * Replacing an existing temporary vote with a permanent one
-     */
-    await client_ledger_classPrivateFieldGet(client_ledger_storage, this).addPendingVote(transaction, blocksAndVote);
-    return vote;
+/**
+ * Size of the XOR buffer objects -- we use them for block hashes so they
+ * should be the same size as a block hash
+ */
+const client_XOR_BUFFER_SIZE = client_HashFunctionLength;
+const client_durationRanges = {
+  '-1ms': [-1, -1],
+  '0ms': [0, 0],
+  '10ms': [1, 10],
+  '100ms': [11, 100],
+  '200ms': [101, 200],
+  '300ms': [201, 300],
+  '400ms': [301, 400],
+  '500ms': [401, 500],
+  '600ms': [501, 600],
+  '700ms': [601, 700],
+  '800ms': [701, 800],
+  '900ms': [801, 900],
+  '1000ms': [901, 1000],
+  '1500ms': [1001, 1500],
+  '2000ms': [1501, 2000],
+  '5000ms': [2001, 5000],
+  '10000ms': [5001, 10000],
+  '100000ms': [10001, 100000],
+  'ExtraLong': [100000, Number.MAX_SAFE_INTEGER]
+};
+class client_stats_StatsPending {
+  constructor() {
+    client_stats_defineProperty(this, "localDBIncr", {});
+    client_stats_defineProperty(this, "localDBXOR", {});
+  }
+  consume() {
+    const incrChanges = this.localDBIncr;
+    this.localDBIncr = {};
+    const xorChanges = this.localDBXOR;
+    this.localDBXOR = {};
+    return {
+      incrChanges,
+      xorChanges
+    };
   }
-  async quote(blocks) {
-    await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_validateBlocksForVote).call(this, blocks);
-    const quote = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_voteOrQuoteWithFees).call(this, blocks, 'QUOTE');
-    return quote;
+  compoundKey(arena, key) {
+    const compoundKey = [arena, key].join('|');
+    return compoundKey;
   }
-  async add(votesAndBlocks, from) {
-    var _classPrivateFieldGet2, _classPrivateFieldGet3, _classPrivateFieldGet4, _classPrivateFieldGet5;
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    switch (client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode) {
-      case 'read-only':
-        throw new Error('Cannot add blocks to a read-only ledger');
-      case 'bootstrap-only':
-        if (from === 'bootstrap') {
-          break;
-        }
-        throw new Error('Cannot add blocks to a read-only ledger (except for bootstrapping)');
-      case 'read-write':
-      case 'no-voting':
-        break;
-      default:
-        throw new Error(`internal error: invalid ledger write mode: ${client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode}`);
+  incrCompoundKey(compoundKey, change) {
+    if (this.localDBIncr[compoundKey] === undefined) {
+      this.localDBIncr[compoundKey] = 0;
+    }
+    this.localDBIncr[compoundKey] += change;
+  }
+  incr(arena, key) {
+    let change = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+    const compoundKey = this.compoundKey(arena, key);
+    this.incrCompoundKey(compoundKey, change);
+  }
+  xor(key, change) {
+    const changeValue = typeof change === 'bigint' ? change : change.toBigInt();
+    const existingValue = this.localDBXOR[key];
+    if (existingValue === undefined) {
+      this.localDBXOR[key] = changeValue;
+      return;
     }
+    this.localDBXOR[key] ^= changeValue;
+  }
+  merge(pending) {
     const {
-      votes,
-      blocks
-    } = votesAndBlocks;
-    if (votes.length < 1) {
-      throw new Error('Must have at least 1 vote in the staple');
+      incrChanges,
+      xorChanges
+    } = pending.consume();
+    // Merge incr changes
+    for (const [key, value] of Object.entries(incrChanges)) {
+      this.incrCompoundKey(key, value);
     }
-    for (const block of blocks) {
-      if (block.network !== client_ledger_classPrivateFieldGet(client_network, this)) {
-        throw new Error('Cannot process block for a different network');
-      }
-      if (block.subnet !== client_ledger_classPrivateFieldGet(client_subnet, this)) {
-        throw new Error('Cannot process block for a different subnet');
-      }
+
+    // Merge xor changes
+    for (const [key, value] of Object.entries(xorChanges)) {
+      this.xor(key, value);
     }
-    for (const vote of votes) {
-      if (!vote.$permanent) {
-        throw new Error('Can only insert permanent votes');
-      }
+  }
+}
+var client_syncPromise = /*#__PURE__*/new WeakMap();
+var client_kv = /*#__PURE__*/new WeakMap();
+class client_Stats extends client_stats_StatsPending {
+  constructor(config) {
+    super();
+    client_stats_classPrivateFieldInitSpec(this, client_syncPromise, void 0);
+    client_stats_classPrivateFieldInitSpec(this, client_kv, void 0);
+    let kv = config.kv;
+    if (kv === null) {
+      kv = new client_kv_memory();
     }
-    const weightTiming = (_classPrivateFieldGet2 = client_ledger_classPrivateFieldGet(src_client_ledger, this).node) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.timing.startTime('db-add/getWeight');
-    const votesSufficient = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_validateVotingWeight).call(this, votesAndBlocks.votes);
-    if (votesSufficient !== true) {
-      throw new client_ledger('LEDGER_INSUFFICIENT_VOTING_WEIGHT', 'Votes attached do not represent enough voting power');
+    client_stats_classPrivateFieldSet(client_kv, this, kv);
+  }
+
+  // Return all keys from durationRanges
+  static durationBreakdownList() {
+    // We know the keys are all valid to the type, but typescript does not know this
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return Object.keys(client_durationRanges);
+  }
+  static assertDurationBreakdown(duration) {
+    if (!(duration in client_durationRanges)) {
+      throw new Error(`Invalid duration: ${duration}`);
     }
-    weightTiming === null || weightTiming === void 0 || weightTiming.end();
-    const changesTiming = (_classPrivateFieldGet3 = client_ledger_classPrivateFieldGet(src_client_ledger, this).node) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.timing.startTime('db-add/computeEffectOfBlocks');
-    const changes = client_computeEffectOfBlocks(votesAndBlocks.blocks, client_ledger_classPrivateFieldGet(src_client_ledger, this));
-    changesTiming === null || changesTiming === void 0 || changesTiming.end();
-    const adjustTiming = (_classPrivateFieldGet4 = client_ledger_classPrivateFieldGet(src_client_ledger, this).node) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.timing.startTime('db-add/adjust');
-    const voteStaples = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).adjust(transaction, votesAndBlocks, changes);
-    adjustTiming === null || adjustTiming === void 0 || adjustTiming.end();
-    const postambleTiming = (_classPrivateFieldGet5 = client_ledger_classPrivateFieldGet(src_client_ledger, this).node) === null || _classPrivateFieldGet5 === void 0 ? void 0 : _classPrivateFieldGet5.timing.startTime('db-add/postamble');
-    /**
-     * Add all the block hashes to the node checksum
-     */
-    const ourNode = client_ledger_classPrivateFieldGet(src_client_ledger, this).node;
-    if (ourNode) {
-      for (const staple of voteStaples) {
-        for (const block of staple.blocks) {
-          ourNode.stats.xor('ledgerChecksum', block.hash);
-        }
+  }
+  // Get duration key for specific number
+  static durationBreakdown(duration) {
+    // Loop through ranges and select key with range that fits around duration
+
+    if (duration < 0) {
+      duration = 0;
+    }
+    for (const name of this.durationBreakdownList()) {
+      const [min, max] = client_durationRanges[name];
+      if (duration >= min && (max === undefined || duration <= max)) {
+        return name;
       }
     }
-    postambleTiming === null || postambleTiming === void 0 || postambleTiming.end();
-    return voteStaples;
+    throw new Error(`Time frame not found for duration: ${duration}`);
   }
-  async getBalance(account, token) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const balance = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getBalance(transaction, account, token);
-    if (balance < 0n) {
-      throw new Error(`internal error: Account with negative balance: ${account.publicKeyString.get()}/${client_lib_account.toPublicKeyString(token)}: ${balance}`);
+  static placeholderTimingData() {
+    const ret = {};
+    for (const key of this.durationBreakdownList()) {
+      ret[key] = {
+        count: -1,
+        range: client_stats_assertClassBrand(client_Stats, this, client_getDurationRange).call(this, key)
+      };
     }
-    return balance;
+
+    // We know this fits TimeStats because we just created it with all of the keys
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return ret;
   }
-  async getAllBalances(account) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const balances = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAllBalances(transaction, account);
-    for (const {
-      token,
-      balance
-    } of balances) {
-      if (balance < 0n) {
-        throw new Error(`internal error: Account with negative balance: ${account.publicKeyString.get()}/${token.publicKeyString.get()}: ${balance}`);
-      }
+  async getXor(key) {
+    await client_stats_classPrivateFieldGet(client_syncPromise, this);
+    const bufferKey = `@buffer:${key}`;
+    const baseString = await client_stats_classPrivateFieldGet(client_kv, this).get(null, bufferKey);
+    let base = 0n;
+    if (baseString !== undefined) {
+      base = BigInt(`0x${baseString}`);
     }
-    return balances;
-  }
-  async getAccountCertificates(account) {
-    client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    return await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountCertificates(client_ledger_classPrivateFieldGet(client_transaction, this), account);
+    let local = 0n;
+    if (this.localDBXOR[key] !== undefined) {
+      local = this.localDBXOR[key];
+    }
+    const computed = base ^ local;
+    const retval = new src_client_BufferStorage(computed, client_XOR_BUFFER_SIZE);
+    return retval;
   }
-  async getAccountCertificateByHash(account, hash) {
-    client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    return await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountCertificateByHash(client_ledger_classPrivateFieldGet(client_transaction, this), account, hash);
+
+  // Calculate key and increment for specific duration/category
+  addTimingPoint(arena, category, duration) {
+    let returnOnly = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    const breakdown = client_Stats.durationBreakdown(duration);
+    const params = [arena, `${category}@${breakdown}`, 1];
+    if (returnOnly !== true) {
+      this.incr(...params);
+    }
+    return params;
   }
-  async listACLsByPrincipal(principal, entityList) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const permissions = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).listACLsByPrincipal(transaction, principal, entityList);
-    return permissions;
+  addRequestTiming(arena, timing) {
+    let returnOnly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    const retval = [];
+    for (const sectionInfo of Object.values(timing.getAllTiming())) {
+      const duration = sectionInfo.duration;
+      const name = sectionInfo.name;
+      retval.push(this.addTimingPoint(arena, name, duration, returnOnly));
+    }
+    return retval;
   }
-  async listACLsByEntity(entity) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const permissions = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).listACLsByEntity(transaction, entity);
-    return permissions;
+  async get(arena, key) {
+    await client_stats_classPrivateFieldGet(client_syncPromise, this);
+    const compoundKey = this.compoundKey(arena, key);
+    let base = await client_stats_classPrivateFieldGet(client_kv, this).get('stats', compoundKey);
+    if (base === undefined) {
+      base = 0;
+    }
+    if (typeof base === 'string') {
+      base = Number(base);
+    }
+    if (typeof base !== 'number' || isNaN(base)) {
+      throw new Error('internal error: corrupt data in stats table');
+    }
+    let local = 0;
+    if (this.localDBIncr[compoundKey] !== undefined) {
+      local = this.localDBIncr[compoundKey];
+    }
+    return base + local;
   }
-  async votingPower(rep) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const weight = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).delegatedWeight(transaction, rep);
 
-    /* Voting Power = Weight (for now) */
-    return weight;
-  }
-  async getVotes(block) {
-    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVotes(transaction, block, from);
+  // Get all timing data from specific arena/category
+  async getTimingData(arena, category) {
+    const retval = client_Stats.placeholderTimingData();
+    const keys = Object.keys(retval);
+    client_assertDurationBreakdowns.call(client_Stats, keys);
+    await Promise.all(keys.map(async breakdown => {
+      const key = `${category}@${breakdown}`;
+      const range = client_getDurationRange.call(client_Stats, breakdown);
+      let count = -1;
+      try {
+        count = await this.get(arena, key);
+      } catch (_ignored_error) {
+        /* Errors fetching single stat are ignored */
+      } finally {
+        retval[breakdown] = {
+          count,
+          range
+        };
+      }
+    }));
     return retval;
   }
-  async getVotesFromMultiplePrevious(prevBlocks) {
-    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
-    let issuer = arguments.length > 2 ? arguments[2] : undefined;
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVotesFromMultiplePrevious(transaction, prevBlocks, from, issuer);
-    return retval;
+  async sync() {
+    const {
+      incrChanges,
+      xorChanges
+    } = this.consume();
+    await client_stats_classPrivateFieldGet(client_syncPromise, this);
+    client_stats_classPrivateFieldSet(client_syncPromise, this, (async () => {
+      const updatePromises = [];
+      for (const [key, value] of Object.entries(incrChanges)) {
+        if (value === undefined) {
+          continue;
+        }
+        updatePromises.push(client_stats_classPrivateFieldGet(client_kv, this).incr('stats', key, value));
+      }
+      for (const [key, value] of Object.entries(xorChanges)) {
+        if (value === undefined) {
+          continue;
+        }
+        const valueBuffer = new src_client_BufferStorage(value, client_XOR_BUFFER_SIZE);
+        const bufferKey = `@buffer:${key}`;
+        updatePromises.push(client_stats_classPrivateFieldGet(client_kv, this).xor(null, bufferKey, valueBuffer));
+      }
+      await Promise.all(updatePromises);
+    })());
+    await client_stats_classPrivateFieldGet(client_syncPromise, this);
+    client_stats_classPrivateFieldSet(client_syncPromise, this, undefined);
   }
-  async getBlockFromPrevious(block, from) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getBlockFromPrevious(transaction, block, from);
-    return retval;
+}
+function client_assertDurationBreakdowns(durations) {
+  for (const duration of durations) {
+    this.assertDurationBreakdown(duration);
   }
-  async getHeadBlocks(accounts, from) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getHeadBlocks(transaction, accounts, from);
-    return retval;
+}
+function client_getDurationRange(duration) {
+  this.assertDurationBreakdown(duration);
+  const range = client_durationRanges[duration];
+  if (!range) {
+    throw new Error(`Could not get range for invalid duration: ${duration}, got range ${range}`);
   }
-  async getHeadBlock(account, from) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getHeadBlock(transaction, account, from);
-    return retval;
+
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return range;
+}
+/* harmony default export */ const client_stats = (client_Stats);
+;// ./src/lib/ledger/index.ts
+var client_Ledger;
+function client_usingCtx2() { var r = "function" == typeof SuppressedError ? SuppressedError : function (r, e) { var n = Error(); return n.name = "SuppressedError", n.error = r, n.suppressed = e, n; }, e = {}, n = []; function using(r, e) { if (null != e) { if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined."); if (r) var o = e[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")]; if (void 0 === o && (o = e[Symbol.dispose || Symbol.for("Symbol.dispose")], r)) var t = o; if ("function" != typeof o) throw new TypeError("Object is not disposable."); t && (o = function () { try { t.call(e); } catch (r) { return Promise.reject(r); } }), n.push({ v: e, d: o, a: r }); } else r && n.push({ d: e, a: r }); return e; } return { e: e, u: using.bind(null, !1), a: using.bind(null, !0), d: function () { var o, t = this.e, s = 0; function next() { for (; o = n.pop();) try { if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next); if (o.d) { var r = o.d.call(o.v); if (o.a) return s |= 2, Promise.resolve(r).then(next, err); } else s |= 1; } catch (r) { return err(r); } if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve(); if (t !== e) throw t; } function err(n) { return t = t !== e ? new r(n, t) : n, next(); } return next(); } }; }
+function client_lib_ledger_defineProperty(e, r, t) { return (r = client_lib_ledger_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function client_lib_ledger_toPropertyKey(t) { var i = client_lib_ledger_toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function client_lib_ledger_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_ledger_classPrivateMethodInitSpec(e, a) { client_ledger_checkPrivateRedeclaration(e, a), a.add(e); }
+function client_ledger_classPrivateFieldInitSpec(e, t, a) { client_ledger_checkPrivateRedeclaration(e, t), t.set(e, a); }
+function client_ledger_checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function client_ledger_classPrivateFieldGet(s, a) { return s.get(client_ledger_assertClassBrand(s, a)); }
+function client_ledger_classPrivateFieldSet(s, a, r) { return s.set(client_ledger_assertClassBrand(s, a), r), r; }
+function client_ledger_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"); }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Kind of ledger
+ */
+let client_LedgerKind = /*#__PURE__*/function (LedgerKind) {
+  LedgerKind[LedgerKind["REPRESENTATIVE"] = 0] = "REPRESENTATIVE";
+  LedgerKind[LedgerKind["ACCOUNT"] = 1] = "ACCOUNT";
+  return LedgerKind;
+}({});
+
+/**
+ * Ledger configuration
+ */
+
+/**
+ * Which ledger to store this data in
+ */
+
+/**
+ * Which ledger(s) to pull the data from
+ */
+
+/**
+ * A set of votes and a pointer to the next set/page
+ */
+
+/**
+ * Options for "getVotesAfter"
+ */
+
+/**
+ * Each transaction can contain the node object making the request to access things like timing information
+ */
+
+class client_LedgerStorageTransactionBase {
+  constructor(options) {
+    var _options$moment, _options$readOnly;
+    this.node = options.node;
+    this.moment = (_options$moment = options.moment) !== null && _options$moment !== void 0 ? _options$moment : new Date();
+    this.identifier = options.identifier;
+    this.readOnly = (_options$readOnly = options.readOnly) !== null && _options$readOnly !== void 0 ? _options$readOnly : true;
+    this.statsPending = new StatsPending();
   }
-  async getAccountRep(account) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountRep(transaction, account);
-    return retval;
+}
+
+/**
+ * Each Ledger Storage backend must implement this interface
+ */
+var client_network = /*#__PURE__*/new WeakMap();
+var client_subnet = /*#__PURE__*/new WeakMap();
+var client_kind = /*#__PURE__*/new WeakMap();
+var client_ledger_privateKey = /*#__PURE__*/new WeakMap();
+var client_computeFeeFromBlocks = /*#__PURE__*/new WeakMap();
+var client_ledger_storage = /*#__PURE__*/new WeakMap();
+var src_client_ledger = /*#__PURE__*/new WeakMap();
+var src_client_cache = /*#__PURE__*/new WeakMap();
+var client_transaction = /*#__PURE__*/new WeakMap();
+var client_LedgerAtomicInterface_brand = /*#__PURE__*/new WeakSet();
+/**
+ * Atomic transactional interface to a storage backend
+ */
+class client_LedgerAtomicInterface {
+  constructor(_transaction2, storage, config, ledger) {
+    client_ledger_classPrivateMethodInitSpec(this, client_LedgerAtomicInterface_brand);
+    client_ledger_classPrivateFieldInitSpec(this, client_network, void 0);
+    client_ledger_classPrivateFieldInitSpec(this, client_subnet, void 0);
+    client_ledger_classPrivateFieldInitSpec(this, client_kind, void 0);
+    client_ledger_classPrivateFieldInitSpec(this, client_ledger_privateKey, void 0);
+    client_ledger_classPrivateFieldInitSpec(this, client_computeFeeFromBlocks, void 0);
+    client_ledger_classPrivateFieldInitSpec(this, client_ledger_storage, void 0);
+    client_ledger_classPrivateFieldInitSpec(this, src_client_ledger, void 0);
+    client_ledger_classPrivateFieldInitSpec(this, src_client_cache, void 0);
+    client_ledger_classPrivateFieldInitSpec(this, client_transaction, void 0);
+    client_ledger_classPrivateFieldSet(client_network, this, config.network);
+    client_ledger_classPrivateFieldSet(client_subnet, this, config.subnet);
+    client_ledger_classPrivateFieldSet(client_kind, this, config.kind);
+    client_ledger_classPrivateFieldSet(client_ledger_privateKey, this, config.privateKey);
+    client_ledger_classPrivateFieldSet(client_computeFeeFromBlocks, this, config.computeFeeFromBlocks);
+    client_ledger_classPrivateFieldSet(src_client_ledger, this, ledger);
+    client_ledger_classPrivateFieldSet(client_ledger_storage, this, storage);
+    client_ledger_classPrivateFieldSet(client_transaction, this, _transaction2);
+
+    /**
+     * Link the storage driver's cache to the transaction cache
+     */
+    let existingCache;
+    if ('cache' in storage && storage.cache !== undefined) {
+      existingCache = storage.cache(_transaction2);
+    }
+    if (existingCache !== undefined) {
+      client_ledger_classPrivateFieldSet(src_client_cache, this, existingCache);
+    } else {
+      client_ledger_classPrivateFieldSet(src_client_cache, this, new client_cache());
+    }
   }
-  async getAccountInfo(account) {
+  async commit() {
+    var _classPrivateFieldGet2;
     const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountInfo(transaction, account);
-    return retval;
+    client_ledger_classPrivateFieldSet(client_transaction, this, null);
+    await client_ledger_classPrivateFieldGet(client_ledger_storage, this).commitTransaction(transaction);
+    (_classPrivateFieldGet2 = client_ledger_classPrivateFieldGet(src_client_ledger, this).node) === null || _classPrivateFieldGet2 === void 0 || _classPrivateFieldGet2.stats.merge(transaction.statsPending);
   }
-  async getBlock(blockhash) {
-    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
+  async abort() {
     const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getBlock(transaction, blockhash, from);
-    return retval;
+    client_ledger_classPrivateFieldSet(client_transaction, this, null);
+    await client_ledger_classPrivateFieldGet(client_ledger_storage, this).abortTransaction(transaction);
   }
-  async getVoteStaple(stapleBlockHash) {
-    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
-    client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const results = await this.getVoteStaples([stapleBlockHash], from);
-    const retval = results.get(stapleBlockHash);
-    if (retval === undefined) {
-      throw new Error(`internal error: missing vote staple for ${stapleBlockHash}`);
+  async vote(blocks, otherVotes, quote) {
+    if (blocks.length === 0) {
+      throw new client_ledger('LEDGER_MISSING_BLOCKS', 'At least one block is required to issue a vote');
     }
-    return retval;
-  }
-  async getVoteStaples(stapleBlockHashes) {
-    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    if (stapleBlockHashes.length === 0) {
-      return new client_VoteBlockHashMap();
+    if (!client_ledger_classPrivateFieldGet(client_ledger_privateKey, this)) {
+      throw new Error('Cannot vote on block, no private key loaded');
     }
-    if (stapleBlockHashes.length > 10000) {
-      throw new Error('Cannot fetch more than 10,000 vote staples at once');
+    if (client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode !== 'read-write') {
+      throw new Error(`May not issue votes in read-only mode, in ${client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode} mode`);
     }
-    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVoteStaples(transaction, stapleBlockHashes, from);
-    return retval;
-  }
-  async getHistory(account, start) {
-    let limit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 25;
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const voteStapleHashes = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getHistory(transaction, account, start, limit);
-    const voteStaplesMap = await this.getVoteStaples(voteStapleHashes, 'main');
-    const voteStaples = voteStapleHashes.map(function (voteStapleHash) {
-      const voteStaple = voteStaplesMap.get(voteStapleHash);
-      if (voteStaple === undefined || voteStaple === null) {
-        throw new Error(`internal error: missing vote staple for ${voteStapleHash}`);
+    const privateKey = client_ledger_classPrivateFieldGet(client_ledger_privateKey, this);
+    const ledgerPubKey = privateKey.publicKeyString.get();
+    if (quote !== undefined) {
+      if (otherVotes !== undefined) {
+        throw new client_ledger('LEDGER_PERM_VOTE_WITH_QUOTE', 'Quote should not be included when requesting permanent votes');
       }
-      return voteStaple;
-    });
-    return voteStaples;
-  }
-  async getStaplesFromBlockHashes(hashes) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    if (client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVoteStaplesFromBlockHash) {
-      const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVoteStaplesFromBlockHash(transaction, hashes, 'main');
-      return retval;
-    }
-    const staples = [];
-    const seenVoteUIDs = new Set();
-    const seenBlockHashes = new client_block_BlockHash.Set();
-    for (const blockHash of hashes) {
-      if (seenBlockHashes.has(blockHash)) {
-        continue;
+      if (!quote.issuer.comparePublicKey(ledgerPubKey)) {
+        throw new client_ledger('LEDGER_QUOTE_MISMATCH', 'Provided quote does not match issuer public key');
       }
+    }
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
 
-      /**
-       * Get all the votes on the same set of blocks (any
-       * block can be used for this purpose)
-       */
-      const relatedVotes = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVotes(transaction, blockHash, 'main');
-      if (!relatedVotes) {
-        continue;
+    /**
+     * If there are other votes, ensure one of them was issued by
+     * us and the blocks are in the same order as the set of
+     * blocks we are voting on now
+     */
+    if (otherVotes !== undefined) {
+      let foundOurVote = false;
+      const seenVoteUIDs = new Set();
+      const seenVoteIssuers = new client_lib_account.Set();
+      const possibleFeeBlock = blocks.at(-1);
+      let hasFeeBlock = false;
+      let blockCount = blocks.length;
+      if ((possibleFeeBlock === null || possibleFeeBlock === void 0 ? void 0 : possibleFeeBlock.purpose) === client_BlockPurpose.FEE) {
+        hasFeeBlock = true;
+        blockCount--;
       }
-      const relatedBlockHashes = relatedVotes[0].blocks;
+      const requiredFees = new Map();
+      for (const checkVote of otherVotes) {
+        if (checkVote.quote === true) {
+          throw new client_ledger('LEDGER_PERM_VOTE_WITH_QUOTE', 'Cannot request permanent votes with quotes');
+        }
+        if (seenVoteUIDs.has(checkVote.$id)) {
+          throw new client_ledger('LEDGER_DUPLICATE_VOTE_FOUND', 'Duplicate vote UID found');
+        }
+        if (seenVoteIssuers.has(checkVote.issuer)) {
+          throw new client_ledger('LEDGER_DUPLICATE_VOTE_ISSUER_FOUND', 'Multiple votes found from same issuer');
+        }
+        seenVoteIssuers.add(checkVote.issuer);
+        seenVoteUIDs.add(checkVote.$id);
+        if (checkVote.fee !== undefined) {
+          requiredFees.set(checkVote.issuer, checkVote.fee);
+        }
+        if (checkVote.$permanent) {
+          throw new client_ledger('LEDGER_CANNOT_EXCHANGE_PERM_VOTE', 'Asked to exchange a permanent vote for a permanent vote');
+        }
+        let blocksDifferFromVoteBlocks = checkVote.blocks.length !== blockCount;
 
-      /**
-       * We do not need to process any blocks within this vote again
-       * All of them will be the same staple
-       */
-      for (const relatedBlockHash of relatedBlockHashes) {
-        seenBlockHashes.add(relatedBlockHash);
-      }
-      if (seenVoteUIDs.has(relatedVotes[0].$id)) {
-        continue;
+        /* If they do not differ from length alone, compare block hashes */
+        if (!blocksDifferFromVoteBlocks) {
+          for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
+            if (!blocks[blockIndex].hash.compareHexString(checkVote.blocks[blockIndex])) {
+              blocksDifferFromVoteBlocks = true;
+              break;
+            }
+          }
+        }
+        if (blocksDifferFromVoteBlocks) {
+          throw new client_ledger('LEDGER_BLOCKS_DIFFER_FROM_VOTED_ON', 'Asked to exchange different number of blocks for a permanent vote');
+        }
+        if (checkVote.issuer.comparePublicKey(ledgerPubKey)) {
+          foundOurVote = true;
+        }
       }
-
-      /**
-       * Indicate we have now seen all these votes -- even if
-       * we cannot create a VoteStaple from it due to
-       * missing blocks, there's no point in retrying that.
-       */
-      for (const relatedVote of relatedVotes) {
-        seenVoteUIDs.add(relatedVote.$id);
+      if (requiredFees.size > 0) {
+        if (!hasFeeBlock) {
+          throw new client_ledger('LEDGER_MISSING_REQUIRED_FEE_BLOCK', 'Missing fee block but votes require it');
+        }
+        if (requiredFees.size !== (possibleFeeBlock === null || possibleFeeBlock === void 0 ? void 0 : possibleFeeBlock.operations.length)) {
+          throw new client_ledger('LEDGER_REQUIRED_FEE_MISMATCH', 'Fee Block Operations do not match required fees');
+        }
       }
 
-      /**
-       * Fetch all the blocks mentioned in the vote
-       */
-      const resolvedVoteBlocks = [];
-      let foundInvalidBlock = false;
-      const voteBlockPromises = relatedBlockHashes.map(async relatedHash => {
-        try {
-          const block = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getBlock(transaction, relatedHash, 'main');
-
-          // We only care about valid blocks
-          if (src_client_Block.isInstance(block)) {
-            resolvedVoteBlocks.push(block);
-            return;
+      // Verify that all required fees have been included in the fee block
+      for (const [issuer, fee] of requiredFees) {
+        const foundFee = possibleFeeBlock === null || possibleFeeBlock === void 0 ? void 0 : possibleFeeBlock.operations.find(operation => {
+          var _fee$payTo, _fee$token;
+          const expectedPayTo = (_fee$payTo = fee.payTo) !== null && _fee$payTo !== void 0 ? _fee$payTo : issuer;
+          const expectedToken = (_fee$token = fee.token) !== null && _fee$token !== void 0 ? _fee$token : client_ledger_classPrivateFieldGet(src_client_ledger, this).baseToken;
+          if (operation.type === client_OperationType.SEND && operation.to.comparePublicKey(expectedPayTo)) {
+            if (operation.amount !== fee.amount) {
+              throw new client_ledger('LEDGER_FEE_AMOUNT_MISMATCH', `Fee Amount Mismatch, found: ${operation.amount} expected: ${fee.amount}`);
+            }
+            if (!operation.token.comparePublicKey(expectedToken)) {
+              throw new client_ledger('LEDGER_FEE_TOKEN_MISMATCH', `Fee Token Mismatch, found: ${operation.token.publicKeyString.get()} expected: ${expectedToken.publicKeyString.get()}`);
+            }
+            return true;
           }
-        } catch {
-          /* Ignore the error, we will check for undefined blocks later */
+          return false;
+        });
+        if (foundFee === undefined) {
+          var _fee$payTo$publicKeyS, _fee$payTo2;
+          throw new client_ledger('LEDGER_FEE_MISSING', `Missing Required Fee for ${(_fee$payTo$publicKeyS = (_fee$payTo2 = fee.payTo) === null || _fee$payTo2 === void 0 ? void 0 : _fee$payTo2.publicKeyString.get()) !== null && _fee$payTo$publicKeyS !== void 0 ? _fee$payTo$publicKeyS : issuer.publicKeyString.get()}`);
         }
-        foundInvalidBlock = true;
-      });
-      await Promise.all(voteBlockPromises);
-
-      /**
-       * If there were any blocks that we don't currently have, we shouldn't construct a staple
-       */
-      if (foundInvalidBlock) {
-        continue;
       }
-
-      /**
-       * Construct the staple from the information gathered
-       */
-      const staple = src_client_Vote.Staple.fromVotesAndBlocks(relatedVotes, resolvedVoteBlocks);
-      staples.push(staple);
+      if (!foundOurVote) {
+        throw new client_ledger('LEDGER_NO_PERM_WITHOUT_SELF_TEMP', 'Asked to give a permanent vote without a temporary vote from us');
+      }
     }
-    return staples;
-  }
-  async getVoteStaplesAfter(moment) {
-    let limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
-    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const {
-      bloomFilter,
-      timeout
-    } = options;
-    const retval = [];
-    const startTime = Date.now();
-    let startKey;
-    while (retval.length < limit) {
-      /**
-       * If the timeout is reached and we have at least one
-       * result already, return it.
-       */
-      if (retval.length > 0 && timeout !== undefined) {
-        const now = Date.now();
-        if (now - startTime > timeout) {
-          break;
+    const allLedgerHeads = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_validateBlocksForVote).call(this, blocks);
+    const needToGetHeadFor = new client_lib_account.Set(allLedgerHeads.keys());
+    const allHeads = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getHeadBlockHashes(transaction, needToGetHeadFor);
+    for (const [account, expectedBlock] of allLedgerHeads.entries()) {
+      const accountHead = allHeads[account.publicKeyString.get()];
+      if (accountHead === null) {
+        if (!expectedBlock.$opening) {
+          throw new client_ledger('LEDGER_NOT_OPENING', 'Cannot vote on non-opening block for an empty account');
         }
+        continue;
       }
-
-      /**
-       * Compute the maximum number of votes we can fetch from the
-       * storage driver in a single page, we request 32x the
-       * remaining limit, but no more than 200
-       */
-      let maxVotesPerPage = (limit - retval.length) * 32;
-      if (maxVotesPerPage > 200) {
-        maxVotesPerPage = 200;
+      if (expectedBlock.$opening) {
+        throw new client_ledger('LEDGER_NOT_EMPTY', 'Cannot vote on opening block for a non-empty account');
       }
+      if (expectedBlock.previous.toString() !== accountHead.toString()) {
+        throw new client_ledger('LEDGER_NOT_SUCCESSOR', 'The block is not the successor to the account head block');
+      }
+    }
 
-      /**
-       * Get all the votes from the storage driver that occurred on
-       * or after the moment specified.
-       */
-      const page = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVotesAfter(transaction, moment, startKey, {
-        maxVotesPerPage,
-        ...options
-      });
-      startKey = page.nextKey;
-      const pageBlockHashes = page.votes.map(vote => vote.blocks);
-
-      // Convert BlockHash[][] to BlockHash[] and remove duplicates
-      const seenBlockHashes = new client_block_BlockHash.Set();
-      const flattenedHashes = pageBlockHashes.flat().filter(function (hash) {
-        return !seenBlockHashes.has(hash);
-      });
-      const staples = await this.getStaplesFromBlockHashes(flattenedHashes);
-      for (const staple of staples) {
+    /**
+     * Ensure we have no active vote for another conflicting successor of this block's parent (previous),
+     * which could cause a fork
+     */
+    const previousToCheckFor = blocks.map(b => b.previous);
+    const allPrevious = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVotesFromMultiplePrevious(transaction, previousToCheckFor, 'both', client_lib_account.toAccount(ledgerPubKey));
+    for (const block of blocks) {
+      const previousVotes = allPrevious[block.previous.toString()];
+      if (previousVotes !== null && previousVotes.length > 0) {
         /**
-         * Break out of the loop if we have reached capacity
+         * If we do have a previous vote, we can
+         * replace it with a permanent vote if
+         * there is only 1 previous vote, issued by us,
+         * and it's a short vote
          */
-        if (retval.length >= limit) {
-          break;
+
+        let mayReplace = false;
+        if (previousVotes.length === 1 && otherVotes !== undefined && otherVotes.length !== 0) {
+          const ourVote = previousVotes[0];
+          mayReplace = !ourVote.$permanent && ourVote.issuer.comparePublicKey(ledgerPubKey);
+        }
+        if (!mayReplace) {
+          throw new client_ledger('LEDGER_SUCCESSOR_VOTE_EXISTS', `We cannot vote for this block (hash=${block.hash.toString()}), we have an existing vote for a successor (previous votes = ${JSON.stringify(client_toJSONSerializable(previousVotes))})`);
         }
+      }
+    }
+
+    /**
+     * If no other votes have been supplied, validate that the blocks are valid, and issue a short vote
+     */
+    if (otherVotes === undefined) {
+      const vote = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_voteOrQuoteWithFees).call(this, blocks, 'VOTE', quote);
+      const blocksAndVote = src_client_VoteStaple.fromVotesAndBlocks([vote], blocks);
+      await client_ledger_classPrivateFieldGet(client_ledger_storage, this).addPendingVote(transaction, blocksAndVote);
+      return vote;
+    }
+
+    /**
+     * Validate the votes are sufficient weight and grant
+     * our permanent vote
+     */
+    const votesSufficient = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_validateVotingWeight).call(this, otherVotes);
+    if (votesSufficient !== true) {
+      throw new client_ledger('LEDGER_INSUFFICIENT_VOTING_WEIGHT', 'Unable to create a vote from these votes, they do not represent enough voting power');
+    }
+
+    /**
+     * Serial number
+     */
+    const serial = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getNextSerialNumber(client_ledger_classPrivateFieldGet(client_transaction, this));
+    const wipVote = new src_client_VoteBuilder(privateKey);
+    for (const block of blocks) {
+      wipVote.addBlock(block);
+    }
+    const vote = await wipVote.seal(serial, null);
+    const blocksAndVote = src_client_VoteStaple.fromVotesAndBlocks([vote], blocks);
 
-        /**
-         * If a filter has been supplied, check
-         * it to see if the new vote has already
-         * been sent
-         */
-        if (bloomFilter) {
-          if (bloomFilter.has(staple.toBytes())) {
-            continue;
-          }
+    /**
+     * Add this pending vote to our side ledger;
+     * Replacing an existing temporary vote with a permanent one
+     */
+    await client_ledger_classPrivateFieldGet(client_ledger_storage, this).addPendingVote(transaction, blocksAndVote);
+    return vote;
+  }
+  async quote(blocks) {
+    await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_validateBlocksForVote).call(this, blocks);
+    const quote = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_voteOrQuoteWithFees).call(this, blocks, 'QUOTE');
+    return quote;
+  }
+  async add(votesAndBlocks, from) {
+    var _classPrivateFieldGet3, _classPrivateFieldGet4, _classPrivateFieldGet5, _classPrivateFieldGet6;
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    switch (client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode) {
+      case 'read-only':
+        throw new Error('Cannot add blocks to a read-only ledger');
+      case 'bootstrap-only':
+        if (from === 'bootstrap') {
+          break;
         }
-        retval.push(staple);
-      }
-
-      /**
-       * If there is no next key, exit the loop
-       */
-      if (startKey === undefined) {
+        throw new Error('Cannot add blocks to a read-only ledger (except for bootstrapping)');
+      case 'read-write':
+      case 'no-voting':
         break;
+      default:
+        throw new Error(`internal error: invalid ledger write mode: ${client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode}`);
+    }
+    const {
+      votes,
+      blocks
+    } = votesAndBlocks;
+    if (votes.length < 1) {
+      throw new Error('Must have at least 1 vote in the staple');
+    }
+    for (const block of blocks) {
+      if (block.network !== client_ledger_classPrivateFieldGet(client_network, this)) {
+        throw new Error('Cannot process block for a different network');
+      }
+      if (block.subnet !== client_ledger_classPrivateFieldGet(client_subnet, this)) {
+        throw new Error('Cannot process block for a different subnet');
       }
     }
-    return retval;
+    for (const vote of votes) {
+      if (!vote.$permanent) {
+        throw new Error('Can only insert permanent votes');
+      }
+    }
+    const weightTiming = (_classPrivateFieldGet3 = client_ledger_classPrivateFieldGet(src_client_ledger, this).node) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.timing.startTime('db-add/getWeight');
+    const votesSufficient = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_validateVotingWeight).call(this, votesAndBlocks.votes);
+    if (votesSufficient !== true) {
+      throw new client_ledger('LEDGER_INSUFFICIENT_VOTING_WEIGHT', 'Votes attached do not represent enough voting power');
+    }
+    weightTiming === null || weightTiming === void 0 || weightTiming.end();
+    const changesTiming = (_classPrivateFieldGet4 = client_ledger_classPrivateFieldGet(src_client_ledger, this).node) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.timing.startTime('db-add/computeEffectOfBlocks');
+    const changes = client_computeEffectOfBlocks(votesAndBlocks.blocks, client_ledger_classPrivateFieldGet(src_client_ledger, this));
+    changesTiming === null || changesTiming === void 0 || changesTiming.end();
+    const adjustTiming = (_classPrivateFieldGet5 = client_ledger_classPrivateFieldGet(src_client_ledger, this).node) === null || _classPrivateFieldGet5 === void 0 ? void 0 : _classPrivateFieldGet5.timing.startTime('db-add/adjust');
+    const voteStaples = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).adjust(transaction, votesAndBlocks, changes);
+    adjustTiming === null || adjustTiming === void 0 || adjustTiming.end();
+    const postambleTiming = (_classPrivateFieldGet6 = client_ledger_classPrivateFieldGet(src_client_ledger, this).node) === null || _classPrivateFieldGet6 === void 0 ? void 0 : _classPrivateFieldGet6.timing.startTime('db-add/postamble');
+    /**
+     * Add all the block hashes to the node checksum
+     */
+    for (const staple of voteStaples) {
+      for (const block of staple.blocks) {
+        transaction.statsPending.xor('ledgerChecksum', block.hash);
+      }
+    }
+    postambleTiming === null || postambleTiming === void 0 || postambleTiming.end();
+    return voteStaples;
   }
-  async gc(timeLimitMS) {
+  async getBalance(account, token) {
     const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    return await client_ledger_classPrivateFieldGet(client_ledger_storage, this).gc(transaction, timeLimitMS);
+    const balance = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getBalance(transaction, account, token);
+    if (balance < 0n) {
+      throw new Error(`internal error: Account with negative balance: ${account.publicKeyString.get()}/${client_lib_account.toPublicKeyString(token)}: ${balance}`);
+    }
+    return balance;
   }
-  async getFee(blocks, effectsInput) {
-    const effects = effectsInput !== null && effectsInput !== void 0 ? effectsInput : client_computeEffectOfBlocks(blocks, client_ledger_classPrivateFieldGet(src_client_ledger, this));
-    return client_ledger_classPrivateFieldGet(client_computeFeeFromBlocks, this).call(this, client_ledger_classPrivateFieldGet(src_client_ledger, this), blocks, effects);
+  async getAllBalances(account) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const balances = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAllBalances(transaction, account);
+    for (const {
+      token,
+      balance
+    } of balances) {
+      if (balance < 0n) {
+        throw new Error(`internal error: Account with negative balance: ${account.publicKeyString.get()}/${token.publicKeyString.get()}: ${balance}`);
+      }
+    }
+    return balances;
   }
-  async _testingRunStorageFunction(code) {
+  async getAccountCertificates(account) {
+    client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    return await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountCertificates(client_ledger_classPrivateFieldGet(client_transaction, this), account);
+  }
+  async getAccountCertificateByHash(account, hash) {
+    client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    return await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountCertificateByHash(client_ledger_classPrivateFieldGet(client_transaction, this), account, hash);
+  }
+  async listACLsByPrincipal(principal, entityList) {
     const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    const retval = await code(client_ledger_classPrivateFieldGet(client_ledger_storage, this), transaction);
-    return retval;
+    const permissions = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).listACLsByPrincipal(transaction, principal, entityList);
+    return permissions;
   }
-}
-
-/**
- * The core Ledger components
- */
-function client_assertTransaction() {
-  if (client_ledger_classPrivateFieldGet(client_transaction, this) === null) {
-    throw new Error('Attempt to use closed transaction');
+  async listACLsByEntity(entity) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const permissions = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).listACLsByEntity(transaction, entity);
+    return permissions;
   }
-  return client_ledger_classPrivateFieldGet(client_transaction, this);
-}
-async function client_validateVotingWeight(votes) {
-  const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-  const totalVotingPower = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).delegatedWeight(transaction);
+  async votingPower(rep) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const weight = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).delegatedWeight(transaction, rep);
 
-  /**
-   * See if the weight across the network is 0
-   * If so, we want to ensure that it has a vote by the trusted account, and only that account
-   */
-  if (totalVotingPower === 0n) {
-    const foundTrustedVote = votes.find(vote => {
-      return vote.issuer.comparePublicKey(client_ledger_classPrivateFieldGet(src_client_ledger, this).initialTrustedAccount);
-    });
-    return foundTrustedVote !== undefined;
+    /* Voting Power = Weight (for now) */
+    return weight;
   }
-  const twoThirdsOfTotalWeight = totalVotingPower / 3n * 2n;
-  const requiredPower = twoThirdsOfTotalWeight + 1n;
-  const voters = votes.map(function (vote) {
-    return vote.issuer;
-  });
-  const votedPowerSum = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).delegatedWeight(transaction, new client_lib_account.Set(voters));
-  return votedPowerSum >= requiredPower;
-}
-async function client_listAccountInfo(accounts) {
-  const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-  const accountInfo = {};
-  const permissionPromises = Array.from(accounts).map(async account => {
-    if (account.isIdentifier() === false) {
-      return;
-    }
-    accountInfo[account.publicKeyString.get()] = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountInfo(transaction, account);
-  });
-  await Promise.all(permissionPromises);
-  return accountInfo;
-}
-async function client_checkSingleAccountPermissions(account, requirements, accountInfos) {
-  client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-
-  // Remove duplicates in entity
-  const unfilteredEntity = requirements.map(acct => acct.entity);
-  const entityAccounts = new client_lib_account.Set(unfilteredEntity).toArray();
-  const gotPermissions = await this.listACLsByPrincipal(account, entityAccounts);
-  for (const requirement of requirements) {
-    var _accountInfos$reqEnti;
-    const reqEntityKey = requirement.entity.publicKeyString.get();
-    const foundACLRow = client_findPermissionMatch(requirement, gotPermissions);
-    let foundPermission;
-    if (foundACLRow !== null && foundACLRow !== void 0 && foundACLRow.permissions) {
-      foundPermission = foundACLRow === null || foundACLRow === void 0 ? void 0 : foundACLRow.permissions;
-    } else if ((_accountInfos$reqEnti = accountInfos[reqEntityKey]) !== null && _accountInfos$reqEnti !== void 0 && _accountInfos$reqEnti.defaultPermission) {
-      foundPermission = accountInfos[reqEntityKey].defaultPermission;
-    } else {
-      foundPermission = new client_permissions_Permissions();
-    }
-    if (requirement.permissions === null) {
-      continue;
-    }
-    const hasPermissions = foundPermission.has(requirement.permissions);
-    if (!hasPermissions) {
-      var _requirement$target;
-      const accountPubKey = account.publicKeyString.get();
-      const baseFlagsStr = requirement.permissions.base.flags.join(', ');
-      const externalOffsetsStr = requirement.permissions.external.trueOffsets.join(', ');
-      const reqTargetKey = (_requirement$target = requirement.target) === null || _requirement$target === void 0 ? void 0 : _requirement$target.publicKeyString.get();
-      throw new client_ledger('LEDGER_INVALID_PERMISSIONS', `${accountPubKey} does not have required permissions to perform action on ${reqEntityKey}/${reqTargetKey} -- needs [${baseFlagsStr}]/[${externalOffsetsStr}]`);
-    }
+  async getVotes(block) {
+    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVotes(transaction, block, from);
+    return retval;
   }
-}
-async function client_checkPermissionRequirements(effects) {
-  client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-  const newOwners = {};
-  const requirementsByPrincipal = {};
-  const needToGetAccountInfoFor = new client_lib_account.Set();
-  const allAccountsChanges = Object.values(effects);
-  const foundMultisigSignerLengths = [];
-  for (const {
-    account,
-    fields
-  } of allAccountsChanges) {
-    if (account.isMultisig()) {
-      if (fields.minSignerSetLength !== undefined) {
-        needToGetAccountInfoFor.add(account);
-        foundMultisigSignerLengths.push([account, fields.minSignerSetLength]);
-      }
-    }
-    for (const singleRequirement of (_fields$permissionReq = fields.permissionRequirements) !== null && _fields$permissionReq !== void 0 ? _fields$permissionReq : []) {
-      var _fields$permissionReq;
-      const principal = singleRequirement.principal;
-      const principalPubKey = principal.publicKeyString.get();
-      if (!requirementsByPrincipal[principalPubKey]) {
-        requirementsByPrincipal[principalPubKey] = [];
-      }
-      requirementsByPrincipal[principalPubKey].push(singleRequirement);
-      const {
-        entity,
-        permissions
-      } = singleRequirement;
-      const entityKey = entity.publicKeyString.get();
-      if (permissions === null) {
-        continue;
-      }
-      if (permissions.has(['OWNER'])) {
-        if (newOwners[entityKey] === undefined) {
-          newOwners[entityKey] = {
-            entity,
-            owners: []
-          };
-        }
-        newOwners[entityKey].owners.push(principal);
-      }
-      if (permissions.base.isValidForDefault && entity.isIdentifier()) {
-        needToGetAccountInfoFor.add(entity);
-      }
-    }
+  async getVotesFromMultiplePrevious(prevBlocks) {
+    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
+    let issuer = arguments.length > 2 ? arguments[2] : undefined;
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVotesFromMultiplePrevious(transaction, prevBlocks, from, issuer);
+    return retval;
   }
-  const foundAccountInfo = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_listAccountInfo).call(this, needToGetAccountInfoFor);
-  for (const [multisig, foundSingerLength] of foundMultisigSignerLengths) {
-    const multisigPubKey = multisig.publicKeyString.get();
-    const foundInfo = foundAccountInfo[multisigPubKey];
-    if (!(foundInfo !== null && foundInfo !== void 0 && foundInfo.multisigQuorum)) {
-      throw new Error(`Multisig quorum not found for ${multisigPubKey}`);
-    }
-    if (foundInfo.multisigQuorum > foundSingerLength) {
-      throw new client_ledger('LEDGER_INVALID_PERMISSIONS', `Quorum of ${foundInfo.multisigQuorum} not reached for ${multisigPubKey} -- got ${foundSingerLength}`);
-    }
+  async getBlockFromPrevious(block, from) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getBlockFromPrevious(transaction, block, from);
+    return retval;
   }
-  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));
+  async getHeadBlocks(accounts, from) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getHeadBlocks(transaction, accounts, from);
+    return retval;
   }
-  await Promise.all(checkPromises);
-  return {
-    newOwners
-  };
-}
-/**
- * Ensure all parts of a transaction do not have a negative outcome
- * Balance/Supply cannot fall negative at any point in transaction
- * Accounts have required permissions to perform actions
- * After permission owner modifications all accounts must have exactly one owner
- */
-async function client_validateLedgerOutcome(blocks) {
-  const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-  const ownersByIdentifier = {};
-
-  // 'ADD' or 'REMOVE' an owner from ownersByIdentifier
-  const modifyOwners = (method, entity, principal) => {
-    if (entity.isIdentifier() === false || entity.isMultisig()) {
-      return;
-    }
-    const entityPubKey = entity.assertIdentifier().publicKeyString.get();
-    if (ownersByIdentifier[entityPubKey] === undefined) {
-      ownersByIdentifier[entityPubKey] = {
-        added: new client_lib_account.Set(),
-        removed: new client_lib_account.Set()
-      };
+  async getHeadBlock(account, from) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getHeadBlock(transaction, account, from);
+    return retval;
+  }
+  async getAccountRep(account) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountRep(transaction, account);
+    return retval;
+  }
+  async getAccountInfo(account) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountInfo(transaction, account);
+    return retval;
+  }
+  async getBlock(blockhash) {
+    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getBlock(transaction, blockhash, from);
+    return retval;
+  }
+  async getAccountsBlockHeightInfo(toFetch) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountsBlockHeightInfo(transaction, toFetch);
+    return retval;
+  }
+  async getVoteStaple(stapleBlockHash) {
+    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
+    client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const results = await this.getVoteStaples([stapleBlockHash], from);
+    const retval = results.get(stapleBlockHash);
+    if (retval === undefined) {
+      throw new Error(`internal error: missing vote staple for ${stapleBlockHash}`);
     }
-    switch (method) {
-      case 'ADD':
-        // If it is not already included, push added owner
-        ownersByIdentifier[entityPubKey].added.add(principal);
-        ownersByIdentifier[entityPubKey].removed.delete(principal);
-        break;
-      case 'REMOVE':
-        // Remove owner if it is already included
-        ownersByIdentifier[entityPubKey].added.delete(principal);
-        ownersByIdentifier[entityPubKey].removed.add(principal);
-        break;
+    return retval;
+  }
+  async getVoteStaples(stapleBlockHashes) {
+    let from = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    if (stapleBlockHashes.length === 0) {
+      return new client_VoteBlockHashMap();
     }
-  };
-  const effects = client_computeEffectOfBlocks(blocks, client_ledger_classPrivateFieldGet(src_client_ledger, this));
-  const accountEffects = effects.accounts;
-  const allAccountsChanges = Object.values(accountEffects);
-
-  /**
-   * Ensure all required permissions are met
-   * See which accounts are now owners, and add those accounts to the set that we have
-   */
-  const {
-    newOwners
-  } = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_checkPermissionRequirements).call(this, accountEffects);
-  for (const entityPubKey in newOwners) {
-    const {
-      entity,
-      owners
-    } = newOwners[entityPubKey];
-    for (const newOwner of owners) {
-      modifyOwners('ADD', entity, newOwner);
+    if (stapleBlockHashes.length > 10000) {
+      throw new Error('Cannot fetch more than 10,000 vote staples at once');
     }
+    const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVoteStaples(transaction, stapleBlockHashes, from);
+    return retval;
   }
-  for (const accountChanges of allAccountsChanges) {
-    var _fields$createRequest, _fields$permissions;
-    const {
-      account,
-      fields = {}
-    } = accountChanges;
-
-    /**
-     * Newly created identifiers automatically grant the creator ownership.
-     */
-    const createRequests = (_fields$createRequest = fields.createRequests) !== null && _fields$createRequest !== void 0 ? _fields$createRequest : [];
-    for (const createRequest of createRequests) {
-      modifyOwners('ADD', createRequest.createdIdentifier, account);
-    }
-
-    /**
-     * If an account was granted permissions, we should take that into effect
-     */
-    const addedPermissions = (_fields$permissions = fields.permissions) !== null && _fields$permissions !== void 0 ? _fields$permissions : [];
-    for (const newPerm of addedPermissions) {
-      let method = 'ADD';
-      if (newPerm.permissions === null || !newPerm.permissions.has(['OWNER'])) {
-        method = 'REMOVE';
+  async getHistory(account, start) {
+    let limit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 25;
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const voteStapleHashes = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getHistory(transaction, account, start, limit);
+    const voteStaplesMap = await this.getVoteStaples(voteStapleHashes, 'main');
+    const voteStaples = voteStapleHashes.map(function (voteStapleHash) {
+      const voteStaple = voteStaplesMap.get(voteStapleHash);
+      if (voteStaple === undefined || voteStaple === null) {
+        throw new Error(`internal error: missing vote staple for ${voteStapleHash}`);
       }
-      modifyOwners(method, newPerm.entity, newPerm.principal);
-    }
+      return voteStaple;
+    });
+    return voteStaples;
   }
+  async getStaplesFromBlockHashes(hashes) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    if (client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVoteStaplesFromBlockHash) {
+      const retval = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVoteStaplesFromBlockHash(transaction, hashes, 'main');
+      return retval;
+    }
+    const staples = [];
+    const seenVoteUIDs = new Set();
+    const seenBlockHashes = new client_block_BlockHash.Set();
+    for (const blockHash of hashes) {
+      if (seenBlockHashes.has(blockHash)) {
+        continue;
+      }
 
-  /**
-   * Ensure there is exactly one owner when permissions were changed
-   */
-  for (const [identifierPubKey, {
-    added,
-    removed
-  }] of Object.entries(ownersByIdentifier)) {
-    let ownerLength = added.size;
+      /**
+       * Get all the votes on the same set of blocks (any
+       * block can be used for this purpose)
+       */
+      const relatedVotes = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVotes(transaction, blockHash, 'main');
+      if (!relatedVotes) {
+        continue;
+      }
+      const relatedBlockHashes = relatedVotes[0].blocks;
 
-    // If more than one owner was granted and not removed, we know it is invalid without checking
-    if (ownerLength <= 1) {
-      const identifierAccount = client_lib_account.fromPublicKeyString(identifierPubKey).assertIdentifier();
-      const receivedOwners = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).listOwners(transaction, identifierAccount);
-      for (const receivedOwner of receivedOwners) {
-        // We already know about these owners, we do not care about adding/removing them again
-        if (added.has(receivedOwner) || removed.has(receivedOwner)) {
-          continue;
-        }
-        ownerLength++;
+      /**
+       * We do not need to process any blocks within this vote again
+       * All of them will be the same staple
+       */
+      for (const relatedBlockHash of relatedBlockHashes) {
+        seenBlockHashes.add(relatedBlockHash);
       }
-    }
-    if (ownerLength === 1) {
-      continue;
-    }
-    throw new client_ledger('LEDGER_INVALID_OWNER_COUNT', `Invalid number of owners for ${identifierPubKey} - Got ${ownerLength}/1`);
-  }
-  const {
-    balances
-  } = await client_computeLedgerEffect({
-    checkRangeConstraints: true,
-    baseToken: client_ledger_classPrivateFieldGet(src_client_ledger, this).baseToken
-  }, accountEffects, client_ledger_classPrivateFieldGet(client_ledger_storage, this), client_ledger_classPrivateFieldGet(client_network, this), client_ledger_classPrivateFieldGet(client_transaction, this));
-  for (const accountPubKey in balances) {
-    const acctBalanceChanges = balances[accountPubKey];
-    for (const tokenPubKey in acctBalanceChanges) {
-      const {
-        change,
-        fellNegative,
-        receiveValidated
-      } = acctBalanceChanges[tokenPubKey];
-      if (fellNegative) {
-        throw new client_ledger('LEDGER_INVALID_BALANCE', `Resulting balance becomes negative at one+ point(s) during this transaction for account/token ${accountPubKey}/${tokenPubKey}: change ${change}`);
+      if (seenVoteUIDs.has(relatedVotes[0].$id)) {
+        continue;
       }
-      if (receiveValidated === false) {
-        throw new client_ledger('LEDGER_RECEIVE_NOT_MET', `${accountPubKey}/${tokenPubKey} did not receive enough of requested token. change: ${change}`);
+
+      /**
+       * Indicate we have now seen all these votes -- even if
+       * we cannot create a VoteStaple from it due to
+       * missing blocks, there's no point in retrying that.
+       */
+      for (const relatedVote of relatedVotes) {
+        seenVoteUIDs.add(relatedVote.$id);
+      }
+
+      /**
+       * Fetch all the blocks mentioned in the vote
+       */
+      const resolvedVoteBlocks = [];
+      let foundInvalidBlock = false;
+      const voteBlockPromises = relatedBlockHashes.map(async relatedHash => {
+        try {
+          const block = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getBlock(transaction, relatedHash, 'main');
+
+          // We only care about valid blocks
+          if (src_client_Block.isInstance(block)) {
+            resolvedVoteBlocks.push(block);
+            return;
+          }
+        } catch {
+          /* Ignore the error, we will check for undefined blocks later */
+        }
+        foundInvalidBlock = true;
+      });
+      await Promise.all(voteBlockPromises);
+
+      /**
+       * If there were any blocks that we don't currently have, we shouldn't construct a staple
+       */
+      if (foundInvalidBlock) {
+        continue;
       }
+
+      /**
+       * Construct the staple from the information gathered
+       */
+      const staple = src_client_Vote.Staple.fromVotesAndBlocks(relatedVotes, resolvedVoteBlocks);
+      staples.push(staple);
     }
+    return staples;
   }
-  return effects;
-}
-async function client_validateBlocksForVote(blocks) {
-  /**
-   * Create a map of all blocks by their hash
-   */
-  const blockHashMap = {};
-  for (const block of blocks) {
-    blockHashMap[block.hash.toString()] = block;
-  }
-  const seenBlockHashes = new client_block_BlockHash.Set();
-  const usedPreviousBlockHashes = new client_block_BlockHash.Set();
-  const allLedgerHeads = new Map();
-  for (const block of blocks) {
-    const prevBlockHash = block.previous;
-    seenBlockHashes.add(block.hash);
-    if (block.network !== client_ledger_classPrivateFieldGet(client_network, this)) {
-      throw new client_ledger('LEDGER_INVALID_NETWORK', 'Cannot vote on block for a different network');
-    }
-    if (block.subnet !== client_ledger_classPrivateFieldGet(client_subnet, this)) {
-      throw new client_ledger('LEDGER_INVALID_SUBNET', 'Cannot vote on block for a different subnet');
-    }
-    if (usedPreviousBlockHashes.has(prevBlockHash)) {
-      throw new client_ledger('LEDGER_PREVIOUS_ALREADY_USED', `Invalid reference to block, previous: ${prevBlockHash} has already been used`);
-    }
-    usedPreviousBlockHashes.add(prevBlockHash);
+  async getVoteStaplesAfter(moment) {
+    let limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+    let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const {
+      bloomFilter,
+      timeout
+    } = options;
+    const retval = [];
+    const startTime = Date.now();
+    let startKey;
+    while (retval.length < limit) {
+      /**
+       * If the timeout is reached and we have at least one
+       * result already, return it.
+       */
+      if (retval.length > 0 && timeout !== undefined) {
+        const now = Date.now();
+        if (now - startTime > timeout) {
+          break;
+        }
+      }
 
-    /**
-     * Only allow this vote if it is the successor the current
-     * HEAD block for the account, or if no blocks exist on the
-     * account and its an opening block, or if the predecessor
-     * block is also being voted on
-     */
-    let predecessorBeingVotedOn = false;
-    if (!block.$opening) {
-      const prevBlock = blockHashMap[prevBlockHash.toString()];
-      if (prevBlock !== undefined) {
-        predecessorBeingVotedOn = true;
-        if (!prevBlock.account.comparePublicKey(block.account)) {
-          throw new client_ledger('LEDGER_INVALID_CHAIN', 'Invalid chain, changes accounts');
+      /**
+       * Compute the maximum number of votes we can fetch from the
+       * storage driver in a single page, we request 32x the
+       * remaining limit, but no more than 200
+       */
+      let maxVotesPerPage = (limit - retval.length) * 32;
+      if (maxVotesPerPage > 200) {
+        maxVotesPerPage = 200;
+      }
+
+      /**
+       * Get all the votes from the storage driver that occurred on
+       * or after the moment specified.
+       */
+      const page = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getVotesAfter(transaction, moment, startKey, {
+        maxVotesPerPage,
+        ...options
+      });
+      startKey = page.nextKey;
+      const pageBlockHashes = page.votes.map(vote => vote.blocks);
+
+      // Convert BlockHash[][] to BlockHash[] and remove duplicates
+      const seenBlockHashes = new client_block_BlockHash.Set();
+      const flattenedHashes = pageBlockHashes.flat().filter(function (hash) {
+        return !seenBlockHashes.has(hash);
+      });
+      const staples = await this.getStaplesFromBlockHashes(flattenedHashes);
+      for (const staple of staples) {
+        /**
+         * Break out of the loop if we have reached capacity
+         */
+        if (retval.length >= limit) {
+          break;
         }
-        if (!seenBlockHashes.has(prevBlockHash)) {
-          throw new client_ledger('LEDGER_PREVIOUS_NOT_SEEN', `Invalid reference to block, out-of-order: ${prevBlockHash} has not already been seen`);
+
+        /**
+         * If a filter has been supplied, check
+         * it to see if the new vote has already
+         * been sent
+         */
+        if (bloomFilter) {
+          if (bloomFilter.has(staple.toBytes())) {
+            continue;
+          }
         }
+        retval.push(staple);
+      }
+
+      /**
+       * If there is no next key, exit the loop
+       */
+      if (startKey === undefined) {
+        break;
       }
     }
-    if (!predecessorBeingVotedOn) {
-      allLedgerHeads.set(block.account, block);
-    }
+    return retval;
   }
-  return allLedgerHeads;
-}
-async function client_voteOrQuoteWithFees(blocks, type, quote) {
-  var _quote$fee;
-  if (client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode !== 'read-write') {
-    throw new Error(`May not issue votes in read-only mode, in ${client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode} mode`);
+  async gc(timeLimitMS) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    return await client_ledger_classPrivateFieldGet(client_ledger_storage, this).gc(transaction, timeLimitMS);
   }
-  if (!client_ledger_classPrivateFieldGet(client_ledger_privateKey, this)) {
-    throw new Error('Cannot vote on block, no private key loaded');
+  async getFee(blocks, effectsInput) {
+    const effects = effectsInput !== null && effectsInput !== void 0 ? effectsInput : client_computeEffectOfBlocks(blocks, client_ledger_classPrivateFieldGet(src_client_ledger, this));
+    return client_ledger_classPrivateFieldGet(client_computeFeeFromBlocks, this).call(this, client_ledger_classPrivateFieldGet(src_client_ledger, this), blocks, effects);
   }
-  client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-  const effects = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_validateLedgerOutcome).call(this, blocks);
-  const now = Date.now();
-  for (const block of blocks) {
-    const blockDate = block.date.valueOf();
-    const timeOffset = 5 /* m */ * 60 /* s */ * 1000 /* ms */;
-
-    /**
-     * Do not allow short votes on blocks from the distant past
-     */
-    if (blockDate < now - timeOffset || blockDate > now + timeOffset) {
-      throw new Error(`Refusing to issue vote for block dated ${block.date.toISOString()}`);
-    }
+  async _testingRunStorageFunction(code) {
+    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+    const retval = await code(client_ledger_classPrivateFieldGet(client_ledger_storage, this), transaction);
+    return retval;
   }
+}
 
-  /**
-   * Serial number
-   */
-  const serial = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getNextSerialNumber(client_ledger_classPrivateFieldGet(client_transaction, this));
-
-  /**
-   * Short expiry (5 minutes)
-   */
-  const pendingVoteExpiry = new Date();
-  pendingVoteExpiry.setUTCMinutes(pendingVoteExpiry.getUTCMinutes() + 5);
-  const builderType = type === 'QUOTE' ? src_client_VoteQuoteBuilder : src_client_VoteBuilder;
-  const builder = new builderType(client_ledger_classPrivateFieldGet(client_ledger_privateKey, this));
-  for (const block of blocks) {
-    builder.addBlock(block);
+/**
+ * The core Ledger components
+ */
+function client_assertTransaction() {
+  if (client_ledger_classPrivateFieldGet(client_transaction, this) === null) {
+    throw new Error('Attempt to use closed transaction');
   }
+  return client_ledger_classPrivateFieldGet(client_transaction, this);
+}
+async function client_validateVotingWeight(votes) {
+  const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+  const totalVotingPower = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).delegatedWeight(transaction);
 
   /**
-   * If a quote was provided use it as the fee, otherwise generate new fee
+   * See if the weight across the network is 0
+   * If so, we want to ensure that it has a vote by the trusted account, and only that account
    */
-  const fee = (_quote$fee = quote === null || quote === void 0 ? void 0 : quote.fee) !== null && _quote$fee !== void 0 ? _quote$fee : await this.getFee(blocks, effects);
-  if (fee !== null) {
-    builder.addFee(fee);
+  if (totalVotingPower === 0n) {
+    const foundTrustedVote = votes.find(vote => {
+      return vote.issuer.comparePublicKey(client_ledger_classPrivateFieldGet(src_client_ledger, this).initialTrustedAccount);
+    });
+    return foundTrustedVote !== undefined;
   }
-  const voteOrQuote = await builder.seal(serial, pendingVoteExpiry);
-  return voteOrQuote;
+  const twoThirdsOfTotalWeight = totalVotingPower / 3n * 2n;
+  const requiredPower = twoThirdsOfTotalWeight + 1n;
+  const voters = votes.map(function (vote) {
+    return vote.issuer;
+  });
+  const votedPowerSum = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).delegatedWeight(transaction, new client_lib_account.Set(voters));
+  return votedPowerSum >= requiredPower;
 }
-var client_storage2 = /*#__PURE__*/new WeakMap();
-var src_client_config = /*#__PURE__*/new WeakMap();
-class src_client_Ledger {
-  constructor(config, node, existingStorage) {
-    client_ledger_classPrivateFieldInitSpec(this, client_storage2, void 0);
-    client_ledger_classPrivateFieldInitSpec(this, src_client_config, void 0);
-    client_ledger_classPrivateFieldSet(src_client_config, this, {
-      ...config
-    });
-    const {
-      baseToken,
-      networkAddress
-    } = client_lib_account.generateBaseAddresses(config.network);
-    this.networkAddress = networkAddress;
-    this.baseToken = baseToken;
-    this.initialTrustedAccount = config.initialTrustedAccount;
-    this.node = node;
-    if (config.kind === client_LedgerKind.REPRESENTATIVE) {
-      if (config.privateKey === undefined) {
-        throw new Error('A private key must be provided if this is a Ledger for a representative');
-      }
+async function client_listAccountInfo(accounts) {
+  const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+  const accountInfo = {};
+  const permissionPromises = Array.from(accounts).map(async account => {
+    if (account.isIdentifier() === false) {
+      return;
+    }
+    accountInfo[account.publicKeyString.get()] = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getAccountInfo(transaction, account);
+  });
+  await Promise.all(permissionPromises);
+  return accountInfo;
+}
+async function client_checkSingleAccountPermissions(account, requirements, accountInfos) {
+  client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+
+  // Remove duplicates in entity
+  const unfilteredEntity = requirements.map(acct => acct.entity);
+  const entityAccounts = new client_lib_account.Set(unfilteredEntity).toArray();
+  const gotPermissions = await this.listACLsByPrincipal(account, entityAccounts);
+  for (const requirement of requirements) {
+    var _accountInfos$reqEnti;
+    const reqEntityKey = requirement.entity.publicKeyString.get();
+    const foundACLRow = client_findPermissionMatch(requirement, gotPermissions);
+    let foundPermission;
+    if (foundACLRow !== null && foundACLRow !== void 0 && foundACLRow.permissions) {
+      foundPermission = foundACLRow === null || foundACLRow === void 0 ? void 0 : foundACLRow.permissions;
+    } else if ((_accountInfos$reqEnti = accountInfos[reqEntityKey]) !== null && _accountInfos$reqEnti !== void 0 && _accountInfos$reqEnti.defaultPermission) {
+      foundPermission = accountInfos[reqEntityKey].defaultPermission;
+    } else {
+      foundPermission = new client_permissions_Permissions();
     }
-    if (existingStorage !== undefined) {
-      client_ledger_classPrivateFieldSet(client_storage2, this, existingStorage);
-      return;
+    if (requirement.permissions === null) {
+      continue;
     }
-    client_ledger_classPrivateFieldSet(client_storage2, this, config.storageDriver);
-    client_ledger_classPrivateFieldGet(client_storage2, this).init(client_ledger_classPrivateFieldGet(src_client_config, this), this);
-  }
-  get ledgerWriteMode() {
-    const retval = client_ledger_classPrivateFieldGet(src_client_config, this).ledgerWriteMode;
-    if (retval === undefined) {
-      return 'read-write';
+    const hasPermissions = foundPermission.has(requirement.permissions);
+    if (!hasPermissions) {
+      var _requirement$target;
+      const accountPubKey = account.publicKeyString.get();
+      const baseFlagsStr = requirement.permissions.base.flags.join(', ');
+      const externalOffsetsStr = requirement.permissions.external.trueOffsets.join(', ');
+      const reqTargetKey = (_requirement$target = requirement.target) === null || _requirement$target === void 0 ? void 0 : _requirement$target.publicKeyString.get();
+      throw new client_ledger('LEDGER_INVALID_PERMISSIONS', `${accountPubKey} does not have required permissions to perform action on ${reqEntityKey}/${reqTargetKey} -- needs [${baseFlagsStr}]/[${externalOffsetsStr}]`);
     }
-    return retval;
-  }
-  copy(newNode) {
-    return new src_client_Ledger(client_ledger_classPrivateFieldGet(src_client_config, this), newNode, client_ledger_classPrivateFieldGet(client_storage2, this));
   }
-  getFeePayToAndToken(accounts, token) {
-    const retval = {};
-    if (accounts !== undefined && accounts.length > 0) {
-      var _classPrivateFieldGet6;
-      // Get a random fee account from the set of possible accounts
-      const feeAccount = accounts[Math.floor(Math.random() * accounts.length)];
-
-      // If the fee account matches the ledger private key then we can omit the account
-      // Fee is then paid to the vote issuer
-      if (!feeAccount.comparePublicKey((_classPrivateFieldGet6 = client_ledger_classPrivateFieldGet(src_client_config, this).privateKey) === null || _classPrivateFieldGet6 === void 0 ? void 0 : _classPrivateFieldGet6.publicKeyString.get())) {
-        retval.payTo = feeAccount;
+}
+async function client_checkPermissionRequirements(effects) {
+  client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+  const newOwners = {};
+  const requirementsByPrincipal = {};
+  const needToGetAccountInfoFor = new client_lib_account.Set();
+  const allAccountsChanges = Object.values(effects);
+  const foundMultisigSignerLengths = [];
+  for (const {
+    account,
+    fields
+  } of allAccountsChanges) {
+    if (account.isMultisig()) {
+      if (fields.minSignerSetLength !== undefined) {
+        needToGetAccountInfoFor.add(account);
+        foundMultisigSignerLengths.push([account, fields.minSignerSetLength]);
       }
     }
-    if (token !== undefined) {
-      // If base token matches ledger fee token then we can omit the token
-      // Fee is then paid using the base token
-      if (!this.baseToken.comparePublicKey(token)) {
-        retval.token = token;
+    for (const singleRequirement of (_fields$permissionReq = fields.permissionRequirements) !== null && _fields$permissionReq !== void 0 ? _fields$permissionReq : []) {
+      var _fields$permissionReq;
+      const principal = singleRequirement.principal;
+      const principalPubKey = principal.publicKeyString.get();
+      if (!requirementsByPrincipal[principalPubKey]) {
+        requirementsByPrincipal[principalPubKey] = [];
       }
-    }
-    return retval;
-  }
-
-  /**
-   * Execute some code with a transaction held, if the code fails the
-   * transaction is aborted, otherwise it is committed
-   *
-   * @param code - Code to run
-   * @returns The return value from "code"
-   */
-  async run(identifier, code, readOnly) {
-    try {
-      var _this$node, _classPrivateFieldGet7, _classPrivateFieldGet8, _this$node4;
-      var _usingCtx = client_usingCtx2();
-      const _timing = _usingCtx.u((_this$node = this.node) === null || _this$node === void 0 ? void 0 : _this$node.timing.startTime(`run-${identifier}`));
-      let retryConfig;
-      if (((_classPrivateFieldGet7 = client_ledger_classPrivateFieldGet(src_client_config, this).transactionRetries) === null || _classPrivateFieldGet7 === void 0 ? void 0 : _classPrivateFieldGet7.maxRetries) !== undefined) {
-        retryConfig = {
-          mode: 'count',
-          maxRetries: client_ledger_classPrivateFieldGet(src_client_config, this).transactionRetries.maxRetries
-        };
-      } else if (((_classPrivateFieldGet8 = client_ledger_classPrivateFieldGet(src_client_config, this).transactionRetries) === null || _classPrivateFieldGet8 === void 0 ? void 0 : _classPrivateFieldGet8.timeout) !== undefined) {
-        retryConfig = {
-          mode: 'time',
-          timeout: client_ledger_classPrivateFieldGet(src_client_config, this).transactionRetries.timeout
-        };
-      } else {
-        /* Legacy default */
-        // retryConfig = {
-        // 	mode: 'count',
-        // 	maxCount: 128
-        // };
-        retryConfig = {
-          mode: 'time',
-          timeout: 5000
-        };
+      requirementsByPrincipal[principalPubKey].push(singleRequirement);
+      const {
+        entity,
+        permissions
+      } = singleRequirement;
+      const entityKey = entity.publicKeyString.get();
+      if (permissions === null) {
+        continue;
       }
-      let retval;
-      let retryCount = 0;
-      const startTime = Date.now();
-      for (;; retryCount++) {
-        try {
-          let runError;
-          let threw = false;
-          const transaction = await this.beginTransaction(identifier, readOnly);
-          try {
-            retval = await code(transaction);
-          } catch (e) {
-            threw = true;
-            runError = e;
-          }
-
-          // If running code was successful, commit, otherwise abort and throw error
-          if (threw === false) {
-            var _this$node2;
-            await client_RequestTiming.runTimer(`${identifier}/commit`, (_this$node2 = this.node) === null || _this$node2 === void 0 ? void 0 : _this$node2.timing, async () => {
-              await transaction.commit();
-            });
-          } else {
-            var _this$node3;
-            await client_RequestTiming.runTimer(`${identifier}/abort`, (_this$node3 = this.node) === null || _this$node3 === void 0 ? void 0 : _this$node3.timing, async () => {
-              await transaction.abort();
-            });
-            throw runError;
-          }
-        } catch (runError) {
-          const txnError = await client_ledger_classPrivateFieldGet(client_storage2, this).evaluateError(runError);
-          let shouldTryToRetry = false;
-          if (retryConfig.mode === 'count') {
-            shouldTryToRetry = retryCount < retryConfig.maxRetries;
-          } else if (retryConfig.mode === 'time') {
-            const now = Date.now();
-            shouldTryToRetry = now - startTime < retryConfig.timeout;
-          }
-          if (shouldTryToRetry) {
-            if (client_ledger.isInstance(txnError)) {
-              if (txnError.shouldRetry) {
-                let retryDelay = 20;
-                if (txnError.retryDelay) {
-                  retryDelay = txnError.retryDelay;
-                }
-                await client_asleep(retryDelay);
-                continue;
-              }
-            }
-          }
-          throw txnError;
+      if (permissions.has(['OWNER'])) {
+        if (newOwners[entityKey] === undefined) {
+          newOwners[entityKey] = {
+            entity,
+            owners: []
+          };
         }
-        break;
+        newOwners[entityKey].owners.push(principal);
       }
-      if (retval === undefined) {
-        throw new Error('Return value for run() is undefined');
+      if (permissions.base.isValidForDefault && entity.isIdentifier()) {
+        needToGetAccountInfoFor.add(entity);
       }
-      (_this$node4 = this.node) === null || _this$node4 === void 0 || _this$node4.stats.incr('ledger', 'dbRetries', retryCount);
-      return retval;
-    } catch (_) {
-      _usingCtx.e = _;
-    } finally {
-      _usingCtx.d();
     }
   }
-  async runReadOnly(identifier, code) {
-    return await this.run(identifier, code, true);
-  }
-  async beginTransaction(identifier) {
-    let readOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    const transactionBase = {
-      node: this.node,
-      moment: new Date(),
-      identifier,
-      readOnly
-    };
-    const transaction = await client_ledger_classPrivateFieldGet(client_storage2, this).beginTransaction(transactionBase);
-    return new client_LedgerAtomicInterface(transaction, client_ledger_classPrivateFieldGet(client_storage2, this), client_ledger_classPrivateFieldGet(src_client_config, this), this);
-  }
-  async vote() {
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
+  const foundAccountInfo = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_listAccountInfo).call(this, needToGetAccountInfoFor);
+  for (const [multisig, foundSingerLength] of foundMultisigSignerLengths) {
+    const multisigPubKey = multisig.publicKeyString.get();
+    const foundInfo = foundAccountInfo[multisigPubKey];
+    if (!(foundInfo !== null && foundInfo !== void 0 && foundInfo.multisigQuorum)) {
+      throw new Error(`Multisig quorum not found for ${multisigPubKey}`);
     }
-    return await this.run('db-vote', async function (transaction) {
-      return await transaction.vote(...args);
-    });
-  }
-  async quote() {
-    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
+    if (foundInfo.multisigQuorum > foundSingerLength) {
+      throw new client_ledger('LEDGER_INVALID_PERMISSIONS', `Quorum of ${foundInfo.multisigQuorum} not reached for ${multisigPubKey} -- got ${foundSingerLength}`);
     }
-    return await this.run('db-quote', async function (transaction) {
-      return await transaction.quote(...args);
-    });
   }
-  async add() {
-    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-      args[_key3] = arguments[_key3];
-    }
-    return await this.run('db-add', async function (transaction) {
-      return await transaction.add(...args);
-    });
+  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));
   }
-  async listACLsByPrincipal() {
-    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-      args[_key4] = arguments[_key4];
+  await Promise.all(checkPromises);
+  return {
+    newOwners
+  };
+}
+/**
+ * Ensure all parts of a transaction do not have a negative outcome
+ * Balance/Supply cannot fall negative at any point in transaction
+ * Accounts have required permissions to perform actions
+ * After permission owner modifications all accounts must have exactly one owner
+ */
+async function client_validateLedgerOutcome(blocks) {
+  const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+  const ownersByIdentifier = {};
+
+  // 'ADD' or 'REMOVE' an owner from ownersByIdentifier
+  const modifyOwners = (method, entity, principal) => {
+    if (entity.isIdentifier() === false || entity.isMultisig()) {
+      return;
     }
-    return await this.runReadOnly('db-listACLs', async function (transaction) {
-      return await transaction.listACLsByPrincipal(...args);
-    });
-  }
-  async listACLsByEntity() {
-    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
-      args[_key5] = arguments[_key5];
+    const entityPubKey = entity.assertIdentifier().publicKeyString.get();
+    if (ownersByIdentifier[entityPubKey] === undefined) {
+      ownersByIdentifier[entityPubKey] = {
+        added: new client_lib_account.Set(),
+        removed: new client_lib_account.Set()
+      };
     }
-    return await this.runReadOnly('db-listACLs', async function (transaction) {
-      return await transaction.listACLsByEntity(...args);
-    });
-  }
-  async getBalance() {
-    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
-      args[_key6] = arguments[_key6];
+    switch (method) {
+      case 'ADD':
+        // If it is not already included, push added owner
+        ownersByIdentifier[entityPubKey].added.add(principal);
+        ownersByIdentifier[entityPubKey].removed.delete(principal);
+        break;
+      case 'REMOVE':
+        // Remove owner if it is already included
+        ownersByIdentifier[entityPubKey].added.delete(principal);
+        ownersByIdentifier[entityPubKey].removed.add(principal);
+        break;
     }
-    return await this.runReadOnly('db-getBalance', async function (transaction) {
-      return await transaction.getBalance(...args);
-    });
-  }
-  async getAllBalances() {
-    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
-      args[_key7] = arguments[_key7];
+  };
+  const effects = client_computeEffectOfBlocks(blocks, client_ledger_classPrivateFieldGet(src_client_ledger, this));
+  const accountEffects = effects.accounts;
+  const allAccountsChanges = Object.values(accountEffects);
+
+  /**
+   * Ensure all required permissions are met
+   * See which accounts are now owners, and add those accounts to the set that we have
+   */
+  const {
+    newOwners
+  } = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_checkPermissionRequirements).call(this, accountEffects);
+  for (const entityPubKey in newOwners) {
+    const {
+      entity,
+      owners
+    } = newOwners[entityPubKey];
+    for (const newOwner of owners) {
+      modifyOwners('ADD', entity, newOwner);
     }
-    return await this.runReadOnly('db-getAllBalances', async function (transaction) {
-      return await transaction.getAllBalances(...args);
-    });
   }
-  async getAccountCertificates() {
-    for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
-      args[_key8] = arguments[_key8];
+  for (const accountChanges of allAccountsChanges) {
+    var _fields$createRequest, _fields$permissions;
+    const {
+      account,
+      fields = {}
+    } = accountChanges;
+
+    /**
+     * Newly created identifiers automatically grant the creator ownership.
+     */
+    const createRequests = (_fields$createRequest = fields.createRequests) !== null && _fields$createRequest !== void 0 ? _fields$createRequest : [];
+    for (const createRequest of createRequests) {
+      modifyOwners('ADD', createRequest.createdIdentifier, account);
     }
-    return await this.runReadOnly('db-getAccountCertificates', async function (transaction) {
-      return await transaction.getAccountCertificates(...args);
-    });
-  }
-  async getAccountCertificateByHash() {
-    for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
-      args[_key9] = arguments[_key9];
+
+    /**
+     * If an account was granted permissions, we should take that into effect
+     */
+    const addedPermissions = (_fields$permissions = fields.permissions) !== null && _fields$permissions !== void 0 ? _fields$permissions : [];
+    for (const newPerm of addedPermissions) {
+      let method = 'ADD';
+      if (newPerm.permissions === null || !newPerm.permissions.has(['OWNER'])) {
+        method = 'REMOVE';
+      }
+      modifyOwners(method, newPerm.entity, newPerm.principal);
     }
-    return await this.runReadOnly('db-getAccountCertificateByHash', async function (transaction) {
-      return await transaction.getAccountCertificateByHash(...args);
-    });
   }
-  async votingPower() {
-    for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
-      args[_key10] = arguments[_key10];
+
+  /**
+   * Ensure there is exactly one owner when permissions were changed
+   */
+  for (const [identifierPubKey, {
+    added,
+    removed
+  }] of Object.entries(ownersByIdentifier)) {
+    let ownerLength = added.size;
+
+    // If more than one owner was granted and not removed, we know it is invalid without checking
+    if (ownerLength <= 1) {
+      const identifierAccount = client_lib_account.fromPublicKeyString(identifierPubKey).assertIdentifier();
+      const receivedOwners = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).listOwners(transaction, identifierAccount);
+      for (const receivedOwner of receivedOwners) {
+        // We already know about these owners, we do not care about adding/removing them again
+        if (added.has(receivedOwner) || removed.has(receivedOwner)) {
+          continue;
+        }
+        ownerLength++;
+      }
     }
-    return await this.runReadOnly('db-votingPower', async function (transaction) {
-      return await transaction.votingPower(...args);
-    });
-  }
-  async getVotes() {
-    for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
-      args[_key11] = arguments[_key11];
+    if (ownerLength === 1) {
+      continue;
     }
-    return await this.runReadOnly('db-getVotes', async function (transaction) {
-      return await transaction.getVotes(...args);
-    });
+    throw new client_ledger('LEDGER_INVALID_OWNER_COUNT', `Invalid number of owners for ${identifierPubKey} - Got ${ownerLength}/1`);
   }
-  async getVotesFromMultiplePrevious() {
-    for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
-      args[_key12] = arguments[_key12];
+  const {
+    balances
+  } = await client_computeLedgerEffect({
+    checkRangeConstraints: true,
+    baseToken: client_ledger_classPrivateFieldGet(src_client_ledger, this).baseToken
+  }, accountEffects, client_ledger_classPrivateFieldGet(client_ledger_storage, this), client_ledger_classPrivateFieldGet(client_network, this), client_ledger_classPrivateFieldGet(client_transaction, this));
+  for (const accountPubKey in balances) {
+    const acctBalanceChanges = balances[accountPubKey];
+    for (const tokenPubKey in acctBalanceChanges) {
+      const {
+        change,
+        fellNegative,
+        receiveValidated
+      } = acctBalanceChanges[tokenPubKey];
+      if (fellNegative) {
+        throw new client_ledger('LEDGER_INVALID_BALANCE', `Resulting balance becomes negative at one+ point(s) during this transaction for account/token ${accountPubKey}/${tokenPubKey}: change ${change}`);
+      }
+      if (receiveValidated === false) {
+        throw new client_ledger('LEDGER_RECEIVE_NOT_MET', `${accountPubKey}/${tokenPubKey} did not receive enough of requested token. change: ${change}`);
+      }
     }
-    return await this.runReadOnly('db-getVotesFromMultiplePrevious', async function (transaction) {
-      return await transaction.getVotesFromMultiplePrevious(...args);
-    });
   }
-  async getBlockFromPrevious() {
-    for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
-      args[_key13] = arguments[_key13];
-    }
-    return await this.runReadOnly('db-getBlockFromPrevious', async function (transaction) {
-      return await transaction.getBlockFromPrevious(...args);
-    });
+  return effects;
+}
+async function client_validateBlocksForVote(blocks) {
+  /**
+   * Create a map of all blocks by their hash
+   */
+  const blockHashMap = {};
+  for (const block of blocks) {
+    blockHashMap[block.hash.toString()] = block;
   }
-  async getHeadBlocks() {
-    for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
-      args[_key14] = arguments[_key14];
+  const seenBlockHashes = new client_block_BlockHash.Set();
+  const usedPreviousBlockHashes = new client_block_BlockHash.Set();
+  const allLedgerHeads = new Map();
+  for (const block of blocks) {
+    const prevBlockHash = block.previous;
+    seenBlockHashes.add(block.hash);
+    if (block.network !== client_ledger_classPrivateFieldGet(client_network, this)) {
+      throw new client_ledger('LEDGER_INVALID_NETWORK', 'Cannot vote on block for a different network');
     }
-    return await this.runReadOnly('db-getHeadBlocks', async function (transaction) {
-      return await transaction.getHeadBlocks(...args);
-    });
-  }
-  async getHeadBlock() {
-    for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
-      args[_key15] = arguments[_key15];
+    if (block.subnet !== client_ledger_classPrivateFieldGet(client_subnet, this)) {
+      throw new client_ledger('LEDGER_INVALID_SUBNET', 'Cannot vote on block for a different subnet');
     }
-    return await this.runReadOnly('db-getHeadBlock', async function (transaction) {
-      return await transaction.getHeadBlock(...args);
-    });
-  }
-  async getAccountRep() {
-    for (var _len16 = arguments.length, args = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {
-      args[_key16] = arguments[_key16];
+    if (usedPreviousBlockHashes.has(prevBlockHash)) {
+      throw new client_ledger('LEDGER_PREVIOUS_ALREADY_USED', `Invalid reference to block, previous: ${prevBlockHash} has already been used`);
     }
-    return await this.runReadOnly('db-getAccountRep', async function (transaction) {
-      return await transaction.getAccountRep(...args);
-    });
-  }
-  async getAccountInfo() {
-    for (var _len17 = arguments.length, args = new Array(_len17), _key17 = 0; _key17 < _len17; _key17++) {
-      args[_key17] = arguments[_key17];
+    usedPreviousBlockHashes.add(prevBlockHash);
+
+    /**
+     * Only allow this vote if it is the successor the current
+     * HEAD block for the account, or if no blocks exist on the
+     * account and its an opening block, or if the predecessor
+     * block is also being voted on
+     */
+    let predecessorBeingVotedOn = false;
+    if (!block.$opening) {
+      const prevBlock = blockHashMap[prevBlockHash.toString()];
+      if (prevBlock !== undefined) {
+        predecessorBeingVotedOn = true;
+        if (!prevBlock.account.comparePublicKey(block.account)) {
+          throw new client_ledger('LEDGER_INVALID_CHAIN', 'Invalid chain, changes accounts');
+        }
+        if (!seenBlockHashes.has(prevBlockHash)) {
+          throw new client_ledger('LEDGER_PREVIOUS_NOT_SEEN', `Invalid reference to block, out-of-order: ${prevBlockHash} has not already been seen`);
+        }
+      }
     }
-    return await this.runReadOnly('db-getAccountInfo', async function (transaction) {
-      return await transaction.getAccountInfo(...args);
-    });
-  }
-  async getBlock() {
-    for (var _len18 = arguments.length, args = new Array(_len18), _key18 = 0; _key18 < _len18; _key18++) {
-      args[_key18] = arguments[_key18];
+    if (!predecessorBeingVotedOn) {
+      allLedgerHeads.set(block.account, block);
     }
-    return await this.runReadOnly('db-getBlock', async function (transaction) {
-      return await transaction.getBlock(...args);
-    });
   }
-  async getVoteStaple() {
-    for (var _len19 = arguments.length, args = new Array(_len19), _key19 = 0; _key19 < _len19; _key19++) {
-      args[_key19] = arguments[_key19];
-    }
-    return await this.runReadOnly('db-getVoteStaple', async function (transaction) {
-      return await transaction.getVoteStaple(...args);
-    });
+  return allLedgerHeads;
+}
+async function client_voteOrQuoteWithFees(blocks, type, quote) {
+  var _quote$fee;
+  if (client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode !== 'read-write') {
+    throw new Error(`May not issue votes in read-only mode, in ${client_ledger_classPrivateFieldGet(src_client_ledger, this).ledgerWriteMode} mode`);
   }
-  async getVoteStaples() {
-    for (var _len20 = arguments.length, args = new Array(_len20), _key20 = 0; _key20 < _len20; _key20++) {
-      args[_key20] = arguments[_key20];
-    }
-    return await this.runReadOnly('db-getVoteStaples', async function (transaction) {
-      return await transaction.getVoteStaples(...args);
-    });
+  if (!client_ledger_classPrivateFieldGet(client_ledger_privateKey, this)) {
+    throw new Error('Cannot vote on block, no private key loaded');
   }
-  async getHistory() {
-    for (var _len21 = arguments.length, args = new Array(_len21), _key21 = 0; _key21 < _len21; _key21++) {
-      args[_key21] = arguments[_key21];
+  client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
+  const effects = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_validateLedgerOutcome).call(this, blocks);
+  const now = Date.now();
+  for (const block of blocks) {
+    const blockDate = block.date.valueOf();
+    const timeOffset = 5 /* m */ * 60 /* s */ * 1000 /* ms */;
+
+    /**
+     * Do not allow short votes on blocks from the distant past
+     */
+    if (blockDate < now - timeOffset || blockDate > now + timeOffset) {
+      throw new Error(`Refusing to issue vote for block dated ${block.date.toISOString()}`);
     }
-    return await this.runReadOnly('db-getHistory', async function (transaction) {
-      return await transaction.getHistory(...args);
-    });
   }
-  async getStaplesFromBlockHashes() {
-    for (var _len22 = arguments.length, args = new Array(_len22), _key22 = 0; _key22 < _len22; _key22++) {
-      args[_key22] = arguments[_key22];
-    }
-    return await this.runReadOnly('db-getStaplesFromBlockHashes', async function (transaction) {
-      return await transaction.getStaplesFromBlockHashes(...args);
-    });
+
+  /**
+   * Serial number
+   */
+  const serial = await client_ledger_classPrivateFieldGet(client_ledger_storage, this).getNextSerialNumber(client_ledger_classPrivateFieldGet(client_transaction, this));
+
+  /**
+   * Short expiry (5 minutes)
+   */
+  const pendingVoteExpiry = new Date();
+  pendingVoteExpiry.setUTCMinutes(pendingVoteExpiry.getUTCMinutes() + 5);
+  const builderType = type === 'QUOTE' ? src_client_VoteQuoteBuilder : src_client_VoteBuilder;
+  const builder = new builderType(client_ledger_classPrivateFieldGet(client_ledger_privateKey, this));
+  for (const block of blocks) {
+    builder.addBlock(block);
   }
-  async getVoteStaplesAfter() {
-    for (var _len23 = arguments.length, args = new Array(_len23), _key23 = 0; _key23 < _len23; _key23++) {
-      args[_key23] = arguments[_key23];
-    }
-    return await this.runReadOnly('db-getVoteStaplesAfter', async function (transaction) {
-      return await transaction.getVoteStaplesAfter(...args);
-    });
+
+  /**
+   * If a quote was provided use it as the fee, otherwise generate new fee
+   */
+  const fee = (_quote$fee = quote === null || quote === void 0 ? void 0 : quote.fee) !== null && _quote$fee !== void 0 ? _quote$fee : await this.getFee(blocks, effects);
+  if (fee !== null) {
+    builder.addFee(fee);
   }
-  async gc() {
-    for (var _len24 = arguments.length, args = new Array(_len24), _key24 = 0; _key24 < _len24; _key24++) {
-      args[_key24] = arguments[_key24];
-    }
-    return await this.run('db-gc', async function (transaction) {
-      return await transaction.gc(...args);
+  const voteOrQuote = await builder.seal(serial, pendingVoteExpiry);
+  return voteOrQuote;
+}
+var client_storage2 = /*#__PURE__*/new WeakMap();
+var src_client_config = /*#__PURE__*/new WeakMap();
+class src_client_Ledger {
+  constructor(config, node, existingStorage) {
+    client_ledger_classPrivateFieldInitSpec(this, client_storage2, void 0);
+    client_ledger_classPrivateFieldInitSpec(this, src_client_config, void 0);
+    client_ledger_classPrivateFieldSet(src_client_config, this, {
+      ...config
     });
-  }
-  async getFee() {
-    for (var _len25 = arguments.length, args = new Array(_len25), _key25 = 0; _key25 < _len25; _key25++) {
-      args[_key25] = arguments[_key25];
+    const {
+      baseToken,
+      networkAddress
+    } = client_lib_account.generateBaseAddresses(config.network);
+    this.networkAddress = networkAddress;
+    this.baseToken = baseToken;
+    this.initialTrustedAccount = config.initialTrustedAccount;
+    this.node = node;
+    if (config.kind === client_LedgerKind.REPRESENTATIVE) {
+      if (config.privateKey === undefined) {
+        throw new Error('A private key must be provided if this is a Ledger for a representative');
+      }
     }
-    return await this.run('db-getFee', async function (transaction) {
-      return await transaction.getFee(...args);
-    });
+    if (existingStorage !== undefined) {
+      client_ledger_classPrivateFieldSet(client_storage2, this, existingStorage);
+      return;
+    }
+    client_ledger_classPrivateFieldSet(client_storage2, this, config.storageDriver);
+    client_ledger_classPrivateFieldGet(client_storage2, this).init(client_ledger_classPrivateFieldGet(src_client_config, this), this);
   }
-  async stats() {
-    try {
-      var _this$node5;
-      var _usingCtx3 = client_usingCtx2();
-      const _timing = _usingCtx3.u((_this$node5 = this.node) === null || _this$node5 === void 0 ? void 0 : _this$node5.timing.startTime('db-stats'));
-      const retval = await client_ledger_classPrivateFieldGet(client_storage2, this).stats();
-      return retval;
-    } catch (_) {
-      _usingCtx3.e = _;
-    } finally {
-      _usingCtx3.d();
+  get ledgerWriteMode() {
+    const retval = client_ledger_classPrivateFieldGet(src_client_config, this).ledgerWriteMode;
+    if (retval === undefined) {
+      return 'read-write';
     }
+    return retval;
   }
-  async _testingRunStorageFunction(code) {
-    return await this.run('db-runStorageFunction', async function (transaction) {
-      return await transaction._testingRunStorageFunction(code);
-    });
+  copy(newNode) {
+    return new src_client_Ledger(client_ledger_classPrivateFieldGet(src_client_config, this), newNode, client_ledger_classPrivateFieldGet(client_storage2, this));
   }
-}
-client_Ledger = src_client_Ledger;
-client_lib_ledger_defineProperty(src_client_Ledger, "Kind", client_LedgerKind);
-client_lib_ledger_defineProperty(src_client_Ledger, "isInstance", client_checkableGenerator(client_Ledger));
-/* harmony default export */ const client_lib_ledger = (src_client_Ledger);
-;// ./src/lib/kv/index.ts
-function client_kv_defineProperty(e, r, t) { return (r = client_kv_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function client_kv_toPropertyKey(t) { var i = client_kv_toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function client_kv_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); }
+  getFeePayToAndToken(accounts, token) {
+    const retval = {};
+    if (accounts !== undefined && accounts.length > 0) {
+      var _classPrivateFieldGet7;
+      // Get a random fee account from the set of possible accounts
+      const feeAccount = accounts[Math.floor(Math.random() * accounts.length)];
 
-class client_KVStorageProviderBase {
-  constructor() {
-    client_kv_defineProperty(this, "id", (0,client_lib_crypto.randomUUID)());
-  }
-  async xor(_ignored_arena, key, _ignored_change, _ignored_options) {
-    if (key.startsWith('@buffer:')) {
-      return;
+      // If the fee account matches the ledger private key then we can omit the account
+      // Fee is then paid to the vote issuer
+      if (!feeAccount.comparePublicKey((_classPrivateFieldGet7 = client_ledger_classPrivateFieldGet(src_client_config, this).privateKey) === null || _classPrivateFieldGet7 === void 0 ? void 0 : _classPrivateFieldGet7.publicKeyString.get())) {
+        retval.payTo = feeAccount;
+      }
     }
-    throw new Error('Key provided for XOR must begin with "@buffer"');
+    if (token !== undefined) {
+      // If base token matches ledger fee token then we can omit the token
+      // Fee is then paid using the base token
+      if (!this.baseToken.comparePublicKey(token)) {
+        retval.token = token;
+      }
+    }
+    return retval;
   }
-}
-;// ./src/lib/kv/kv_memory.ts
-function client_kv_memory_classPrivateMethodInitSpec(e, a) { client_kv_memory_checkPrivateRedeclaration(e, a), a.add(e); }
-function client_kv_memory_classPrivateFieldInitSpec(e, t, a) { client_kv_memory_checkPrivateRedeclaration(e, t), t.set(e, a); }
-function client_kv_memory_checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function client_kv_memory_classPrivateFieldGet(s, a) { return s.get(client_kv_memory_assertClassBrand(s, a)); }
-function client_kv_memory_classPrivateFieldSet(s, a, r) { return s.set(client_kv_memory_assertClassBrand(s, a), r), r; }
-function client_kv_memory_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"); }
 
+  /**
+   * Execute some code with a transaction held, if the code fails the
+   * transaction is aborted, otherwise it is committed
+   *
+   * @param code - Code to run
+   * @returns The return value from "code"
+   */
+  async run(identifier, code, readOnly) {
+    try {
+      var _this$node, _classPrivateFieldGet8, _classPrivateFieldGet9, _this$node4;
+      var _usingCtx = client_usingCtx2();
+      const _timing = _usingCtx.u((_this$node = this.node) === null || _this$node === void 0 ? void 0 : _this$node.timing.startTime(`run-${identifier}`));
+      let retryConfig;
+      if (((_classPrivateFieldGet8 = client_ledger_classPrivateFieldGet(src_client_config, this).transactionRetries) === null || _classPrivateFieldGet8 === void 0 ? void 0 : _classPrivateFieldGet8.maxRetries) !== undefined) {
+        retryConfig = {
+          mode: 'count',
+          maxRetries: client_ledger_classPrivateFieldGet(src_client_config, this).transactionRetries.maxRetries
+        };
+      } else if (((_classPrivateFieldGet9 = client_ledger_classPrivateFieldGet(src_client_config, this).transactionRetries) === null || _classPrivateFieldGet9 === void 0 ? void 0 : _classPrivateFieldGet9.timeout) !== undefined) {
+        retryConfig = {
+          mode: 'time',
+          timeout: client_ledger_classPrivateFieldGet(src_client_config, this).transactionRetries.timeout
+        };
+      } else {
+        /* Legacy default */
+        // retryConfig = {
+        // 	mode: 'count',
+        // 	maxCount: 128
+        // };
+        retryConfig = {
+          mode: 'time',
+          timeout: 5000
+        };
+      }
+      let retval;
+      let retryCount = 0;
+      const startTime = Date.now();
+      for (;; retryCount++) {
+        try {
+          let runError;
+          let threw = false;
+          const transaction = await this.beginTransaction(identifier, readOnly);
+          try {
+            retval = await code(transaction);
+          } catch (e) {
+            threw = true;
+            runError = e;
+          }
 
-const client_nullArena = 'null:43c98976-2282-44c2-819a-769732ceb847';
-function client_deserialize(value) {
-  if (src_client_BufferStorage.isInstance(value)) {
-    value = value.toString('hex');
-  }
-  return value;
-}
-var client_db = /*#__PURE__*/new WeakMap();
-var client_KVStorageProviderMemory_brand = /*#__PURE__*/new WeakSet();
-class client_KVStorageProviderMemory extends client_KVStorageProviderBase {
-  constructor() {
-    super();
-    client_kv_memory_classPrivateMethodInitSpec(this, client_KVStorageProviderMemory_brand);
-    client_kv_memory_classPrivateFieldInitSpec(this, client_db, void 0);
-    client_kv_memory_classPrivateFieldSet(client_db, this, {});
-  }
-  async set(arena, key, value, options) {
-    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, arena);
-    if (value !== undefined) {
-      if (options !== null && options !== void 0 && options.exclusiveCreate) {
-        if (storeArena[key] !== undefined) {
-          throw new Error('unable to exclusively create this item, already exists');
+          // If running code was successful, commit, otherwise abort and throw error
+          if (threw === false) {
+            var _this$node2;
+            await client_RequestTiming.runTimer(`${identifier}/commit`, (_this$node2 = this.node) === null || _this$node2 === void 0 ? void 0 : _this$node2.timing, async () => {
+              await transaction.commit();
+            });
+          } else {
+            var _this$node3;
+            await client_RequestTiming.runTimer(`${identifier}/abort`, (_this$node3 = this.node) === null || _this$node3 === void 0 ? void 0 : _this$node3.timing, async () => {
+              await transaction.abort();
+            });
+            throw runError;
+          }
+        } catch (runError) {
+          const txnError = await client_ledger_classPrivateFieldGet(client_storage2, this).evaluateError(runError);
+          let shouldTryToRetry = false;
+          if (retryConfig.mode === 'count') {
+            shouldTryToRetry = retryCount < retryConfig.maxRetries;
+          } else if (retryConfig.mode === 'time') {
+            const now = Date.now();
+            shouldTryToRetry = now - startTime < retryConfig.timeout;
+          }
+          if (shouldTryToRetry) {
+            if (client_ledger.isInstance(txnError)) {
+              if (txnError.shouldRetry) {
+                let retryDelay = 20;
+                if (txnError.retryDelay) {
+                  retryDelay = txnError.retryDelay;
+                }
+                await client_asleep(retryDelay);
+                continue;
+              }
+            }
+          }
+          throw txnError;
         }
+        break;
       }
+      if (retval === undefined) {
+        throw new Error('Return value for run() is undefined');
+      }
+      (_this$node4 = this.node) === null || _this$node4 === void 0 || _this$node4.stats.incr('ledger', 'dbRetries', retryCount);
+      return retval;
+    } catch (_) {
+      _usingCtx.e = _;
+    } finally {
+      _usingCtx.d();
     }
-    let expiry;
-    if ((options === null || options === void 0 ? void 0 : options.ttl) !== undefined) {
-      expiry = Date.now() + options.ttl;
-    }
-    if (value === undefined || value === null) {
-      delete storeArena[key];
-      return;
-    }
-    storeArena[key] = {
-      value,
-      expiry
-    };
   }
-  async get(arena, key) {
-    if (arena === null) {
-      arena = client_nullArena;
-    }
-    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, arena);
-    if (!storeArena[key]) {
-      return undefined;
-    }
-    const {
-      expiry,
-      value
-    } = storeArena[key];
-    if (expiry !== undefined) {
-      if (expiry < Date.now()) {
-        delete storeArena[key];
-        return undefined;
-      }
+  async runReadOnly(identifier, code) {
+    return await this.run(identifier, code, true);
+  }
+  async beginTransaction(identifier) {
+    let readOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const transaction = await client_ledger_classPrivateFieldGet(client_storage2, this).beginTransaction({
+      node: this.node,
+      moment: new Date(),
+      identifier,
+      readOnly
+    });
+    return new client_LedgerAtomicInterface(transaction, client_ledger_classPrivateFieldGet(client_storage2, this), client_ledger_classPrivateFieldGet(src_client_config, this), this);
+  }
+  async vote() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
-    const retval = client_deserialize(value);
-    return retval;
+    return await this.run('db-vote', async function (transaction) {
+      return await transaction.vote(...args);
+    });
   }
-  async getAll(arena) {
-    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, arena);
-    const retval = {};
-    for (const key in storeArena) {
-      const value = await this.get(arena, key);
-      if (value === undefined) {
-        continue;
-      }
-      retval[key] = value;
+  async quote() {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
     }
-    return retval;
+    return await this.run('db-quote', async function (transaction) {
+      return await transaction.quote(...args);
+    });
   }
-  async list(arena) {
-    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, arena);
-    return Object.keys(storeArena);
+  async add() {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    return await this.run('db-add', async function (transaction) {
+      return await transaction.add(...args);
+    });
   }
-  async incr(arena, key, change) {
-    var _previous$value;
-    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, arena);
-    const previous = storeArena[key];
-    let previousValue = (_previous$value = previous === null || previous === void 0 ? void 0 : previous.value) !== null && _previous$value !== void 0 ? _previous$value : 0;
-    if (typeof previousValue !== 'number') {
-      throw new Error('May not increment non-number');
+  async listACLsByPrincipal() {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
     }
-    let newExpiry;
-    if ((previous === null || previous === void 0 ? void 0 : previous.expiry) !== undefined) {
-      if (previous.expiry < Date.now()) {
-        previousValue = 0;
-      } else {
-        newExpiry = previous.expiry;
-      }
+    return await this.runReadOnly('db-listACLs', async function (transaction) {
+      return await transaction.listACLsByPrincipal(...args);
+    });
+  }
+  async listACLsByEntity() {
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
     }
-    const newVal = previousValue + change;
-    storeArena[key] = {
-      value: newVal,
-      expiry: newExpiry
-    };
-    return BigInt(newVal);
+    return await this.runReadOnly('db-listACLs', async function (transaction) {
+      return await transaction.listACLsByEntity(...args);
+    });
   }
-  async xor(arena, key, change) {
-    await super.xor(arena, key, change);
-    const storeArena = client_kv_memory_assertClassBrand(client_KVStorageProviderMemory_brand, this, client_getArena).call(this, client_nullArena);
-    const previous = storeArena[key];
-    const value = previous === null || previous === void 0 ? void 0 : previous.value;
-    if (value === undefined) {
-      storeArena[key] = {
-        value: change
-      };
-      return;
+  async getBalance() {
+    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+      args[_key6] = arguments[_key6];
     }
-    if (!src_client_BufferStorage.isInstance(value) || previous.expiry !== undefined) {
-      throw new Error('May only use XOR on keys containing BufferStorage without expiry');
+    return await this.runReadOnly('db-getBalance', async function (transaction) {
+      return await transaction.getBalance(...args);
+    });
+  }
+  async getAllBalances() {
+    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+      args[_key7] = arguments[_key7];
     }
-    const valueBigInt = value.toBigInt();
-    const changeBigInt = change.toBigInt();
-    const valueLength = Math.max(value.length, change.length);
-    const newValue = valueBigInt ^ changeBigInt;
-    storeArena[key] = {
-      value: new src_client_BufferStorage(newValue, valueLength)
-    };
+    return await this.runReadOnly('db-getAllBalances', async function (transaction) {
+      return await transaction.getAllBalances(...args);
+    });
   }
-}
-function client_getArena(arena) {
-  if (client_kv_memory_classPrivateFieldGet(client_db, this)[arena] === undefined) {
-    client_kv_memory_classPrivateFieldGet(client_db, this)[arena] = {};
+  async getAccountCertificates() {
+    for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+      args[_key8] = arguments[_key8];
+    }
+    return await this.runReadOnly('db-getAccountCertificates', async function (transaction) {
+      return await transaction.getAccountCertificates(...args);
+    });
   }
-  return client_kv_memory_classPrivateFieldGet(client_db, this)[arena];
-}
-/* harmony default export */ const client_kv_memory = (client_KVStorageProviderMemory);
-;// ./src/lib/stats.ts
-function client_stats_classPrivateMethodInitSpec(e, a) { client_stats_checkPrivateRedeclaration(e, a), a.add(e); }
-function client_stats_classPrivateFieldInitSpec(e, t, a) { client_stats_checkPrivateRedeclaration(e, t), t.set(e, a); }
-function client_stats_checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
-function client_stats_classPrivateFieldGet(s, a) { return s.get(client_stats_assertClassBrand(s, a)); }
-function client_stats_classPrivateFieldSet(s, a, r) { return s.set(client_stats_assertClassBrand(s, a), r), r; }
-function client_stats_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"); }
-
-
-
-/**
- * Size of the XOR buffer objects -- we use them for block hashes so they
- * should be the same size as a block hash
- */
-const client_XOR_BUFFER_SIZE = client_HashFunctionLength;
-const client_durationRanges = {
-  '-1ms': [-1, -1],
-  '0ms': [0, 0],
-  '10ms': [1, 10],
-  '100ms': [11, 100],
-  '200ms': [101, 200],
-  '300ms': [201, 300],
-  '400ms': [301, 400],
-  '500ms': [401, 500],
-  '600ms': [501, 600],
-  '700ms': [601, 700],
-  '800ms': [701, 800],
-  '900ms': [801, 900],
-  '1000ms': [901, 1000],
-  '1500ms': [1001, 1500],
-  '2000ms': [1501, 2000],
-  '5000ms': [2001, 5000],
-  '10000ms': [5001, 10000],
-  '100000ms': [10001, 100000],
-  'ExtraLong': [100000, Number.MAX_SAFE_INTEGER]
-};
-var client_localDBIncr = /*#__PURE__*/new WeakMap();
-var client_localDBXOR = /*#__PURE__*/new WeakMap();
-var client_syncPromise = /*#__PURE__*/new WeakMap();
-var client_kv = /*#__PURE__*/new WeakMap();
-var client_Stats_brand = /*#__PURE__*/new WeakSet();
-class client_Stats {
-  constructor(config) {
-    client_stats_classPrivateMethodInitSpec(this, client_Stats_brand);
-    client_stats_classPrivateFieldInitSpec(this, client_localDBIncr, {});
-    client_stats_classPrivateFieldInitSpec(this, client_localDBXOR, {});
-    client_stats_classPrivateFieldInitSpec(this, client_syncPromise, void 0);
-    client_stats_classPrivateFieldInitSpec(this, client_kv, void 0);
-    let kv = config.kv;
-    if (kv === null) {
-      kv = new client_kv_memory();
+  async getAccountCertificateByHash() {
+    for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+      args[_key9] = arguments[_key9];
     }
-    client_stats_classPrivateFieldSet(client_kv, this, kv);
+    return await this.runReadOnly('db-getAccountCertificateByHash', async function (transaction) {
+      return await transaction.getAccountCertificateByHash(...args);
+    });
   }
-  // Return all keys from durationRanges
-  static durationBreakdownList() {
-    // We know the keys are all valid to the type, but typescript does not know this
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return Object.keys(client_durationRanges);
+  async votingPower() {
+    for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
+      args[_key10] = arguments[_key10];
+    }
+    return await this.runReadOnly('db-votingPower', async function (transaction) {
+      return await transaction.votingPower(...args);
+    });
   }
-  static assertDurationBreakdown(duration) {
-    if (!(duration in client_durationRanges)) {
-      throw new Error(`Invalid duration: ${duration}`);
+  async getVotes() {
+    for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
+      args[_key11] = arguments[_key11];
     }
+    return await this.runReadOnly('db-getVotes', async function (transaction) {
+      return await transaction.getVotes(...args);
+    });
   }
-  // Get duration key for specific number
-  static durationBreakdown(duration) {
-    // Loop through ranges and select key with range that fits around duration
-
-    if (duration < 0) {
-      duration = 0;
+  async getVotesFromMultiplePrevious() {
+    for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
+      args[_key12] = arguments[_key12];
     }
-    for (const name of this.durationBreakdownList()) {
-      const [min, max] = client_durationRanges[name];
-      if (duration >= min && (max === undefined || duration <= max)) {
-        return name;
-      }
+    return await this.runReadOnly('db-getVotesFromMultiplePrevious', async function (transaction) {
+      return await transaction.getVotesFromMultiplePrevious(...args);
+    });
+  }
+  async getBlockFromPrevious() {
+    for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
+      args[_key13] = arguments[_key13];
     }
-    throw new Error(`Time frame not found for duration: ${duration}`);
+    return await this.runReadOnly('db-getBlockFromPrevious', async function (transaction) {
+      return await transaction.getBlockFromPrevious(...args);
+    });
   }
-  static placeholderTimingData() {
-    const ret = {};
-    for (const key of this.durationBreakdownList()) {
-      ret[key] = {
-        count: -1,
-        range: client_stats_assertClassBrand(client_Stats, this, client_getDurationRange).call(this, key)
-      };
+  async getHeadBlocks() {
+    for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
+      args[_key14] = arguments[_key14];
     }
-
-    // We know this fits TimeStats because we just created it with all of the keys
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return ret;
+    return await this.runReadOnly('db-getHeadBlocks', async function (transaction) {
+      return await transaction.getHeadBlocks(...args);
+    });
   }
-  incr(arena, key) {
-    let change = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
-    const compoundKey = client_stats_assertClassBrand(client_Stats_brand, this, client_compoundKey).call(this, arena, key);
-    if (client_stats_classPrivateFieldGet(client_localDBIncr, this)[compoundKey] === undefined) {
-      client_stats_classPrivateFieldGet(client_localDBIncr, this)[compoundKey] = 0;
+  async getHeadBlock() {
+    for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
+      args[_key15] = arguments[_key15];
     }
-    client_stats_classPrivateFieldGet(client_localDBIncr, this)[compoundKey] += change;
+    return await this.runReadOnly('db-getHeadBlock', async function (transaction) {
+      return await transaction.getHeadBlock(...args);
+    });
   }
-  xor(key, change) {
-    const changeValue = change.toBigInt();
-    const existingValue = client_stats_classPrivateFieldGet(client_localDBXOR, this)[key];
-    if (existingValue === undefined) {
-      client_stats_classPrivateFieldGet(client_localDBXOR, this)[key] = changeValue;
-      return;
+  async getAccountRep() {
+    for (var _len16 = arguments.length, args = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {
+      args[_key16] = arguments[_key16];
     }
-    client_stats_classPrivateFieldGet(client_localDBXOR, this)[key] ^= changeValue;
+    return await this.runReadOnly('db-getAccountRep', async function (transaction) {
+      return await transaction.getAccountRep(...args);
+    });
   }
-  async getXor(key) {
-    await client_stats_classPrivateFieldGet(client_syncPromise, this);
-    const bufferKey = `@buffer:${key}`;
-    const baseString = await client_stats_classPrivateFieldGet(client_kv, this).get(null, bufferKey);
-    let base = 0n;
-    if (baseString !== undefined) {
-      base = BigInt(`0x${baseString}`);
+  async getAccountInfo() {
+    for (var _len17 = arguments.length, args = new Array(_len17), _key17 = 0; _key17 < _len17; _key17++) {
+      args[_key17] = arguments[_key17];
     }
-    let local = 0n;
-    if (client_stats_classPrivateFieldGet(client_localDBXOR, this)[key] !== undefined) {
-      local = client_stats_classPrivateFieldGet(client_localDBXOR, this)[key];
+    return await this.runReadOnly('db-getAccountInfo', async function (transaction) {
+      return await transaction.getAccountInfo(...args);
+    });
+  }
+  async getBlock() {
+    for (var _len18 = arguments.length, args = new Array(_len18), _key18 = 0; _key18 < _len18; _key18++) {
+      args[_key18] = arguments[_key18];
     }
-    const computed = base ^ local;
-    const retval = new src_client_BufferStorage(computed, client_XOR_BUFFER_SIZE);
-    return retval;
+    return await this.runReadOnly('db-getBlock', async function (transaction) {
+      return await transaction.getBlock(...args);
+    });
   }
-
-  // Calculate key and increment for specific duration/category
-  addTimingPoint(arena, category, duration) {
-    let returnOnly = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-    const breakdown = client_Stats.durationBreakdown(duration);
-    const params = [arena, `${category}@${breakdown}`, 1];
-    if (returnOnly !== true) {
-      this.incr(...params);
+  async getAccountsBlockHeightInfo() {
+    for (var _len19 = arguments.length, args = new Array(_len19), _key19 = 0; _key19 < _len19; _key19++) {
+      args[_key19] = arguments[_key19];
     }
-    return params;
+    return await this.runReadOnly('db-getAccountsBlockHeightInfo', async function (transaction) {
+      return await transaction.getAccountsBlockHeightInfo(...args);
+    });
   }
-  addRequestTiming(arena, timing) {
-    let returnOnly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    const retval = [];
-    for (const sectionInfo of Object.values(timing.getAllTiming())) {
-      const duration = sectionInfo.duration;
-      const name = sectionInfo.name;
-      retval.push(this.addTimingPoint(arena, name, duration, returnOnly));
+  async getVoteStaple() {
+    for (var _len20 = arguments.length, args = new Array(_len20), _key20 = 0; _key20 < _len20; _key20++) {
+      args[_key20] = arguments[_key20];
     }
-    return retval;
+    return await this.runReadOnly('db-getVoteStaple', async function (transaction) {
+      return await transaction.getVoteStaple(...args);
+    });
   }
-  async get(arena, key) {
-    await client_stats_classPrivateFieldGet(client_syncPromise, this);
-    const compoundKey = client_stats_assertClassBrand(client_Stats_brand, this, client_compoundKey).call(this, arena, key);
-    let base = await client_stats_classPrivateFieldGet(client_kv, this).get('stats', compoundKey);
-    if (base === undefined) {
-      base = 0;
+  async getVoteStaples() {
+    for (var _len21 = arguments.length, args = new Array(_len21), _key21 = 0; _key21 < _len21; _key21++) {
+      args[_key21] = arguments[_key21];
     }
-    if (typeof base === 'string') {
-      base = Number(base);
+    return await this.runReadOnly('db-getVoteStaples', async function (transaction) {
+      return await transaction.getVoteStaples(...args);
+    });
+  }
+  async getHistory() {
+    for (var _len22 = arguments.length, args = new Array(_len22), _key22 = 0; _key22 < _len22; _key22++) {
+      args[_key22] = arguments[_key22];
     }
-    if (typeof base !== 'number' || isNaN(base)) {
-      throw new Error('internal error: corrupt data in stats table');
+    return await this.runReadOnly('db-getHistory', async function (transaction) {
+      return await transaction.getHistory(...args);
+    });
+  }
+  async getStaplesFromBlockHashes() {
+    for (var _len23 = arguments.length, args = new Array(_len23), _key23 = 0; _key23 < _len23; _key23++) {
+      args[_key23] = arguments[_key23];
     }
-    let local = 0;
-    if (client_stats_classPrivateFieldGet(client_localDBIncr, this)[compoundKey] !== undefined) {
-      local = client_stats_classPrivateFieldGet(client_localDBIncr, this)[compoundKey];
+    return await this.runReadOnly('db-getStaplesFromBlockHashes', async function (transaction) {
+      return await transaction.getStaplesFromBlockHashes(...args);
+    });
+  }
+  async getVoteStaplesAfter() {
+    for (var _len24 = arguments.length, args = new Array(_len24), _key24 = 0; _key24 < _len24; _key24++) {
+      args[_key24] = arguments[_key24];
     }
-    return base + local;
+    return await this.runReadOnly('db-getVoteStaplesAfter', async function (transaction) {
+      return await transaction.getVoteStaplesAfter(...args);
+    });
   }
-
-  // Get all timing data from specific arena/category
-  async getTimingData(arena, category) {
-    const retval = client_Stats.placeholderTimingData();
-    const keys = Object.keys(retval);
-    client_assertDurationBreakdowns.call(client_Stats, keys);
-    await Promise.all(keys.map(async breakdown => {
-      const key = `${category}@${breakdown}`;
-      const range = client_getDurationRange.call(client_Stats, breakdown);
-      let count = -1;
-      try {
-        count = await this.get(arena, key);
-      } catch (_ignored_error) {
-        /* Errors fetching single stat are ignored */
-      } finally {
-        retval[breakdown] = {
-          count,
-          range
-        };
-      }
-    }));
-    return retval;
+  async gc() {
+    for (var _len25 = arguments.length, args = new Array(_len25), _key25 = 0; _key25 < _len25; _key25++) {
+      args[_key25] = arguments[_key25];
+    }
+    return await this.run('db-gc', async function (transaction) {
+      return await transaction.gc(...args);
+    });
   }
-  async sync() {
-    const localDBIncr = Object.entries(client_stats_classPrivateFieldGet(client_localDBIncr, this));
-    const localDBXOR = Object.entries(client_stats_classPrivateFieldGet(client_localDBXOR, this));
-    client_stats_classPrivateFieldSet(client_localDBIncr, this, {});
-    client_stats_classPrivateFieldSet(client_localDBXOR, this, {});
-    await client_stats_classPrivateFieldGet(client_syncPromise, this);
-    client_stats_classPrivateFieldSet(client_syncPromise, this, (async () => {
-      const updatePromises = [];
-      for (const [key, value] of localDBIncr) {
-        if (value === undefined) {
-          continue;
-        }
-        updatePromises.push(client_stats_classPrivateFieldGet(client_kv, this).incr('stats', key, value));
-      }
-      for (const [key, value] of localDBXOR) {
-        if (value === undefined) {
-          continue;
-        }
-        const valueBuffer = new src_client_BufferStorage(value, client_XOR_BUFFER_SIZE);
-        const bufferKey = `@buffer:${key}`;
-        updatePromises.push(client_stats_classPrivateFieldGet(client_kv, this).xor(null, bufferKey, valueBuffer));
-      }
-      await Promise.all(updatePromises);
-    })());
-    await client_stats_classPrivateFieldGet(client_syncPromise, this);
-    client_stats_classPrivateFieldSet(client_syncPromise, this, undefined);
+  async getFee() {
+    for (var _len26 = arguments.length, args = new Array(_len26), _key26 = 0; _key26 < _len26; _key26++) {
+      args[_key26] = arguments[_key26];
+    }
+    return await this.runReadOnly('db-getFee', async function (transaction) {
+      return await transaction.getFee(...args);
+    });
   }
-}
-function client_compoundKey(arena, key) {
-  const compoundKey = [arena, key].join('|');
-  return compoundKey;
-}
-function client_assertDurationBreakdowns(durations) {
-  for (const duration of durations) {
-    this.assertDurationBreakdown(duration);
+  async stats() {
+    try {
+      var _this$node5;
+      var _usingCtx3 = client_usingCtx2();
+      const _timing = _usingCtx3.u((_this$node5 = this.node) === null || _this$node5 === void 0 ? void 0 : _this$node5.timing.startTime('db-stats'));
+      const retval = await client_ledger_classPrivateFieldGet(client_storage2, this).stats();
+      return retval;
+    } catch (_) {
+      _usingCtx3.e = _;
+    } finally {
+      _usingCtx3.d();
+    }
   }
-}
-function client_getDurationRange(duration) {
-  this.assertDurationBreakdown(duration);
-  const range = client_durationRanges[duration];
-  if (!range) {
-    throw new Error(`Could not get range for invalid duration: ${duration}, got range ${range}`);
+  async _testingRunStorageFunction(code) {
+    return await this.run('db-runStorageFunction', async function (transaction) {
+      return await transaction._testingRunStorageFunction(code);
+    });
   }
-
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return range;
 }
-/* harmony default export */ const client_stats = (client_Stats);
+client_Ledger = src_client_Ledger;
+client_lib_ledger_defineProperty(src_client_Ledger, "Kind", client_LedgerKind);
+client_lib_ledger_defineProperty(src_client_Ledger, "isInstance", client_checkableGenerator(client_Ledger));
+/* harmony default export */ const client_lib_ledger = (src_client_Ledger);
 // EXTERNAL MODULE: ws (ignored)
 var client_ws_ignored_ = __webpack_require__(4708);
 ;// ./src/version.ts
-const client_version = '0.14.0+g8b0bdc16c0cba85135437a9ffb3a8cea2dae170d';
+const client_version = '0.14.3+gc0f4c96265aa999e6f32e3b21443d294bbf33806';
 /* 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"];
@@ -127583,6 +127692,8 @@ var client_localNode = /*#__PURE__*/new WeakMap();
 var client_manualPeersCheckIntervals = /*#__PURE__*/new WeakMap();
 var client_asyncSends = /*#__PURE__*/new WeakMap();
 var client_messageFilterCache = /*#__PURE__*/new WeakMap();
+var client_cachedLocalPeerInfo = /*#__PURE__*/new WeakMap();
+var client_cachedLocalPeerSerialized = /*#__PURE__*/new WeakMap();
 var client_P2PSwitch_brand = /*#__PURE__*/new WeakSet();
 var client_peersCacheSet = /*#__PURE__*/new WeakMap();
 class src_client_P2PSwitch {
@@ -127618,6 +127729,8 @@ class src_client_P2PSwitch {
     client_p2p_classPrivateFieldInitSpec(this, client_manualPeersCheckIntervals, void 0);
     client_p2p_classPrivateFieldInitSpec(this, client_asyncSends, []);
     client_p2p_classPrivateFieldInitSpec(this, client_messageFilterCache, {});
+    client_p2p_classPrivateFieldInitSpec(this, client_cachedLocalPeerInfo, undefined);
+    client_p2p_classPrivateFieldInitSpec(this, client_cachedLocalPeerSerialized, undefined);
     /**
      * Write a debug or error message to the connected node.
      *
@@ -127962,11 +128075,14 @@ class src_client_P2PSwitch {
     return await client_p2p_assertClassBrand(client_P2PSwitch_brand, this, client_getLocalPeerInfo).call(this);
   }
   async getOutgoingGreetingInfo() {
-    const greetingInfo = await client_p2p_assertClassBrand(client_P2PSwitch_brand, this, client_getLocalPeerInfo).call(this);
-    if (greetingInfo === null) {
-      throw new Error('Invalid NodeKind for emitting outgoing greeting');
+    if (client_p2p_classPrivateFieldGet(client_cachedLocalPeerSerialized, this) === undefined) {
+      const greetingInfo = await client_p2p_assertClassBrand(client_P2PSwitch_brand, this, client_getLocalPeerInfo).call(this);
+      if (greetingInfo === null) {
+        throw new Error('Invalid NodeKind for emitting outgoing greeting');
+      }
+      client_p2p_classPrivateFieldSet(client_cachedLocalPeerSerialized, this, client_P2PPeerToJSO(greetingInfo));
     }
-    return client_P2PPeerToJSO(greetingInfo);
+    return client_p2p_classPrivateFieldGet(client_cachedLocalPeerSerialized, this);
   }
   /**
    * Receive a message from a connection
@@ -128655,47 +128771,50 @@ async function client_performPeerCleanup() {
   /** XXX:TODO */
 }
 async function client_getLocalPeerInfo() {
-  let greetingInfo;
-  switch (client_p2p_classPrivateFieldGet(client_localNode, this).config.kind) {
-    case client_node_NodeKind.PARTICIPANT:
-      greetingInfo = {
-        kind: client_p2p_classPrivateFieldGet(client_localNode, this).config.kind,
-        id: 'unused'
-      };
-      break;
-    case client_node_NodeKind.REPRESENTATIVE:
-      {
-        if (client_p2p_classPrivateFieldGet(client_localNode, this).config.endpoints === undefined) {
-          throw new Error('internal error: Our endpoints are not defined');
-        }
-        if (client_p2p_classPrivateFieldGet(client_localNode, this).config.endpoints.p2p === undefined) {
-          throw new Error('internal error: Our endpoint (p2p) is not defined');
-        }
-        if (client_p2p_classPrivateFieldGet(client_localNode, this).config.endpoints.api === undefined) {
-          throw new Error('internal error: Our endpoint (api) is not defined');
-        }
-        if (client_p2p_classPrivateFieldGet(client_localNode, this).config.ledgerPrivateKey === undefined) {
-          throw new Error('internal error: Our ledger key is not defined');
-        }
-        const greetingInfoSigned = await client_generateP2PPeerSigned({
+  if (client_p2p_classPrivateFieldGet(client_cachedLocalPeerInfo, this) === undefined) {
+    let greetingInfo;
+    switch (client_p2p_classPrivateFieldGet(client_localNode, this).config.kind) {
+      case client_node_NodeKind.PARTICIPANT:
+        greetingInfo = {
           kind: client_p2p_classPrivateFieldGet(client_localNode, this).config.kind,
-          key: client_p2p_classPrivateFieldGet(client_localNode, this).config.ledgerPrivateKey,
-          endpoints: {
-            p2p: client_p2p_classPrivateFieldGet(client_localNode, this).config.endpoints.p2p,
-            api: client_p2p_classPrivateFieldGet(client_localNode, this).config.endpoints.api
-          },
-          preferUpdates: this.config.useHTTPRepublish ? 'http' : 'websocket'
-        });
-        if (greetingInfoSigned === null) {
-          throw new Error('internal error: Could not generate signature');
-        }
-        greetingInfo = greetingInfoSigned;
+          id: 'unused'
+        };
         break;
-      }
-    default:
-      return null;
+      case client_node_NodeKind.REPRESENTATIVE:
+        {
+          if (client_p2p_classPrivateFieldGet(client_localNode, this).config.endpoints === undefined) {
+            throw new Error('internal error: Our endpoints are not defined');
+          }
+          if (client_p2p_classPrivateFieldGet(client_localNode, this).config.endpoints.p2p === undefined) {
+            throw new Error('internal error: Our endpoint (p2p) is not defined');
+          }
+          if (client_p2p_classPrivateFieldGet(client_localNode, this).config.endpoints.api === undefined) {
+            throw new Error('internal error: Our endpoint (api) is not defined');
+          }
+          if (client_p2p_classPrivateFieldGet(client_localNode, this).config.ledgerPrivateKey === undefined) {
+            throw new Error('internal error: Our ledger key is not defined');
+          }
+          const greetingInfoSigned = await client_generateP2PPeerSigned({
+            kind: client_p2p_classPrivateFieldGet(client_localNode, this).config.kind,
+            key: client_p2p_classPrivateFieldGet(client_localNode, this).config.ledgerPrivateKey,
+            endpoints: {
+              p2p: client_p2p_classPrivateFieldGet(client_localNode, this).config.endpoints.p2p,
+              api: client_p2p_classPrivateFieldGet(client_localNode, this).config.endpoints.api
+            },
+            preferUpdates: this.config.useHTTPRepublish ? 'http' : 'websocket'
+          });
+          if (greetingInfoSigned === null) {
+            throw new Error('internal error: Could not generate signature');
+          }
+          greetingInfo = greetingInfoSigned;
+          break;
+        }
+      default:
+        return null;
+    }
+    client_p2p_classPrivateFieldSet(client_cachedLocalPeerInfo, this, greetingInfo);
   }
-  return greetingInfo;
+  return client_p2p_classPrivateFieldGet(client_cachedLocalPeerInfo, this);
 }
 async function client_emitOutgoingGreeting(to) {
   const messageID = client_esm_browser_v4();
@@ -129353,9 +129472,18 @@ function client_builder_assertClassBrand(e, t, n) { if ("function" == typeof e ?
 
 
 
+/** @expand */
+
 /** @expandType GetPrevFunction */
 
-/** @useDeclaredType */
+/** @expand */
+
+/*
+ * Ensure that BlockBuilderOptions is exactly the same as
+ * Partial<AccountSignerOptions> -- we do this so that the
+ * documentation gets generated correctly, otherwise it
+ * gets confused by `Partial`
+ */
 
 /**
  * Either a UserClient or an object with a client and network
@@ -131987,6 +132115,7 @@ function client_parseAccountInfo(account, accountInfo) {
   return {
     account: client_src_lib.Account.fromPublicKeyString(accountInfo.account),
     currentHeadBlock: currentHeadBlock,
+    currentHeadBlockHeight: accountInfo.currentHeadBlockHeight,
     representative: currentRepresentative,
     info: client_client_assertClassBrand(client_Client_brand, this, client_formatAccountInfo).call(this, accountInfo.info),
     balances: client_client_assertClassBrand(client_Client_brand, this, client_formatAllBalances).call(this, accountInfo.balances)