@keetanetwork/keetanet-client 0.12.2 → 0.14.0

package/client/index-browser.js

@@ -101177,6 +101177,7 @@ __webpack_require__.d(client_helper_namespaceObject, {
   asleep: () => (client_asleep),
   booleanEnv: () => (client_booleanEnv),
   bufferToArrayBuffer: () => (client_bufferToArrayBuffer),
+  bufferToBigInt: () => (client_helper_bufferToBigInt),
   checkableGenerator: () => (client_checkableGenerator),
   crypto: () => (client_helper_crypto),
   debugPrintableObject: () => (client_debugPrintableObject),
@@ -105417,6 +105418,13 @@ function client_bufferToArrayBuffer(input) {
   }
   return out;
 }
+function client_helper_bufferToBigInt(buffer) {
+  let result = 0n;
+  for (const byte of buffer) {
+    result = (result << 8n) + BigInt(byte);
+  }
+  return result;
+}
 
 /**
  * Check if a value is an integer or a bigint.
@@ -105800,7 +105808,11 @@ function client_setGenerator(parent, rawEncode, rawDecode) {
       src_client_classPrivateFieldInitSpec(this, _map, void 0);
       src_client_defineProperty_0(this, Symbol.toStringTag, `${parent.name}Set`);
       src_client_classPrivateFieldSet(_map, this, new Map());
-      src_client_classPrivateFieldSet(_set, this, new Set(data.map(item => encode(item, src_client_classPrivateFieldGet(_map, this)))));
+      src_client_classPrivateFieldSet(_set, this, new Set());
+      // Use a loop since data could be an Iterable not always an array
+      for (const item of data) {
+        src_client_classPrivateFieldGet(_set, this).add(encode(item, src_client_classPrivateFieldGet(_map, this)));
+      }
     }
 
     // Fit with new JS spec
@@ -113820,7 +113832,11 @@ class client_ValidateASN1 {
    * Given a schema, validate the ASN.1 object against it and return the
    * object as the validated type
    */
-  static againstSchema(input, schema) {
+  static againstSchema(input, schemaIn) {
+    let schema = schemaIn;
+    if (typeof schema === 'function') {
+      schema = schema();
+    }
     let needsMoreAnalysis = false;
     if (client_util.types.isDate(input) && schema === client_ValidateASN1.IsDate) {
       /* XXX:TODO */
@@ -114303,6 +114319,12 @@ const client_baseValidationConfig = {
     },
     supply: {
       maxValue: 10n ** 200n - 1n
+    },
+    blockSignerCount: {
+      maxValue: 16n
+    },
+    blockSignerDepth: {
+      maxValue: 3n
     }
   },
   permissions: {
@@ -114618,6 +114640,7 @@ var client_BaseFlag = /*#__PURE__*/function (BaseFlag) {
   BaseFlag[BaseFlag["PERMISSION_DELEGATE_ADD"] = 11] = "PERMISSION_DELEGATE_ADD";
   BaseFlag[BaseFlag["PERMISSION_DELEGATE_REMOVE"] = 12] = "PERMISSION_DELEGATE_REMOVE";
   BaseFlag[BaseFlag["MANAGE_CERTIFICATE"] = 13] = "MANAGE_CERTIFICATE";
+  BaseFlag[BaseFlag["MULTISIG_SIGNER"] = 14] = "MULTISIG_SIGNER";
   return BaseFlag;
 }(client_BaseFlag || {});
 /**
@@ -114631,6 +114654,8 @@ var client_BasePermissionGroup = /*#__PURE__*/function (BasePermissionGroup) {
   BasePermissionGroup[BasePermissionGroup["NETWORK"] = 3] = "NETWORK";
   BasePermissionGroup[BasePermissionGroup["TOKEN"] = 4] = "TOKEN";
   BasePermissionGroup[BasePermissionGroup["STORAGE"] = 5] = "STORAGE";
+  BasePermissionGroup[BasePermissionGroup["NONIDENTIFIER_OR_MULTISIG"] = 6] = "NONIDENTIFIER_OR_MULTISIG";
+  BasePermissionGroup[BasePermissionGroup["MULTISIG"] = 7] = "MULTISIG";
   return BasePermissionGroup;
 }(client_BasePermissionGroup || {});
 const client_basePermissionRules = {
@@ -114717,6 +114742,12 @@ const client_basePermissionRules = {
     entity: client_BasePermissionGroup.ANY,
     principal: client_BasePermissionGroup.ANY,
     target: client_BasePermissionGroup.NEVER
+  },
+  MULTISIG_SIGNER: {
+    canBeDefault: false,
+    entity: client_BasePermissionGroup.MULTISIG,
+    principal: client_BasePermissionGroup.NONIDENTIFIER_OR_MULTISIG,
+    target: client_BasePermissionGroup.NEVER
   }
 };
 const client_basePermissionSetOffsets = {};
@@ -114864,15 +114895,19 @@ class src_client_BaseSet extends client_PermissionSetHolder {
         // Multisig addresses can sign anywhere a keyed account can.
         return account.isAccount() || account.isMultisig();
       case src_client_BaseSet.BasePermissionGroup.NETWORK:
-        return keyType === client_account_AccountKeyAlgorithm.NETWORK;
+        return keyType === client_AccountKeyAlgorithm.NETWORK;
       case src_client_BaseSet.BasePermissionGroup.TOKEN:
-        return keyType === client_account_AccountKeyAlgorithm.TOKEN;
+        return keyType === client_AccountKeyAlgorithm.TOKEN;
       case src_client_BaseSet.BasePermissionGroup.STORAGE:
-        return keyType === client_account_AccountKeyAlgorithm.STORAGE;
+        return keyType === client_AccountKeyAlgorithm.STORAGE;
       case src_client_BaseSet.BasePermissionGroup.ANY:
         return true;
       case src_client_BaseSet.BasePermissionGroup.NEVER:
         return false;
+      case src_client_BaseSet.BasePermissionGroup.NONIDENTIFIER_OR_MULTISIG:
+        return account.isAccount() || account.isMultisig();
+      case src_client_BaseSet.BasePermissionGroup.MULTISIG:
+        return account.isMultisig();
     }
     return false;
   }
@@ -115164,7 +115199,7 @@ function client_block_toPrimitive(t, r) { if ("object" != typeof t || !t) return
 
 
 const client_BlockErrorType = 'BLOCK';
-const client_BlockErrorCodes = ['INVALID_TYPE', 'INVALID_VERSION', 'NO_MULTIPLE_SET_REP', 'IDENTIFIER_NEED_DEFAULT_PERMISSIONS', 'CANNOT_SEND_NON_TOKEN', 'TOKEN_RECEIVE_DIFFERS', 'ONLY_TOKEN_OP', 'ONLY_IDENTIFIER_OP', 'NO_TOKEN_OP', 'NO_IDENTIFIER_OP', 'NO_MULTISIG_OP', 'IDENTIFIER_INVALID', 'GENERAL_FIELD_INVALID', 'PERMISSIONS_INVALID_DEFAULT', 'PERMISSIONS_INVALID_ENTITY', 'PERMISSIONS_INVALID_PRINCIPAL', 'PERMISSIONS_INVALID_TARGET', 'INVALID_ACCOUNT_TYPE', 'NO_ADMIN_ON_TARGET', 'PREVIOUS_SELF', 'NO_DELEGATE_ADMIN', 'NO_MODIFY_PERMISSION_DUPE', 'CANNOT_FORWARD_TO_SELF', 'EXACT_TRUE_WHEN_FORWARDING', 'CERTIFICATE_SUBJECT_MISMATCH', 'NO_DUPLICATE_CERTIFICATE_OPERATION', 'INTERMEDIATE_CERTIFICATES_ONLY_ADD', 'INVALID_CERTIFICATE_VALUE', 'EXTERNAL_TOO_LONG', 'EXTERNAL_INVALID', 'EXTERNAL_MISSING', 'SUPPLY_INVALID'];
+const client_BlockErrorCodes = ['INVALID_TYPE', 'INVALID_VERSION', 'NO_MULTIPLE_SET_REP', 'IDENTIFIER_NEED_DEFAULT_PERMISSIONS', 'CANNOT_SEND_NON_TOKEN', 'TOKEN_RECEIVE_DIFFERS', 'ONLY_TOKEN_OP', 'ONLY_IDENTIFIER_OP', 'NO_TOKEN_OP', 'NO_IDENTIFIER_OP', 'INVALID_SIGNER', 'INVALID_PURPOSE_VALIDATION', 'INVALID_MULTISIG_QUORUM', 'INVALID_MULTISIG_SIGNER_DEPTH', 'INVALID_MULTISIG_SIGNER_COUNT', 'INVALID_MULTISIG_SIGNER_DUPLICATE', 'INVALID_CREATE_IDENTIFIER_ARGS', 'NO_MULTISIG_OP', 'IDENTIFIER_INVALID', 'GENERAL_FIELD_INVALID', 'PERMISSIONS_INVALID_DEFAULT', 'PERMISSIONS_INVALID_ENTITY', 'PERMISSIONS_INVALID_PRINCIPAL', 'PERMISSIONS_INVALID_TARGET', 'INVALID_ACCOUNT_TYPE', 'NO_ADMIN_ON_TARGET', 'PREVIOUS_SELF', 'NO_DELEGATE_ADMIN', 'NO_MODIFY_PERMISSION_DUPE', 'CANNOT_FORWARD_TO_SELF', 'EXACT_TRUE_WHEN_FORWARDING', 'CERTIFICATE_SUBJECT_MISMATCH', 'NO_DUPLICATE_CERTIFICATE_OPERATION', 'INTERMEDIATE_CERTIFICATES_ONLY_ADD', 'INVALID_CERTIFICATE_VALUE', 'EXTERNAL_TOO_LONG', 'EXTERNAL_INVALID', 'EXTERNAL_MISSING', 'SUPPLY_INVALID'];
 class src_client_KeetaNetBlockError extends src_client_KeetaNetError {
   constructor(code, message) {
     super(code, message, {
@@ -115420,18 +115455,51 @@ function client_fromDNSequenceToString(dn) {
   const retval = parts.join(', ');
   return retval;
 }
+const client_defaultHashName = client_HashFunctionName;
 var client_params = /*#__PURE__*/new WeakMap();
 class client_CertificateBuilder {
   constructor(params) {
     client_certificate_classPrivateFieldInitSpec(this, client_params, void 0);
     client_certificate_classPrivateFieldSet(client_params, this, {
-      hashLib: {
-        hash: client_hash_Hash,
-        name: client_HashFunctionName
-      },
       ...params
     });
   }
+  static hashName(params, purpose) {
+    var _params$hashParams$de, _params$hashParams;
+    const hashLib = params.hashLib;
+    if (hashLib !== undefined) {
+      switch (hashLib.name) {
+        case 'sha256':
+        case 'sha3-256':
+          return hashLib.name;
+        default:
+          throw new 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;
+    return hashName;
+  }
+  static hash(params, purpose) {
+    var _params$hashParams$fu;
+    /*
+     * If the deprecated hashLib parameter is set, then use it
+     * regardless of the algo parameter for backwards compatibility
+     * even though it is not recommended to use it anymore
+     */
+    const hashLib = params.hashLib;
+    for (var _len = arguments.length, data = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      data[_key - 2] = arguments[_key];
+    }
+    if (hashLib !== undefined) {
+      return hashLib.hash(...data);
+    }
+    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}"`);
+    }
+    return hashFunction(...data);
+  }
 
   /**
    * Construct an extension
@@ -115451,12 +115519,8 @@ class client_CertificateBuilder {
   /**
    * Convert a KeetaNet Account to a Key ID (for Subject Key Identifier)
    */
-  accountToKeyId(account) {
-    const hashLib = client_certificate_classPrivateFieldGet(client_params, this).hashLib;
-    if (hashLib === undefined) {
-      throw new Error('"hashLib" not set');
-    }
-    return client_certificate_Buffer.from(hashLib.hash(client_certificate_Buffer.concat([client_certificate_Buffer.from('KeetaKey', 'utf-8'), account.publicKeyAndType]), 20));
+  accountToKeyId(params, account, purpose) {
+    return client_certificate_Buffer.from(client_CertificateBuilder.hash(params, purpose, client_certificate_Buffer.concat([client_certificate_Buffer.from('KeetaKey', 'utf-8'), account.publicKeyAndType]), 20));
   }
 
   /**
@@ -115497,13 +115561,14 @@ class client_CertificateBuilder {
 
     /* Common Extensions */
     extensions.push(/** Extension: Authority Key Identifier */
-    client_CertificateBuilder.extension('2.5.29.35', [{
+    client_CertificateBuilder.extension('2.5.29.35', [/** XXX:TODO: Copy the key ID from the issuer certificate's Subject Key Identifier if known */
+    {
       type: 'context',
       value: 0,
       kind: 'implicit',
-      contains: this.accountToKeyId(params.issuer)
+      contains: this.accountToKeyId(params, params.issuer, 'aki')
     }]), /** Extension: Subject Key Identifier */
-    client_CertificateBuilder.extension('2.5.29.14', this.accountToKeyId(params.subjectPublicKey)));
+    client_CertificateBuilder.extension('2.5.29.14', this.accountToKeyId(params, params.subjectPublicKey, 'ski')));
     return extensions;
   }
 
@@ -115511,9 +115576,29 @@ class client_CertificateBuilder {
    * Compute the final params as required
    */
   getFinalParams(params) {
+    var _classPrivateFieldGet2, _classPrivateFieldGet3, _params$hashParams2, _classPrivateFieldGet4, _params$hashParams3;
     const finalParams = {
       ...client_certificate_classPrivateFieldGet(client_params, this),
-      ...params
+      ...params,
+      hashParams: {
+        ...((_classPrivateFieldGet2 = client_certificate_classPrivateFieldGet(client_params, this)) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.hashParams),
+        ...(params === null || params === void 0 ? void 0 : params.hashParams),
+        functions: {
+          'sha256': function (data, len) {
+            throw new Error('not implemented, please provide an implementation');
+          },
+          [client_defaultHashName]: client_hash_Hash,
+          ...((_classPrivateFieldGet3 = client_certificate_classPrivateFieldGet(client_params, this)) === null || _classPrivateFieldGet3 === void 0 || (_classPrivateFieldGet3 = _classPrivateFieldGet3.hashParams) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.functions),
+          ...(params === null || params === void 0 || (_params$hashParams2 = params.hashParams) === null || _params$hashParams2 === void 0 ? void 0 : _params$hashParams2.functions)
+        },
+        defaults: {
+          signature: client_defaultHashName,
+          ski: client_defaultHashName,
+          aki: client_defaultHashName,
+          ...((_classPrivateFieldGet4 = client_certificate_classPrivateFieldGet(client_params, this)) === null || _classPrivateFieldGet4 === void 0 || (_classPrivateFieldGet4 = _classPrivateFieldGet4.hashParams) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.defaults),
+          ...(params === null || params === void 0 || (_params$hashParams3 = params.hashParams) === null || _params$hashParams3 === void 0 ? void 0 : _params$hashParams3.defaults)
+        }
+      }
     };
 
     /* Validate that required parameters are set */
@@ -115538,8 +115623,9 @@ class client_CertificateBuilder {
       throw new Error('"serialNumber" not set');
     }
     const hashLib = finalParams.hashLib;
-    if (hashLib === undefined) {
-      throw new Error('"hashLib" not set');
+    const hashParams = finalParams.hashParams;
+    if (hashParams === undefined) {
+      throw new Error('"hashParams" not set');
     }
     return {
       ...finalParams,
@@ -115548,7 +115634,8 @@ class client_CertificateBuilder {
       validFrom,
       validTo,
       serial,
-      hashLib
+      hashLib,
+      hashParams
     };
   }
 
@@ -115557,19 +115644,19 @@ class client_CertificateBuilder {
    */
   async buildDER(params) {
     const finalParams = this.getFinalParams(params);
-    const hashLib = finalParams.hashLib;
     const {
       oid: signatureAlgorithmOID,
       hashData: hashData
     } = function () {
+      const hashName = client_CertificateBuilder.hashName(finalParams, 'signature');
       switch (finalParams.issuer.keyType) {
-        case client_account_AccountKeyAlgorithm.ECDSA_SECP256K1:
-        case client_account_AccountKeyAlgorithm.ECDSA_SECP256R1:
+        case client_AccountKeyAlgorithm.ECDSA_SECP256K1:
+        case client_AccountKeyAlgorithm.ECDSA_SECP256R1:
           return {
-            oid: `${hashLib.name}WithEcDSA`,
+            oid: `${hashName}WithEcDSA`,
             hashData: true
           };
-        case client_account_AccountKeyAlgorithm.ED25519:
+        case client_AccountKeyAlgorithm.ED25519:
           return {
             oid: 'ed25519',
             hashData: false
@@ -115646,7 +115733,7 @@ class client_CertificateBuilder {
      */
     let toSign;
     if (hashData) {
-      toSign = client_certificate_Buffer.from(hashLib.hash(tbsCertificateBuffer));
+      toSign = client_certificate_Buffer.from(client_CertificateBuilder.hash(finalParams, 'signature', tbsCertificateBuffer));
     } else {
       toSign = tbsCertificateBuffer;
     }
@@ -116274,6 +116361,19 @@ class src_client_Certificate {
     }
     return issuerCert.subjectPublicKey;
   }
+
+  /**
+   * Get the extensions present in the certificate -- this is the raw
+   * extensions as they were parsed from the certificate, and may
+   * contain extensions that are not processed by this class.
+   */
+  getExtensions() {
+    this.assertConstructed();
+    if (client_certificate_classPrivateFieldGet(client_extensionsRaw, this) === undefined) {
+      return undefined;
+    }
+    return client_certificate_classPrivateFieldGet(client_extensionsRaw, this);
+  }
   assertConstructed() {
     if (!client_certificate_classPrivateFieldGet(client_finalizeConstructionCalled, this)) {
       throw new Error('finalizeConstruction not called');
@@ -116618,7 +116718,9 @@ 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'];
+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',
+// 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 {
   constructor(code, message) {
     let shouldRetry = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
@@ -116647,6 +116749,7 @@ function client_common_assertClassBrand(e, t, n) { if ("function" == typeof e ?
 
 
 
+
 function client_findPermissionMatch(lookingFor, entries) {
   const {
     principal,
@@ -116685,6 +116788,23 @@ function client_validateSupply(amount, network) {
     throw new src_client_KeetaNetBlockError('BLOCK_SUPPLY_INVALID', `supply does not fit proper format -- GOT: '${amount}' MaxValue: ${maxValue}`);
   }
 }
+function client_validateBlockSignerCount(amount, network) {
+  const {
+    maxValue
+  } = client_getValidation(network).accountInfoFieldRules['blockSignerCount'];
+  if (amount > maxValue || amount < 1n) {
+    throw new src_client_KeetaNetBlockError('BLOCK_INVALID_MULTISIG_SIGNER_COUNT', `signer count does not fit proper format -- GOT: '${amount}' MaxValue: ${maxValue}`);
+  }
+}
+function client_validateBlockSignerDepth(depth, network) {
+  const {
+    maxValue
+  } = client_getValidation(network).accountInfoFieldRules['blockSignerDepth'];
+  if (depth > maxValue) {
+    throw new src_client_KeetaNetBlockError('BLOCK_INVALID_MULTISIG_SIGNER_DEPTH', `signer depth does not fit proper format -- GOT: '${depth}' MaxValue: ${maxValue}`);
+  }
+}
+
 /**
  * Compute effects on the ledger from block effects
  */
@@ -116791,7 +116911,7 @@ async function client_computeLedgerEffect(options, effects, storageProvider, net
           set,
           value
         } = balanceUpdate;
-        const token = client_lib_account.fromPublicKeyString(tokenPubKey).assertKeyType(client_account_AccountKeyAlgorithm.TOKEN);
+        const token = client_lib_account.fromPublicKeyString(tokenPubKey).assertKeyType(client_AccountKeyAlgorithm.TOKEN);
         if (rollingChanges[tokenPubKey] === undefined) {
           rollingChanges[tokenPubKey] = 0n;
         }
@@ -116967,7 +117087,7 @@ async function client_computeLedgerEffect(options, effects, storageProvider, net
     const receivable = {};
     for (const tokenPubKey in (_fields$balance3 = fields.balance) !== null && _fields$balance3 !== void 0 ? _fields$balance3 : {}) {
       var _fields$balance3;
-      const tokenAcct = client_lib_account.fromPublicKeyString(tokenPubKey).assertKeyType(client_account_AccountKeyAlgorithm.TOKEN);
+      const tokenAcct = client_lib_account.fromPublicKeyString(tokenPubKey).assertKeyType(client_AccountKeyAlgorithm.TOKEN);
       for (const balanceUpdate of ((_fields$balance4 = fields.balance) !== null && _fields$balance4 !== void 0 ? _fields$balance4 : {})[tokenPubKey]) {
         var _fields$balance4;
         const {
@@ -117209,19 +117329,25 @@ class client_LedgerStorageBase {
       }
       ret.defaultPermission = new Permissions(baseSet, externalSet);
     }
-    if (account.keyType === AccountKeyAlgorithm.TOKEN) {
+    if (account.isToken()) {
       var _row$supply;
       ret.supply = BigInt((_row$supply = row.supply) !== null && _row$supply !== void 0 ? _row$supply : 0);
     }
+    if (account.isMultisig() && row.multisigQuorum !== undefined) {
+      ret.multisigQuorum = BigInt(row.multisigQuorum);
+    }
     return ret;
   }
   _validateAccountInfoKeys(account, info) {
     const validKeys = ['name', 'description', 'metadata'];
     if (account.isIdentifier()) {
       validKeys.push('defaultPermission');
-    }
-    if (account.keyType === AccountKeyAlgorithm.TOKEN) {
-      validKeys.push('supply');
+      if (account.isToken()) {
+        validKeys.push('supply');
+      }
+      if (account.isMultisig()) {
+        validKeys.push('multisigQuorum');
+      }
     }
     const keys = Object.keys(info);
     const foundBannedKey = keys.find(function (key) {
@@ -117231,6 +117357,36 @@ class client_LedgerStorageBase {
       throw new KeetaNetLedgerError('LEDGER_INVALID_ACCOUNT_INFO_KEY', `Invalid AccountInfo field ${foundBannedKey}`);
     }
   }
+
+  /**
+   * @param moment - The date to use as the base for the timestamp.
+   * @param momentBits - The number of bits to use for the timestamp
+   * @param totalLength - The total length of the generated number in bits
+   * @param randomData - A hexadecimal string to use as the random data.
+   * @param timestampFuzzMS - The number of milliseconds to fuzz the timestamp by, defaults to 1n (precise).
+   * @param optimistic - If true, the timestamp will be incremented by 1 quanta, defaults to false.
+   * @returns A bigint representing the noisy timestamp.
+   */
+  _generateNoisyTimestamp(moment, momentBits, totalLength, randomData) {
+    let timestampFuzzMS = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
+    let optimistic = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
+    if (timestampFuzzMS > Number.MAX_SAFE_INTEGER) {
+      throw new Error('timestampFuzzMs is too large');
+    }
+    const timestampFuzz = BigInt(Math.ceil(Math.log2(Number(timestampFuzzMS))));
+    const length = totalLength - momentBits;
+    if (BigInt(randomData.length * 8) < length + timestampFuzz) {
+      throw new Error('randomData is too short for the specified bit length');
+    }
+    if (length < 0n) {
+      throw new Error('momentBits should be less than totalLength');
+    }
+    const timestamp = BigInt(moment.valueOf()) >> timestampFuzz;
+    const mask = (1n << length + timestampFuzz) - 1n;
+    const upperBits = timestamp + (optimistic ? 1n : 0n) << length + timestampFuzz;
+    const lowerBits = bufferToBigInt(randomData) & mask;
+    return upperBits | lowerBits;
+  }
   async getHeadBlock(transaction, account, from) {
     const response = await this.getHeadBlocks(transaction, [account], from);
     const pubKey = account.publicKeyString.get();
@@ -117248,8 +117404,9 @@ class client_LedgerStorageBase {
     return null;
   }
   async gc(transaction) {
+    let timeLimitMS = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 280000;
     let lastGCResult = false;
-    for (const startTime = Date.now(); Date.now() - startTime < 280000;) {
+    for (const startTime = Date.now(); Date.now() - startTime < timeLimitMS;) {
       const gcResult = await this.gcBatch(transaction);
       lastGCResult = gcResult;
       if (!gcResult) {
@@ -117295,7 +117452,6 @@ function client_operations_toPrimitive(t, r) { if ("object" != typeof t || !t) r
 
 
 
-
 /**
  * All supported operations
  */
@@ -117422,6 +117578,20 @@ const client_BlockOperationASN1SchemaBase = {
   'CREATE_IDENTIFIER': [{
     name: 'identifier',
     schema: client_ValidateASN1.IsOctetString
+  }, {
+    name: 'createArguments',
+    schema: {
+      optional: {
+        choice: [{
+          type: 'context',
+          kind: 'explicit',
+          value: 7,
+          contains: [{
+            sequenceOf: client_ValidateASN1.IsOctetString
+          }, client_ValidateASN1.IsInteger]
+        }]
+      }
+    }
   }],
   'TOKEN_ADMIN_SUPPLY': [{
     name: 'amount',
@@ -117557,10 +117727,10 @@ class src_client_BlockOperationSEND extends src_client_BlockOperation {
     const account = block.account;
 
     // Only allow tokens to use send if they are the token being sent
-    if (account.keyType === client_account_AccountKeyAlgorithm.TOKEN && this.token.comparePublicKey(account) === false) {
+    if (account.keyType === client_AccountKeyAlgorithm.TOKEN && this.token.comparePublicKey(account) === false) {
       throw new src_client_KeetaNetBlockError('BLOCK_NO_TOKEN_OP', 'Tokens cannot use SEND, did you mean to use TOKEN_ADMIN_MODIFY_BALANCE');
     }
-    if (this.to.keyType === client_account_AccountKeyAlgorithm.TOKEN) {
+    if (this.to.keyType === client_AccountKeyAlgorithm.TOKEN) {
       // Note: This will fail if you are sending the base token to the base token, without specifying the token in operation
       if (this.to.comparePublicKey(this.token) === false) {
         throw new src_client_KeetaNetBlockError('BLOCK_TOKEN_RECEIVE_DIFFERS', 'Cannot send a token to a token account that is different from itself, if this is invalid, please include the token in the operation');
@@ -117596,10 +117766,10 @@ class src_client_BlockOperationSEND extends src_client_BlockOperation {
 client_BlockOperationSEND = src_client_BlockOperationSEND;
 function client_computeToken(token) {
   const asAccount = this.computeTo(token);
-  if (asAccount.keyType !== client_account_AccountKeyAlgorithm.TOKEN) {
+  if (asAccount.keyType !== client_AccountKeyAlgorithm.TOKEN) {
     throw new src_client_KeetaNetBlockError('BLOCK_CANNOT_SEND_NON_TOKEN', 'You cannot send a non token identifier');
   }
-  return asAccount.assertKeyType(client_account_AccountKeyAlgorithm.TOKEN);
+  return asAccount.assertKeyType(client_AccountKeyAlgorithm.TOKEN);
 }
 client_operations_defineProperty(src_client_BlockOperationSEND, "isInstance", client_checkableGenerator(client_BlockOperationSEND));
 var client_amount2 = /*#__PURE__*/new WeakMap();
@@ -117750,7 +117920,7 @@ class src_client_BlockOperationTOKEN_ADMIN_MODIFY_BALANCE extends src_client_Blo
     const {
       block
     } = context;
-    if (block.account.keyType === client_account_AccountKeyAlgorithm.TOKEN) {
+    if (block.account.keyType === client_AccountKeyAlgorithm.TOKEN) {
       throw new src_client_KeetaNetBlockError('BLOCK_NO_TOKEN_OP', 'You cannot use TOKEN_ADMIN_MODIFY_BALANCE on a token account');
     }
   }
@@ -117769,7 +117939,7 @@ class src_client_BlockOperationTOKEN_ADMIN_MODIFY_BALANCE extends src_client_Blo
  */
 client_BlockOperationTOKEN_ADMIN_MODIFY_BALANCE = src_client_BlockOperationTOKEN_ADMIN_MODIFY_BALANCE;
 function client_computeToken3(token) {
-  return client_lib_account.toAccount(token).assertKeyType(client_account_AccountKeyAlgorithm.TOKEN);
+  return client_lib_account.toAccount(token).assertKeyType(client_AccountKeyAlgorithm.TOKEN);
 }
 client_operations_defineProperty(src_client_BlockOperationTOKEN_ADMIN_MODIFY_BALANCE, "isInstance", client_checkableGenerator(client_BlockOperationTOKEN_ADMIN_MODIFY_BALANCE));
 var client_to2 = /*#__PURE__*/new WeakMap();
@@ -117824,17 +117994,20 @@ class src_client_BlockOperationSET_REP extends src_client_BlockOperation {
 client_BlockOperationSET_REP = src_client_BlockOperationSET_REP;
 client_operations_defineProperty(src_client_BlockOperationSET_REP, "isInstance", client_checkableGenerator(client_BlockOperationSET_REP));
 var client_identifier = /*#__PURE__*/new WeakMap();
+var client_createArguments = /*#__PURE__*/new WeakMap();
 var client_BlockOperationCREATE_IDENTIFIER_brand = /*#__PURE__*/new WeakSet();
 class src_client_BlockOperationCREATE_IDENTIFIER extends src_client_BlockOperation {
-  constructor(input) {
+  constructor(_input) {
     super();
     client_operations_classPrivateMethodInitSpec(this, client_BlockOperationCREATE_IDENTIFIER_brand);
     client_operations_defineProperty(this, "type", client_OperationType.CREATE_IDENTIFIER);
     client_operations_classPrivateFieldInitSpec(this, client_identifier, void 0);
-    if (input.type !== client_OperationType.CREATE_IDENTIFIER) {
+    client_operations_classPrivateFieldInitSpec(this, client_createArguments, void 0);
+    if (_input.type !== client_OperationType.CREATE_IDENTIFIER) {
       throw new src_client_KeetaNetBlockError('BLOCK_INVALID_TYPE', 'Invalid construction of BlockOperationCREATE_IDENTIFIER');
     }
-    client_operations_classPrivateFieldSet(client_identifier, this, client_operations_assertClassBrand(client_BlockOperationCREATE_IDENTIFIER_brand, this, client_computeIdentifier).call(this, input.identifier));
+    client_operations_classPrivateFieldSet(client_identifier, this, client_operations_assertClassBrand(client_BlockOperationCREATE_IDENTIFIER_brand, this, client_computeIdentifier).call(this, _input.identifier));
+    client_operations_classPrivateFieldSet(client_createArguments, this, client_operations_assertClassBrand(client_BlockOperationCREATE_IDENTIFIER_brand, this, client_computeCreateArguments).call(this, _input.createArguments));
   }
   set identifier(identifier) {
     client_operations_classPrivateFieldSet(client_identifier, this, client_operations_assertClassBrand(client_BlockOperationCREATE_IDENTIFIER_brand, this, client_computeIdentifier).call(this, identifier));
@@ -117842,6 +118015,12 @@ class src_client_BlockOperationCREATE_IDENTIFIER extends src_client_BlockOperati
   get identifier() {
     return client_operations_classPrivateFieldGet(client_identifier, this);
   }
+  set createArguments(input) {
+    client_operations_classPrivateFieldSet(client_createArguments, this, client_operations_assertClassBrand(client_BlockOperationCREATE_IDENTIFIER_brand, this, client_computeCreateArguments).call(this, input));
+  }
+  get createArguments() {
+    return client_operations_classPrivateFieldGet(client_createArguments, this);
+  }
   validate(context) {
     const {
       block,
@@ -117858,11 +118037,38 @@ class src_client_BlockOperationCREATE_IDENTIFIER extends src_client_BlockOperati
     if (this.identifier.comparePublicKey(validIdentifier) === false) {
       throw new src_client_KeetaNetBlockError('BLOCK_IDENTIFIER_INVALID', 'Requested token identifier is not valid');
     }
+    const keyTypesArgumentsRequired = [client_AccountKeyAlgorithm.MULTISIG];
+    const shouldHaveCreateArguments = keyTypesArgumentsRequired.includes(this.identifier.keyType);
+    if (this.createArguments !== undefined !== shouldHaveCreateArguments) {
+      throw new src_client_KeetaNetBlockError('BLOCK_INVALID_CREATE_IDENTIFIER_ARGS', `Create arguments set/unset when should not be for key type ${this.identifier.keyType}`);
+    }
+    if (client_operations_classPrivateFieldGet(client_createArguments, this)) {
+      if (!client_operations_classPrivateFieldGet(client_identifier, this).isKeyType(client_operations_classPrivateFieldGet(client_createArguments, this).type)) {
+        throw new src_client_KeetaNetBlockError('BLOCK_INVALID_CREATE_IDENTIFIER_ARGS', 'Invalid create arguments for key type');
+      }
+      if (client_operations_classPrivateFieldGet(client_createArguments, this).type === client_AccountKeyAlgorithm.MULTISIG) {
+        const {
+          signers,
+          quorum
+        } = client_operations_classPrivateFieldGet(client_createArguments, this);
+        client_validateBlockSignerCount(BigInt(signers.length), block.network);
+        const signerSet = new client_lib_account.Set(signers);
+        if (signerSet.size !== signers.length) {
+          throw new src_client_KeetaNetBlockError('BLOCK_INVALID_MULTISIG_SIGNER_DUPLICATE', `Duplicate signer found`);
+        }
+        if (quorum < 1n || quorum > signerSet.size) {
+          throw new src_client_KeetaNetBlockError('BLOCK_INVALID_MULTISIG_QUORUM', `Quorum must be between [1, ${signerSet.size}], got ${quorum}`);
+        }
+      } else {
+        throw new Error('Unrecognized createArguments type');
+      }
+    }
   }
   toJSON() {
     return {
       type: this.type,
-      identifier: this.identifier
+      identifier: this.identifier,
+      createArguments: client_operations_classPrivateFieldGet(client_createArguments, this)
     };
   }
 }
@@ -117873,16 +118079,31 @@ class src_client_BlockOperationCREATE_IDENTIFIER extends src_client_BlockOperati
 client_BlockOperationCREATE_IDENTIFIER = src_client_BlockOperationCREATE_IDENTIFIER;
 function client_computeIdentifier(identifierStr) {
   const account = this.computeTo(identifierStr, true);
-  if (account.keyType === client_account_AccountKeyAlgorithm.NETWORK) {
+  if (account.keyType === client_AccountKeyAlgorithm.NETWORK) {
     throw new Error('BlockOperationCREATE_IDENTIFIER must have a non-network identifier account');
   }
-
-  // XXX:TODO Remove this once multisig account metadata is done
-  if (account.keyType === client_account_AccountKeyAlgorithm.MULTISIG) {
-    throw new Error('Multisig accounts currently not supported');
-  }
   return account;
 }
+function client_computeCreateArguments(input) {
+  if (input === undefined) {
+    return undefined;
+  }
+  if (input.type === client_AccountKeyAlgorithm.MULTISIG) {
+    return {
+      type: client_AccountKeyAlgorithm.MULTISIG,
+      quorum: BigInt(input.quorum),
+      signers: input.signers.map(function (signerInput) {
+        const signer = client_lib_account.toAccount(signerInput);
+        if (!signer.isMultisig() && !signer.isAccount()) {
+          throw new src_client_KeetaNetBlockError('BLOCK_INVALID_CREATE_IDENTIFIER_ARGS', 'Unsupported key type for multisig signer');
+        }
+        return signer;
+      })
+    };
+  } else {
+    throw new src_client_KeetaNetBlockError('BLOCK_INVALID_CREATE_IDENTIFIER_ARGS', 'Unsupported key type for identifier creation args');
+  }
+}
 client_operations_defineProperty(src_client_BlockOperationCREATE_IDENTIFIER, "isInstance", client_checkableGenerator(client_BlockOperationCREATE_IDENTIFIER));
 var client_name = /*#__PURE__*/new WeakMap();
 var client_description = /*#__PURE__*/new WeakMap();
@@ -118166,7 +118387,7 @@ class src_client_BlockOperationTOKEN_ADMIN_SUPPLY extends src_client_BlockOperat
     const {
       block
     } = context;
-    if (block.account.keyType !== client_account_AccountKeyAlgorithm.TOKEN) {
+    if (block.account.keyType !== client_AccountKeyAlgorithm.TOKEN) {
       throw new src_client_KeetaNetBlockError('BLOCK_ONLY_TOKEN_OP', 'Only token accounts can use TOKEN_ADMIN_SUPPLY');
     }
     client_validateSupply(client_operations_classPrivateFieldGet(client_amount4, this), block.network);
@@ -118185,7 +118406,7 @@ class src_client_BlockOperationTOKEN_ADMIN_SUPPLY extends src_client_BlockOperat
  */
 client_BlockOperationTOKEN_ADMIN_SUPPLY = src_client_BlockOperationTOKEN_ADMIN_SUPPLY;
 function client_computeSupplyMethod(method) {
-  const numericMethod = client_assertAdjustMethod(method, true);
+  const numericMethod = client_toAdjustMethod(method);
   if (numericMethod === client_lib_block.AdjustMethod.SET) {
     throw new Error('Cannot use AdjustMethod.SET on a TOKEN_ADMIN_SUPPLY operation');
   }
@@ -118347,7 +118568,7 @@ function client_asIntermediateCertificates(bundle) {
   return bundleObject;
 }
 function client_computeCertificateMethod(method) {
-  const numericMethod = client_assertAdjustMethod(method, true);
+  const numericMethod = client_toAdjustMethod(method);
   if (numericMethod === client_lib_block.AdjustMethod.SET) {
     throw new Error('Cannot use AdjustMethod.SET on a MANAGE_CERTIFICATE operation.');
   }
@@ -118414,11 +118635,27 @@ function client_ExportBlockOperations(operations) {
     // We want to be able to read any key on the operation, so we need to cast it to any
     const unTypedEntry = entry;
     for (const {
-      name: key
+      name: key,
+      schema
     } of operationSchema) {
       let valueToWrite = unTypedEntry[key];
       if (valueToWrite === undefined) {
+        if (typeof schema === 'object' && schema && !('optional' in schema)) {
+          throw new Error(`Key ${key} for operation ${typeStr} is not optional but undefined value provided`);
+        }
         continue;
+      } else if (typeStr === 'CREATE_IDENTIFIER' && key === 'createArguments') {
+        // We are checking this in other places, and if this argument changes there will be many other things that break beforehand
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const typedValue = valueToWrite;
+        valueToWrite = {
+          type: 'context',
+          kind: 'explicit',
+          value: valueToWrite.type,
+          contains: [typedValue.signers.map(function (signer) {
+            return signer.publicKeyAndType;
+          }), typedValue.quorum]
+        };
       } else if (typeof valueToWrite === 'string') {
         valueToWrite = {
           type: 'string',
@@ -118451,34 +118688,37 @@ 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 = {};
-    if (typeof entryWrapper !== 'object' || entryWrapper === null) {
-      throw new Error(`Found entry which is not a context ${String(entryWrapper)}`);
-    }
-    if (!('type' in entryWrapper) || entryWrapper.type !== 'context') {
-      throw new Error(`Found entry which is not a context ${String(entryWrapper)}`);
-    }
-    if (!('kind' in entryWrapper) || entryWrapper.kind !== 'explicit') {
-      throw new Error(`Found entry which is not an explicit context ${String(entryWrapper)}`);
-    }
-    if (!('value' in entryWrapper)) {
-      throw new Error(`Found entry which is not a numeric explicit context ${String(entryWrapper)}`);
-    }
-    const typeInput = entryWrapper.value;
-    if (typeof typeInput !== 'number') {
-      throw new Error(`Found entry which is not a numeric explicit context ${String(entryWrapper)}`);
-    }
-    const type = client_assertOperationType(typeInput);
-    if (!('contains' in entryWrapper)) {
-      throw new Error(`Found entry which which lacks contains ${JSON.stringify(entryWrapper)}`);
-    }
+    client_assertExplicitContextValueLike(entryWrapper);
+    const type = client_assertOperationType(entryWrapper.value);
     const entry = entryWrapper.contains;
-    if (!Array.isArray(entry)) {
-      throw new Error(`Found entry which is not a Sequence ${entry}`);
-    }
     const typeStr = client_operationTypeToString(type);
     const operationSchema = client_BlockOperationASN1SchemaBase[typeStr];
     if (!operationSchema) {
@@ -118506,13 +118746,28 @@ function client_ImportOperationsASN1(input, network) {
         const newKeyValue = new client_permissions_Permissions(base, external);
         newKeyValue.validate(network);
         keyValueOut = newKeyValue;
+      } else if (key === 'createArguments' && typeStr === 'CREATE_IDENTIFIER') {
+        client_assertExplicitContextValueLike(keyValueIn);
+        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])) {
+          throw new Error('Invalid createArgs container');
+        }
+        keyValueOut = {
+          type: keyValueIn.value,
+          signers: keyValueIn.contains[0].map(function (value) {
+            return client_lib_account.fromPublicKeyAndType(value);
+          }),
+          quorum: keyValueIn.contains[1]
+        };
       } else if (Array.isArray(keyValueIn) && key === 'intermediateCertificates') {
         keyValueOut = new src_client_CertificateBundle(keyValueIn.map(function (certificate) {
           return new src_client_Certificate(certificate);
         }));
       } else if (client_isBuffer(keyValueIn)) {
         if (type === client_OperationType.MANAGE_CERTIFICATE && key === 'certificateOrHash') {
-          const method = client_assertAdjustMethod(operation['method'], true);
+          const method = client_toAdjustMethod(operation['method']);
           if (method === client_AdjustMethod.SUBTRACT) {
             keyValueOut = new src_client_CertificateHash(keyValueIn);
           } else if (method === client_AdjustMethod.ADD) {
@@ -118577,17 +118832,43 @@ function client_lib_block_toPrimitive(t, r) { if ("object" != typeof t || !t) re
 
 
 
+
 const client_NO_PREVIOUS = '9bd05fa2-8e59-42a2-8153-26d8e8c10143:NO_PREVIOUS';
+let client_BlockPurpose = /*#__PURE__*/function (BlockPurpose) {
+  BlockPurpose[BlockPurpose["GENERIC"] = 0] = "GENERIC";
+  BlockPurpose[BlockPurpose["FEE"] = 1] = "FEE";
+  return BlockPurpose;
+}({});
+function client_toBlockPurpose(value) {
+  if (typeof value === 'bigint') {
+    value = Number(value);
+  }
+  if (typeof value !== 'number') {
+    throw new Error(`Invalid BlockPurpose supplied: got ${value} -- ${typeof value}`);
+  }
+
+  // We add this type assertion to make sure the switch is exhaustive
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  switch (value) {
+    case client_BlockPurpose.GENERIC:
+    case client_BlockPurpose.FEE:
+      return value;
+  }
+  throw new Error(`Invalid BlockPurpose supplied: got ${value} -- ${typeof value}`);
+}
 let client_AdjustMethod = /*#__PURE__*/function (AdjustMethod) {
   AdjustMethod[AdjustMethod["ADD"] = 0] = "ADD";
   AdjustMethod[AdjustMethod["SUBTRACT"] = 1] = "SUBTRACT";
   AdjustMethod[AdjustMethod["SET"] = 2] = "SET";
   return AdjustMethod;
 }({});
-function client_assertAdjustMethod(value, bigintOkay) {
-  if (bigintOkay && typeof value === 'bigint') {
+function client_toAdjustMethod(value) {
+  if (typeof value === 'bigint') {
     value = Number(value);
   }
+  if (typeof value !== 'number') {
+    throw new Error(`Invalid AdjustMethod supplied: got ${value} -- ${typeof value}`);
+  }
 
   // We add this type assertion to make sure the switch is exhaustive
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -118647,11 +118928,14 @@ client_lib_block_defineProperty(client_block_BlockHash, "Set", client_setGenerat
 /**
  * Output of block suitable to JSON serialization
  */
+/**
+ * Representation of the block V2
+ */
 /**
  * Map input to our values
  */
 /** @internal */
-const client_BlockASN1Schema = [0n, client_BufferStorageASN1.Validate.IsInteger, {
+const client_BlockV1ASN1Schema = [0n, client_BufferStorageASN1.Validate.IsInteger, {
   choice: [client_BufferStorageASN1.Validate.IsInteger, client_BufferStorageASN1.Validate.IsNull]
 }, {
   type: 'date',
@@ -118663,29 +118947,151 @@ const client_BlockASN1Schema = [0n, client_BufferStorageASN1.Validate.IsInteger,
     choice: Object.values(client_BlockOperationASN1Schema)
   }
 }, client_BufferStorageASN1.Validate.IsOctetString];
+const client_multisigSignerInfoASN1Schema = [client_BufferStorageASN1.Validate.IsOctetString, {
+  sequenceOf: {
+    choice: [
+    // XXX:TODO We need to use a type assertion here because the ASN1 schema does not support recursive types
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    () => client_multisigSignerInfoASN1Schema, client_BufferStorageASN1.Validate.IsOctetString]
+  }
+}];
+function client_parseBlockSignerFieldContainer(input, state) {
+  if (!state) {
+    state = {
+      depth: 0
+    };
+  } else if (state.depth > 3) {
+    throw new src_client_KeetaNetBlockError('BLOCK_INVALID_MULTISIG_SIGNER_DEPTH', 'Multisig signer depth exceeded maximum allowed depth');
+  }
+  const multisigAccount = client_lib_account.fromPublicKeyAndType(input[0]).assertKeyType(client_AccountKeyAlgorithm.MULTISIG);
+  const signers = [];
+
+  // XXX:TODO We need to use a type assertion here because the ASN1 schema does not support recursive types properly
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  for (const signer of input[1]) {
+    let parsedSigner;
+    if (client_block_Buffer.isBuffer(signer)) {
+      parsedSigner = client_lib_account.fromPublicKeyAndType(signer).assertAccount();
+    } else if (signer && Array.isArray(signer)) {
+      if (signer.length !== 2) {
+        throw new Error('Multisig signer must have two items');
+      }
+      if (!client_block_Buffer.isBuffer(signer[0])) {
+        throw new Error('Multisig signer first item must be a buffer');
+      }
+      if (!Array.isArray(signer[1])) {
+        throw new Error('Multisig signer second item must be an array');
+      }
+
+      // XXX:TODO We need to use a type assertion here because we are not asserting the type recursively
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const inner = client_parseBlockSignerFieldContainer(signer, {
+        depth: state.depth + 1
+      });
+      parsedSigner = inner.parsed;
+    } else {
+      throw new Error('Multisig signer must be a buffer or an array');
+    }
+    signers.push(parsedSigner);
+  }
+  return {
+    parsed: [multisigAccount, signers],
+    depth: state.depth
+  };
+}
+function client_getMultisigSignerContainer(input) {
+  const out = [input[0].publicKeyAndType, []];
+  for (const signer of input[1]) {
+    let parsed;
+    if (Array.isArray(signer)) {
+      parsed = client_getMultisigSignerContainer(signer);
+    } else {
+      parsed = signer.publicKeyAndType;
+    }
+    out[1].push(parsed);
+  }
+
+  // XXX:TODO We need to use a type assertion here because the ASN1 schema does not support recursive types properly
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return out;
+}
+
+/** @internal */
+const client_BlockV2ASN1Schema = {
+  type: 'context',
+  kind: 'explicit',
+  value: 1,
+  contains: [client_BufferStorageASN1.Validate.IsInteger, {
+    optional: client_BufferStorageASN1.Validate.IsInteger
+  }, {
+    type: 'date',
+    kind: 'general'
+  }, client_BufferStorageASN1.Validate.IsInteger, client_BufferStorageASN1.Validate.IsOctetString, {
+    choice: [client_BufferStorageASN1.Validate.IsNull,
+    // If principal has a private key, the signature of principal
+    client_BufferStorageASN1.Validate.IsOctetString,
+    // If principal does not have private key, list of accounts signing on behalf of principal and their signatures
+    client_multisigSignerInfoASN1Schema]
+  }, client_BufferStorageASN1.Validate.IsOctetString, {
+    sequenceOf: {
+      choice: Object.values(client_BlockOperationASN1Schema)
+    }
+  }, {
+    choice: [
+    // If principal has a private key, the signature of principal
+    client_BufferStorageASN1.Validate.IsOctetString,
+    // If principal does not have private key, list of accounts signing on behalf of principal and their signatures
+    {
+      sequenceOf: client_BufferStorageASN1.Validate.IsOctetString
+    }]
+  }]
+};
+const client_BlockASN1Schema = {
+  choice: [client_BlockV1ASN1Schema, client_BlockV2ASN1Schema]
+};
+function client_parseBlockSignerFieldJSON(input) {
+  if (!Array.isArray(input)) {
+    return client_lib_account.toAccount(input).assertAccount();
+  }
+  if (input.length !== 2) {
+    throw new Error('Multisig signer field must have two items');
+  }
+  const signer = client_lib_account.toAccount(input[0]).assertKeyType(client_AccountKeyAlgorithm.MULTISIG);
+  const innerSigners = [];
+  for (const signer of input[1]) {
+    innerSigners.push(client_parseBlockSignerFieldJSON(signer));
+  }
+  return [signer, innerSigners];
+}
 /**
  * Statically assert that the BlockASN1 type is compatible with BlockASN1Schema
  * @internal
  */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 function client_ignore_static_checks() {
+  // V1 Checks
   // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/consistent-type-assertions
-  const _ignore_check_blockasn1_forward_1 = {};
+  const _ignore_check_blockasn1v1_forward_1 = {};
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const _ignore_check_blockasn1_forward_2 = _ignore_check_blockasn1_forward_1;
+  const _ignore_check_blockasn1v1_forward_2 = _ignore_check_blockasn1v1_forward_1;
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/consistent-type-assertions
-  const _ignore_check_blockasn1_reverse_1 = {};
+  const _ignore_check_blockasn1v1_reverse_1 = {};
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const _ignore_check_blockasn1_reverse_2 = _ignore_check_blockasn1_reverse_1;
-}
-function client_assertBlockBlockCanonicalVersion(input) {
-  const expected = 1;
-  if (input !== expected) {
-    throw new Error('Invalid block version');
-  }
+  const _ignore_check_blockasn1v1_reverse_2 = _ignore_check_blockasn1v1_reverse_1;
+
+  // V2 Checks
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/consistent-type-assertions
+  const _ignore_check_blockasn1v2_forward_1 = {};
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const _ignore_check_blockasn1v2_forward_2 = _ignore_check_blockasn1v2_forward_1;
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/consistent-type-assertions
+  const _ignore_check_blockasn1v2_reverse_1 = {};
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const _ignore_check_blockasn1v2_reverse_2 = _ignore_check_blockasn1v2_reverse_1;
 }
-function client_MapInputValues(input) {
+function client_MapV1InputValues(input) {
   var _Account$toAccount, _output$account;
   const output = {};
   if (input.version !== 1) {
@@ -118700,6 +119106,9 @@ function client_MapInputValues(input) {
    * Import account
    */
   output.account = (_Account$toAccount = client_lib_account.toAccount(input.account)) !== null && _Account$toAccount !== void 0 ? _Account$toAccount : undefined;
+  if (Array.isArray(input.signer)) {
+    throw new Error('V1 block signer must not be a multisig signer');
+  }
   output.signer = client_lib_account.toAccount(input.signer);
   if (!output.signer && (_output$account = output.account) !== null && _output$account !== void 0 && _output$account.isAccount()) {
     output.signer = output.account;
@@ -118753,6 +119162,71 @@ function client_MapInputValues(input) {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return output;
 }
+function client_MapV2InputValues(input) {
+  var _Account$toAccount2;
+  const output = {};
+  if (input.version !== 2) {
+    throw new Error('MapInputValues should not be called with version != 2');
+  }
+  output.version = input.version;
+  output.purpose = input.purpose;
+  if (input.date !== undefined) {
+    output.date = new Date(input.date);
+  }
+
+  /*
+   * Import account
+   */
+  output.account = (_Account$toAccount2 = client_lib_account.toAccount(input.account)) !== null && _Account$toAccount2 !== void 0 ? _Account$toAccount2 : undefined;
+
+  /*
+   * Import previous block hash
+   */
+  if (input.previous !== undefined) {
+    if (client_block_BlockHash.isInstance(input.previous)) {
+      output.previous = input.previous;
+    } else if (input.previous === client_NO_PREVIOUS) {
+      if (output.account) {
+        output.previous = client_block_BlockHash.getAccountOpeningHash(output.account);
+      }
+    } else {
+      output.previous = new client_block_BlockHash(input.previous);
+    }
+  }
+
+  /*
+   * Import network
+   */
+  if (input.network !== undefined) {
+    output.network = BigInt(input.network);
+  }
+
+  /*
+   * Import Subnet
+   */
+  if (input.subnet !== undefined) {
+    output.subnet = BigInt(input.subnet);
+  }
+
+  /*
+   * Import operations from JSON
+   */
+  if (input.operations !== undefined) {
+    output.operations = client_ImportOperationsJSON(input.operations);
+  }
+  if (input.signer !== undefined) {
+    output.signer = client_parseBlockSignerFieldJSON(input.signer);
+  }
+
+  // This is valid, the compiler does not understand that we are adding all of the values in this function
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return output;
+}
+function client_assertBlockSignatureField(input) {
+  if (input.length < 1) {
+    throw new Error('Input must include 1+ signatures');
+  }
+}
 
 /**
  * Block:  An item which contains a number of operations (transactions) which
@@ -118762,32 +119236,68 @@ var client_valueBytes = /*#__PURE__*/new WeakMap();
 var client_valueHash = /*#__PURE__*/new WeakMap();
 var client_Block_brand = /*#__PURE__*/new WeakSet();
 class src_client_Block {
+  // Canonical Fields
+
+  get principal() {
+    if (Array.isArray(this.signer)) {
+      return this.signer[0];
+    } else {
+      return this.signer;
+    }
+  }
   static async fromUnsignedJSON(input) {
     const inputCheck = input;
     if (typeof inputCheck === 'object' && inputCheck !== null) {
-      if ('signature' in inputCheck) {
-        throw new Error('fromUnsignedJSON() was called when a signature already exists');
+      if ('signature' in inputCheck || 'signatures' in inputCheck) {
+        throw new Error('fromUnsignedJSON() was called when a signature(s) already exists');
       }
     }
-    const container = src_client_Block.getASN1ContainerWithoutSignature(input);
+    const container = this.getASN1ContainerWithoutSignature(input);
+    // We have to ignore the type here because the ASN1.JStoASN1 function does not handle recursive types well
+    // @ts-ignore
     const bytes = client_JStoASN1(container).toBER(false);
     const hash = new client_block_BlockHash(client_hash_Hash(client_block_Buffer.from(bytes)));
-    const signature = await input.signer.sign(hash.getBuffer());
-    return new src_client_Block({
-      version: input.version,
-      date: input.date,
-      previous: input.previous,
-      account: input.account,
-      signer: input.signer,
-      operations: input.operations,
-      network: input.network,
-      subnet: input.subnet,
-      signature: signature.getBuffer()
-    });
+    const signers = client_block_assertClassBrand(src_client_Block, this, client_getSortedRequiredSigners).call(this, input.signer);
+    const signatures = await Promise.all(signers.map(async function (signer) {
+      const signature = await signer.sign(hash.getBuffer());
+      return signature.getBuffer();
+    }));
+    let blockInput;
+    if (input.version === 1) {
+      blockInput = {
+        ...input,
+        signature: signatures[0]
+      };
+    } else {
+      blockInput = {
+        ...input,
+        signatures
+      };
+    }
+    return new src_client_Block(blockInput);
   }
-  static isValidJSON(block) {
-    for (const checkField of ['version', 'date', 'previous', 'network', 'network', 'account', 'signer', 'signature', 'operations']) {
-      if (block[checkField] === undefined) {
+  static isValidJSON(block, version) {
+    if (!block || typeof block !== 'object' || Array.isArray(block)) {
+      return false;
+    }
+    if (!('version' in block)) {
+      return false;
+    }
+    if (version !== undefined && block.version !== version) {
+      return false;
+    }
+    const checkFields = ['date', 'previous', 'network', 'network', 'account', 'signer', 'operations'];
+    if (block.version === 1) {
+      checkFields.push('signature');
+    } else if (block.version === 2) {
+      checkFields.push('signatures');
+      checkFields.push('purpose');
+    } else {
+      return false;
+    }
+    for (const checkField of checkFields) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      if (!(checkField in block) || block[checkField] === undefined) {
         return false;
       }
     }
@@ -118798,7 +119308,6 @@ class src_client_Block {
     client_block_classPrivateFieldInitSpec(this, client_valueBytes, void 0);
     client_block_classPrivateFieldInitSpec(this, client_valueHash, void 0);
     // Extra attributes
-    client_lib_block_defineProperty(this, "$signatureValid", true);
     client_lib_block_defineProperty(this, "$opening", false);
     if (typeof input === 'string') {
       input = client_block_Buffer.from(input, 'base64');
@@ -118807,80 +119316,166 @@ class src_client_Block {
       input = client_bufferToArrayBuffer(input);
     }
     if (client_util.types.isArrayBuffer(input)) {
-      var _data$;
-      /*
-       * TypeScript cannot deal with this complex type, so we have to manually
-       * specify the type -- this might be fixed in TypeScript 5.7+
-       */
-      // @ts-ignore
       const data = new client_BufferStorageASN1(input, client_BlockASN1Schema).getASN1();
-      if (data[0] !== 0n) {
-        throw new src_client_KeetaNetBlockError('BLOCK_INVALID_VERSION', 'Only version 1 is supported');
-      }
-      const version = Number(data[0]) + 1;
-      client_assertBlockBlockCanonicalVersion(version);
-      this.version = version;
-      this.network = data[1];
-      this.subnet = (_data$ = data[2]) !== null && _data$ !== void 0 ? _data$ : undefined;
-      this.date = data[3].date;
-      const signerPubKey = data[4];
-      this.signer = client_lib_account.fromPublicKeyAndType(signerPubKey).assertAccount();
-      const acctItem = data[5];
-      if (acctItem === null) {
-        this.account = this.signer;
-      } else {
-        this.account = client_lib_account.fromPublicKeyAndType(acctItem);
-        if (this.account.comparePublicKey(this.signer)) {
-          throw new Error('Account should not be in block when it is same as signer, we cannot use this block');
+      if (Array.isArray(data)) {
+        var _data$;
+        if (data[0] !== 0n) {
+          throw new Error('Invalid block version without context tag');
+        }
+        this.version = 1;
+        this.purpose = client_BlockPurpose.GENERIC;
+        this.network = data[1];
+        this.subnet = (_data$ = data[2]) !== null && _data$ !== void 0 ? _data$ : undefined;
+        this.date = data[3].date;
+        const signerContainer = data[4];
+        this.signer = client_lib_account.fromPublicKeyAndType(signerContainer).assertAccount();
+        const acctItem = data[5];
+        if (acctItem === null) {
+          this.account = this.signer;
+        } else {
+          this.account = client_lib_account.fromPublicKeyAndType(acctItem);
+          if (this.account.comparePublicKey(this.signer)) {
+            throw new Error('Account should not be in block when it is same as signer, we cannot use this block');
+          }
+        }
+        const prevHashBuf = data[6];
+        this.previous = new client_block_BlockHash(prevHashBuf);
+        this.operations = client_ImportOperationsASN1(data[7], this.network);
+        this.signatures = [data[8]];
+      } else if (data.value === 1) {
+        var _container$;
+        this.version = 2;
+        const container = data.contains;
+        this.network = container[0];
+        this.subnet = (_container$ = container[1]) !== null && _container$ !== void 0 ? _container$ : undefined;
+        this.date = container[2].date;
+        this.purpose = client_toBlockPurpose(container[3]);
+        this.account = client_lib_account.fromPublicKeyAndType(container[4]);
+        const signersContainer = container[5];
+        if (signersContainer === null) {
+          this.signer = this.account.assertAccount();
+        } else if (client_block_Buffer.isBuffer(signersContainer)) {
+          this.signer = client_lib_account.fromPublicKeyAndType(signersContainer).assertAccount();
+          if (this.account.comparePublicKey(this.signer)) {
+            throw new Error('Signer should not be in block when it is same as account, we cannot use this block');
+          }
+        } else {
+          this.signer = client_parseBlockSignerFieldContainer(signersContainer).parsed;
         }
+        this.previous = new client_block_BlockHash(container[6]);
+        this.operations = client_ImportOperationsASN1(container[7], this.network);
+        const signatureContainer = container[8];
+        if (client_block_Buffer.isBuffer(signatureContainer)) {
+          this.signatures = [signatureContainer];
+        } else {
+          if (signatureContainer.length <= 1) {
+            throw new Error('Signature field invalid, must be greater than one when using sequence of');
+          }
+          client_assertBlockSignatureField(signatureContainer);
+          this.signatures = signatureContainer;
+        }
+      } else {
+        throw new Error('Unknown block version');
       }
-      const prevHashBuf = data[6];
-      this.previous = new client_block_BlockHash(prevHashBuf);
-      this.operations = client_ImportOperationsASN1(data[7], this.network);
-      this.signature = data[8];
       client_block_classPrivateFieldSet(client_valueBytes, this, input);
     } else {
-      if (!src_client_Block.isValidJSON(input)) {
-        throw new Error('Cannot construct block, it is not a valid Block JSON object');
-      }
-
-      /* XXX:TODO: Verify that no extra keys were passed in */
+      if (src_client_Block.isInstance(input)) {
+        this.version = input.version;
+        this.purpose = input.purpose;
+        this.date = input.date;
+        this.previous = input.previous;
+        this.network = input.network;
+        this.subnet = input.subnet;
+        this.account = input.account;
+        this.operations = input.operations;
+        this.signer = input.signer;
+        this.signatures = input.signatures;
+      } else if (src_client_Block.isValidJSON(input, 1)) {
+        /*
+        * Map input to our values
+        */
+        const {
+          version,
+          date,
+          previous,
+          network,
+          subnet,
+          account,
+          operations,
+          signer
+        } = client_MapV1InputValues(input);
+        this.version = version;
+        this.purpose = client_BlockPurpose.GENERIC;
+        this.date = date;
+        this.previous = previous;
+        this.network = network;
+        this.subnet = subnet;
+        this.account = account;
+        this.operations = operations;
+        this.signer = signer;
 
-      /*
-       * Map input to our values
-       */
-      const {
-        version,
-        date,
-        previous,
-        network,
-        subnet,
-        account,
-        operations,
-        signer
-      } = client_MapInputValues(input);
-      this.version = version;
-      this.date = date;
-      this.previous = previous;
-      this.network = network;
-      this.subnet = subnet;
-      this.account = account;
-      this.signer = signer;
-      this.operations = operations;
+        /*
+        * We must handle the signature last because we will
+        * sign the hash of the block based on what has been
+        * processed
+        */
+        if (input.signature === undefined) {
+          throw new Error('Cannot construct block without a signature and explicit direction to sign');
+        }
+        let signature;
+        if (typeof input.signature === 'string') {
+          signature = client_block_Buffer.from(input.signature, 'hex');
+        } else {
+          signature = client_block_Buffer.from(input.signature);
+        }
+        this.signatures = [signature];
+      } else if (src_client_Block.isValidJSON(input, 2)) {
+        /*
+        * Map input to our values
+        */
+        const {
+          version,
+          date,
+          previous,
+          network,
+          subnet,
+          account,
+          operations,
+          signer,
+          purpose
+        } = client_MapV2InputValues(input);
+        this.version = version;
+        this.purpose = purpose;
+        this.date = date;
+        this.previous = previous;
+        this.network = network;
+        this.subnet = subnet;
+        this.account = account;
+        this.signer = signer;
+        this.operations = operations;
 
-      /*
-       * We must handle the signature last because we will
-       * sign the hash of the block based on what has been
-       * processed
-       */
-      if (input.signature === undefined) {
-        throw new Error('Cannot construct block without a signature and explicit direction to sign');
-      }
-      if (typeof input.signature === 'string') {
-        this.signature = client_block_Buffer.from(input.signature, 'hex');
+        /*
+        * We must handle the signature last because we will
+        * sign the hash of the block based on what has been
+        * processed
+        */
+        if (input.signatures === undefined) {
+          throw new Error('Cannot construct block without a signature and explicit direction to sign');
+        }
+        const signatures = input.signatures.map(function (signature) {
+          if (typeof signature === 'string') {
+            return client_block_Buffer.from(signature, 'hex');
+          } else {
+            return client_block_Buffer.from(signature);
+          }
+        });
+        client_assertBlockSignatureField(signatures);
+        this.signatures = signatures;
       } else {
-        this.signature = client_block_Buffer.from(input.signature);
+        throw new Error('Cannot construct block, it is not a valid Block JSON object');
       }
+
+      /* XXX:TODO: Verify that no extra keys were passed in */
     }
     if (this.previous.compareHexString(this.hash)) {
       throw new src_client_KeetaNetBlockError('BLOCK_PREVIOUS_SELF', 'internal error: Block references itself');
@@ -118895,36 +119490,95 @@ class src_client_Block {
         throw new Error('Subnet ID must be a positive number');
       }
     }
-    if (this.version !== 1) {
-      throw new Error('We only support Blocks with Version 1');
+    if (this.version !== 1 && this.version !== 2) {
+      throw new src_client_KeetaNetBlockError('BLOCK_INVALID_VERSION', 'We only support Blocks Version 1-2');
     }
     if (this.account.isMultisig()) {
       throw new src_client_KeetaNetBlockError('BLOCK_NO_MULTISIG_OP', 'Cannot create a block for a multisig account');
     }
-    client_block_assertClassBrand(client_Block_brand, this, client_validateOperations).call(this);
-    client_block_assertClassBrand(client_Block_brand, this, client_validateSignature).call(this);
+    if (this.account.isMultisig()) {
+      throw new src_client_KeetaNetBlockError('BLOCK_NO_MULTISIG_OP', 'Cannot create a block for a multisig account');
+    }
+    client_block_assertClassBrand(client_Block_brand, this, client_validateSignerField).call(this);
+    client_block_assertClassBrand(client_Block_brand, this, client_validateOperationsPurpose).call(this);
+    client_block_assertClassBrand(client_Block_brand, this, client_validateSignatures).call(this);
   }
   static getAccountOpeningHash(account) {
     return client_block_BlockHash.getAccountOpeningHash(account);
   }
   toBytes() {
-    let includeSignature = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    if (client_block_classPrivateFieldGet(client_valueBytes, this) !== undefined) {
-      if (includeSignature) {
-        return client_block_classPrivateFieldGet(client_valueBytes, this);
-      }
+    let includeSignatures = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    if (client_block_classPrivateFieldGet(client_valueBytes, this) !== undefined && includeSignatures) {
+      return client_block_classPrivateFieldGet(client_valueBytes, this);
     }
-    const container = src_client_Block.getASN1ContainerWithoutSignature(this);
-    if (includeSignature) {
-      container.push(this.signature);
+    const sharedBlockValues = {
+      previous: this.previous,
+      operations: this.operations,
+      account: this.account,
+      network: this.network,
+      subnet: this.subnet,
+      date: this.date
+    };
+    let container;
+    if (this.version === 1) {
+      if (Array.isArray(this.signer) || this.signatures.length !== 1) {
+        throw new Error('Block v1 only supports single signer');
+      }
+      container = src_client_Block.getV1ASN1ContainerWithoutSignature({
+        ...sharedBlockValues,
+        version: 1,
+        signer: this.signer
+      });
+      if (includeSignatures) {
+        container.push(this.signatures[0]);
+      }
+    } else {
+      const versionTag = this.version - 1;
+      if (versionTag !== 1) {
+        // We only support version 2
+        throw new src_client_KeetaNetBlockError('BLOCK_INVALID_VERSION', 'We only support version 1/2 blocks');
+      }
+      const v2Container = src_client_Block.getV2ASN1ContainerWithoutSignature({
+        ...sharedBlockValues,
+        purpose: this.purpose,
+        version: this.version,
+        signer: this.signer
+      });
+      const baseContextTag = {
+        type: 'context',
+        kind: 'explicit',
+        value: versionTag
+      };
+      if (includeSignatures) {
+        let signatureContainer;
+        if (this.signatures.length > 1) {
+          signatureContainer = this.signatures;
+        } else if (this.signatures.length === 1) {
+          signatureContainer = this.signatures[0];
+        } else {
+          throw new Error('Block has not been signed');
+        }
+        container = {
+          ...baseContextTag,
+          contains: [...v2Container, signatureContainer]
+        };
+      } else {
+        container = {
+          ...baseContextTag,
+          contains: v2Container
+        };
+      }
     }
+
+    // We know the container is valid because of the container type, but the ASN1.JStoASN1 function does not handle recursive types well
+    // @ts-ignore
     const retval = client_JStoASN1(container).toBER(false);
-    if (includeSignature) {
+    if (includeSignatures) {
       client_block_classPrivateFieldSet(client_valueBytes, this, retval);
     }
     return retval;
   }
-  static getASN1ContainerWithoutSignature(input) {
+  static getV1ASN1ContainerWithoutSignature(input) {
     var _input$subnet;
     let outputAccount;
     if (input.account.comparePublicKey(input.signer)) {
@@ -118935,25 +119589,66 @@ class src_client_Block {
     if (input.version !== 1) {
       throw new Error('Cannot call getASN1ContainerWithoutSignature when version != 1');
     }
-    const container = [0n, input.network, (_input$subnet = input.subnet) !== null && _input$subnet !== void 0 ? _input$subnet : null, {
+    return [0n, input.network, (_input$subnet = input.subnet) !== null && _input$subnet !== void 0 ? _input$subnet : null, {
       type: 'date',
       kind: 'general',
       date: input.date
     }, input.signer.publicKeyAndType, outputAccount, client_block_Buffer.from(input.previous.get()), client_ExportBlockOperations([...input.operations])];
-    return container;
+  }
+  static getV2ASN1ContainerWithoutSignature(input) {
+    if (input.version !== 2) {
+      throw new Error('Only version 2 supported');
+    }
+    let signerContainer;
+    if (Array.isArray(input.signer)) {
+      signerContainer = client_getMultisigSignerContainer(input.signer);
+    } else if (input.signer.comparePublicKey(input.account)) {
+      signerContainer = null;
+    } else {
+      signerContainer = input.signer.publicKeyAndType;
+    }
+    return [input.network, input.subnet, {
+      type: 'date',
+      kind: 'general',
+      date: input.date
+    }, BigInt(input.purpose), input.account.publicKeyAndType, signerContainer, client_block_Buffer.from(input.previous.get()), client_ExportBlockOperations([...input.operations])];
+  }
+  static getASN1ContainerWithoutSignature(input) {
+    if (input.version === 1) {
+      return this.getV1ASN1ContainerWithoutSignature(input);
+    } else if (input.version === 2) {
+      return {
+        type: 'context',
+        kind: 'explicit',
+        value: 1,
+        contains: this.getV2ASN1ContainerWithoutSignature(input)
+      };
+    } else {
+      throw new src_client_KeetaNetBlockError('BLOCK_INVALID_VERSION', 'Invalid Version');
+    }
   }
   toJSON(options) {
     const additionalFields = {};
     if (options !== null && options !== void 0 && options.addBinary) {
       additionalFields['$binary'] = client_block_Buffer.from(this.toBytes()).toString('base64');
     }
+    const signatures = this.signatures.map(function (signature) {
+      return signature.toString('hex').toUpperCase();
+    });
+    if (this.version === 1) {
+      additionalFields.signature = signatures[0];
+    } else {
+      additionalFields.signatures = signatures;
+    }
     return {
       version: this.version,
       date: this.date,
       previous: this.previous,
       account: this.account,
+      purpose: this.purpose,
+      // XXX:TODO We need to use a type assertion here because toJSONSerializable does not support recursive types
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       signer: this.signer,
-      signature: this.signature.toString('hex').toUpperCase(),
       network: this.network,
       subnet: this.subnet,
       operations: client_ExportOperationsJSON(this.operations),
@@ -118981,7 +119676,27 @@ class src_client_Block {
   }
 }
 client_Block = src_client_Block;
-function client_validateOperations() {
+function client_getSortedRequiredSigners(input) {
+  const queue = [input];
+  const visited = new client_lib_account.Set();
+  const out = [];
+  while (queue.length > 0) {
+    // We can assume that the signerFieldQueue is not empty here since the loop condition checks it
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const cur = queue.shift();
+    if (client_lib_account.isInstance(cur)) {
+      if (visited.has(cur)) {
+        continue;
+      }
+      visited.add(cur);
+      out.push(cur);
+    } else {
+      queue.unshift(...cur[1]);
+    }
+  }
+  return out;
+}
+function client_validateOperationsPurpose() {
   /**
    * Do not allow blocks to contain invalid constructions
    */
@@ -118991,16 +119706,55 @@ function client_validateOperations() {
     operationIndex: 0
   };
   for (const operation of this.operations) {
+    if (this.purpose === client_BlockPurpose.FEE) {
+      if (operation.type !== client_OperationType.SEND) {
+        throw new src_client_KeetaNetBlockError('BLOCK_INVALID_PURPOSE_VALIDATION', `Block purpose is FEE, but operation at index ${context.operationIndex} is not a SEND operation`);
+      }
+    }
     operation.validate(context);
     context.operationIndex++;
   }
 }
-function client_validateSignature() {
-  /* XXX:TODO: 64 is the size of signatures right now but this shouldn't be hard-coded */
-  const signature = new src_client_BufferStorage(this.signature, 64);
-  const valid = this.signer.verify(this.hash.get(), signature.get());
-  if (valid !== true) {
-    throw new Error(`Unable to validate signature of ${this.hash.toString()} against signature ${this.signature}`);
+function client_validateSignerField() {
+  if (!Array.isArray(this.signer)) {
+    return;
+  }
+  const queue = [[1n, this.signer]];
+  while (queue.length > 0) {
+    // We can assume that the signerFieldQueue is not empty here since the loop condition checks it
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const [depth, cur] = queue.shift();
+    client_validateBlockSignerDepth(depth, this.network);
+    if (Array.isArray(cur)) {
+      client_validateBlockSignerCount(BigInt(cur[1].length), this.network);
+      const seen = new client_lib_account.Set();
+      for (const innerSigner of cur[1]) {
+        let signer;
+        if (Array.isArray(innerSigner)) {
+          signer = innerSigner[0];
+          queue.push([depth + 1n, innerSigner]);
+        } else {
+          signer = innerSigner;
+        }
+        if (seen.has(signer)) {
+          throw new src_client_KeetaNetBlockError('BLOCK_INVALID_MULTISIG_SIGNER_DUPLICATE', `Multisig signer at depth ${depth} has duplicate signer ${signer.publicKeyString.get()}`);
+        }
+        seen.add(signer);
+      }
+    }
+  }
+}
+function client_validateSignatures() {
+  const signers = client_getSortedRequiredSigners.call(client_Block, this.signer);
+  if (this.signatures.length !== signers.length) {
+    throw new src_client_KeetaNetBlockError('BLOCK_INVALID_SIGNER', 'Signer count does not match signature count');
+  }
+  for (let i = 0; i < signers.length; i++) {
+    const signature = new src_client_BufferStorage(this.signatures[i], 64);
+    const valid = signers[i].verify(this.hash.get(), signature.get());
+    if (valid !== true) {
+      throw new Error(`Unable to validate signature of ${this.hash.toString()} against signature ${this.signatures[i]} for account ${signers[i].publicKeyString.get()}`);
+    }
   }
 }
 client_lib_block_defineProperty(src_client_Block, "isInstance", client_checkableGenerator(client_Block));
@@ -119009,6 +119763,7 @@ client_lib_block_defineProperty(src_client_Block, "OperationType", client_Operat
 client_lib_block_defineProperty(src_client_Block, "Operation", client_Operation);
 client_lib_block_defineProperty(src_client_Block, "NO_PREVIOUS", client_NO_PREVIOUS);
 client_lib_block_defineProperty(src_client_Block, "AdjustMethod", client_AdjustMethod);
+client_lib_block_defineProperty(src_client_Block, "Purpose", client_BlockPurpose);
 var client_block = /*#__PURE__*/new WeakMap();
 class src_client_BlockBuilder {
   constructor(block) {
@@ -119025,12 +119780,12 @@ class src_client_BlockBuilder {
        */
       client_block_classPrivateFieldSet(client_block, this, new src_client_Block(block));
     } else {
-      if (block !== undefined && src_client_Block.isValidJSON(block)) {
+      if (block !== undefined && src_client_Block.isValidJSON(block, 2)) {
         client_block_classPrivateFieldSet(client_block, this, new src_client_Block(block));
       } else {
         const incompleteBlockJSON = {
-          version: 1,
           date: new Date().toISOString(),
+          version: 1,
           ...block
         };
 
@@ -119041,7 +119796,22 @@ class src_client_BlockBuilder {
         if (incompleteBlockJSON.previous === src_client_BlockBuilder.NO_PREVIOUS) {
           setPreviousNoBlock = true;
         }
-        const newBlockJSON = client_MapInputValues(incompleteBlockJSON);
+        let newBlockJSON;
+        if (incompleteBlockJSON.version === 1) {
+          // We have to use a type assertion here because the MapV1InputValues function does not support recursive types
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          newBlockJSON = client_MapV1InputValues({
+            ...incompleteBlockJSON,
+            version: 1
+          });
+        } else if (incompleteBlockJSON.version === 2) {
+          newBlockJSON = client_MapV2InputValues({
+            ...incompleteBlockJSON,
+            version: 2
+          });
+        } else {
+          throw new Error('Cannot construct block, it is not a valid Block JSON object');
+        }
         if (setPreviousNoBlock) {
           newBlockJSON.previous = src_client_BlockBuilder.NO_PREVIOUS;
         }
@@ -119081,11 +119851,24 @@ class src_client_BlockBuilder {
       network: this.network,
       subnet: this.subnet,
       operations: this.operations,
+      purpose: this.purpose,
       ['$opening']: this.$opening
     };
   }
   async seal() {
-    const block = await src_client_Block.fromUnsignedJSON(client_MapInputValues(this));
+    if (this.version === undefined) {
+      throw new Error('Cannot seal block without version');
+    }
+    let input;
+    // There is no clean way to tell the compiler which version `this` is, so we have to use a type assertion
+    if (this.version === 1) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      input = client_MapV1InputValues(this);
+    } else {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      input = client_MapV2InputValues(this);
+    }
+    const block = await src_client_Block.fromUnsignedJSON(input);
     client_block_classPrivateFieldSet(client_block, this, block);
     return block;
   }
@@ -119093,10 +119876,16 @@ class src_client_BlockBuilder {
     let retval;
     if (src_client_Block.isInstance(client_block_classPrivateFieldGet(client_block, this))) {
       client_block_classPrivateFieldSet(client_block, this, {
-        ...client_block_classPrivateFieldGet(client_block, this)
+        version: client_block_classPrivateFieldGet(client_block, this).version,
+        date: client_block_classPrivateFieldGet(client_block, this).date,
+        previous: client_block_classPrivateFieldGet(client_block, this).previous,
+        account: client_block_classPrivateFieldGet(client_block, this).account,
+        signer: client_block_classPrivateFieldGet(client_block, this).signer,
+        network: client_block_classPrivateFieldGet(client_block, this).network,
+        subnet: client_block_classPrivateFieldGet(client_block, this).subnet,
+        operations: [...client_block_classPrivateFieldGet(client_block, this).operations]
       });
       retval = client_block_classPrivateFieldGet(client_block, this);
-      delete retval['signature'];
     } else {
       retval = client_block_classPrivateFieldGet(client_block, this);
     }
@@ -119120,12 +119909,33 @@ class src_client_BlockBuilder {
     }
   }
   set signer(signer) {
-    this.currentWIP.signer = client_lib_account.toAccount(signer);
+    if (signer) {
+      this.currentWIP.signer = client_parseBlockSignerFieldJSON(signer);
+    } else {
+      this.currentWIP.signer = undefined;
+    }
   }
   get signer() {
     const signer = client_block_classPrivateFieldGet(client_block, this).signer;
-    if (signer !== undefined && !client_lib_account.isInstance(signer)) {
-      throw new Error('internal error: We only represent signer as Account');
+    if (signer === undefined) {
+      if (this.account && this.account.isAccount() && this.account.hasPrivateKey) {
+        return this.account;
+      }
+    } else {
+      const queue = [signer];
+      while (queue.length > 0) {
+        const cur = queue.shift();
+        let signer;
+        if (Array.isArray(cur)) {
+          signer = cur[0];
+          queue.push(...cur[1]);
+        } else {
+          signer = cur;
+        }
+        if (!client_lib_account.isInstance(signer)) {
+          throw new Error('internal error: We only represent signer/multisig-info as their constructed values');
+        }
+      }
     }
     return signer;
   }
@@ -119137,7 +119947,16 @@ class src_client_BlockBuilder {
     if (account !== undefined && !client_lib_account.isInstance(account)) {
       throw new Error('internal error: We only represent account as an Account');
     }
-    return account !== null && account !== void 0 ? account : this.signer;
+    if (account === undefined && this.version === 1 || this.version === undefined) {
+      if (Array.isArray(this.signer)) {
+        throw new Error('Cannot create a v1 block with a multisig signer');
+      }
+      if (typeof this.signer === 'string') {
+        throw new Error('We should only represent signer as an Account');
+      }
+      return this.signer;
+    }
+    return account;
   }
   set previous(blockhash) {
     const wip = this.currentWIP;
@@ -119207,6 +120026,18 @@ class src_client_BlockBuilder {
   get version() {
     return this.currentBlock.version;
   }
+  set purpose(purpose) {
+    if (purpose !== undefined && purpose !== client_BlockPurpose.GENERIC && this.version === 1) {
+      throw new Error('Cannot set purpose (other than generic) on a v1 block');
+    }
+    this.currentWIP.purpose = purpose;
+  }
+  get purpose() {
+    if (this.currentBlock.purpose !== undefined) {
+      return this.currentBlock.purpose;
+    }
+    return client_BlockPurpose.GENERIC;
+  }
   set network(network) {
     this.currentWIP.network = network;
   }
@@ -119698,7 +120529,7 @@ const client_AccountPrefixes = ['keeta_', 'tyblocks_']; // cspell:disable-line -
  * Account key algorithms specify how the key should be used for validation,
  * signing, and encoding.
  */
-let client_account_AccountKeyAlgorithm = /*#__PURE__*/function (AccountKeyAlgorithm) {
+let client_AccountKeyAlgorithm = /*#__PURE__*/function (AccountKeyAlgorithm) {
   AccountKeyAlgorithm[AccountKeyAlgorithm["ECDSA_SECP256K1"] = 0] = "ECDSA_SECP256K1";
   AccountKeyAlgorithm[AccountKeyAlgorithm["ED25519"] = 1] = "ED25519";
   AccountKeyAlgorithm[AccountKeyAlgorithm["NETWORK"] = 2] = "NETWORK";
@@ -119758,12 +120589,12 @@ function client_account_ignore_static_checks() {
  */
 
 function client_assertAccountKeyAlgorithm(algorithm) {
-  if (typeof algorithm === 'number' && client_account_AccountKeyAlgorithm[algorithm] !== undefined) {
+  if (typeof algorithm === 'number' && client_AccountKeyAlgorithm[algorithm] !== undefined) {
     return algorithm;
   }
   throw new Error(`Invalid account key algorithm ${algorithm}`);
 }
-const client_identifierKeyTypes = [client_account_AccountKeyAlgorithm.NETWORK, client_account_AccountKeyAlgorithm.TOKEN, client_account_AccountKeyAlgorithm.STORAGE, client_account_AccountKeyAlgorithm.MULTISIG];
+const client_identifierKeyTypes = [client_AccountKeyAlgorithm.NETWORK, client_AccountKeyAlgorithm.TOKEN, client_AccountKeyAlgorithm.STORAGE, client_AccountKeyAlgorithm.MULTISIG];
 
 /**
  * Things we can use to construct a key from
@@ -119994,13 +120825,13 @@ class src_client_ExternalKeyPair extends client_KeyInterface {
     client_account_classPrivateFieldSet(client_functions, this, functions);
     client_account_classPrivateFieldSet(client_keyType, this, keyType);
     switch (keyType) {
-      case client_account_AccountKeyAlgorithm.ECDSA_SECP256K1:
+      case client_AccountKeyAlgorithm.ECDSA_SECP256K1:
         client_account_classPrivateFieldSet(client_publicKey, this, new src_client_ECDSASECP256K1PublicKey(publicKey));
         break;
-      case client_account_AccountKeyAlgorithm.ECDSA_SECP256R1:
+      case client_AccountKeyAlgorithm.ECDSA_SECP256R1:
         client_account_classPrivateFieldSet(client_publicKey, this, new src_client_ECDSASECP256R1PublicKey(publicKey));
         break;
-      case client_account_AccountKeyAlgorithm.ED25519:
+      case client_AccountKeyAlgorithm.ED25519:
         client_account_classPrivateFieldSet(client_publicKey, this, new src_client_ED25519PublicKey(publicKey));
         break;
       default:
@@ -120156,7 +120987,7 @@ class src_client_ECDSASECP256K1KeyPair extends client_ECDSAKeyPair {
   }
   constructor(privateKey, publicKey) {
     super();
-    client_account_classPrivateFieldInitSpec(this, client_keyType2, client_account_AccountKeyAlgorithm.ECDSA_SECP256K1);
+    client_account_classPrivateFieldInitSpec(this, client_keyType2, client_AccountKeyAlgorithm.ECDSA_SECP256K1);
     client_account_classPrivateFieldInitSpec(this, client_privateKey, void 0);
     client_account_classPrivateFieldInitSpec(this, client_publicKey2, void 0);
     client_account_classPrivateFieldInitSpec(this, client_privateKeyInternalValue, void 0);
@@ -120324,7 +121155,7 @@ class src_client_ECDSASECP256R1KeyPair extends client_ECDSAKeyPair {
   }
   constructor(privateKey, publicKey) {
     super();
-    client_account_classPrivateFieldInitSpec(this, client_keyType3, client_account_AccountKeyAlgorithm.ECDSA_SECP256R1);
+    client_account_classPrivateFieldInitSpec(this, client_keyType3, client_AccountKeyAlgorithm.ECDSA_SECP256R1);
     client_account_classPrivateFieldInitSpec(this, client_privateKey2, void 0);
     client_account_classPrivateFieldInitSpec(this, client_publicKey3, void 0);
     client_account_classPrivateFieldInitSpec(this, client_privateKeyInternalValue2, void 0);
@@ -120551,7 +121382,7 @@ class src_client_ED25519KeyPair extends client_KeyInterface {
     return decrypted.buffer;
   }
   get keyType() {
-    return client_account_AccountKeyAlgorithm.ED25519;
+    return client_AccountKeyAlgorithm.ED25519;
   }
   get publicKey() {
     return client_account_classPrivateFieldGet(client_publicKey4, this);
@@ -120689,16 +121520,16 @@ function client_derivePublicKeyFromPublicKeyString(key_str) {
   const pubKeyValues = new Uint8Array(pubKeyValuesBuffer.slice(1, -5));
   const keyType = pubKeyValuesArray[0];
   switch (keyType) {
-    case client_account_AccountKeyAlgorithm.ECDSA_SECP256K1:
+    case client_AccountKeyAlgorithm.ECDSA_SECP256K1:
       return new src_client_ECDSASECP256K1KeyPair(undefined, client_account_Buffer.from(pubKeyValues));
-    case client_account_AccountKeyAlgorithm.ECDSA_SECP256R1:
+    case client_AccountKeyAlgorithm.ECDSA_SECP256R1:
       return new src_client_ECDSASECP256R1KeyPair(undefined, client_account_Buffer.from(pubKeyValues));
-    case client_account_AccountKeyAlgorithm.ED25519:
+    case client_AccountKeyAlgorithm.ED25519:
       return new src_client_ED25519KeyPair(undefined, client_account_Buffer.from(pubKeyValues));
-    case client_account_AccountKeyAlgorithm.NETWORK:
-    case client_account_AccountKeyAlgorithm.TOKEN:
-    case client_account_AccountKeyAlgorithm.STORAGE:
-    case client_account_AccountKeyAlgorithm.MULTISIG:
+    case client_AccountKeyAlgorithm.NETWORK:
+    case client_AccountKeyAlgorithm.TOKEN:
+    case client_AccountKeyAlgorithm.STORAGE:
+    case client_AccountKeyAlgorithm.MULTISIG:
       return new src_client_IdentifierKeyPair(client_account_Buffer.from(pubKeyValues), keyType);
   }
   throw new src_client_KeetaNetAccountError('ACCOUNT_INVALID_KEYTYPE', `Invalid key type (${keyType}) while parsing public key string: ${key_str.get()}`);
@@ -120804,28 +121635,28 @@ class src_client_Account {
    * Construct an account from a network identifier public key
    */
   static fromNetworkPublicKey(key) {
-    return this.fromIdentifierPublicKey(key, client_account_AccountKeyAlgorithm.NETWORK);
+    return this.fromIdentifierPublicKey(key, client_AccountKeyAlgorithm.NETWORK);
   }
 
   /**
    * Construct an account from a token identifier public key
    */
   static fromTokenPublicKey(key) {
-    return this.fromIdentifierPublicKey(key, client_account_AccountKeyAlgorithm.TOKEN);
+    return this.fromIdentifierPublicKey(key, client_AccountKeyAlgorithm.TOKEN);
   }
 
   /**
    * Construct an account from a storage identifier public key
    */
   static fromStoragePublicKey(key) {
-    return this.fromIdentifierPublicKey(key, client_account_AccountKeyAlgorithm.STORAGE);
+    return this.fromIdentifierPublicKey(key, client_AccountKeyAlgorithm.STORAGE);
   }
 
   /**
    * Construct an account from a multisig identifier public key
    */
   static fromMultisigPublicKey(key) {
-    return this.fromIdentifierPublicKey(key, client_account_AccountKeyAlgorithm.MULTISIG);
+    return this.fromIdentifierPublicKey(key, client_AccountKeyAlgorithm.MULTISIG);
   }
 
   /**
@@ -120847,19 +121678,19 @@ class src_client_Account {
     const key = keyData.slice(1);
     let constructorFunction;
     switch (keyType) {
-      case client_account_AccountKeyAlgorithm.ECDSA_SECP256K1:
+      case client_AccountKeyAlgorithm.ECDSA_SECP256K1:
         constructorFunction = src_client_Account.fromECDSASECP256K1PublicKey.bind(src_client_Account);
         break;
-      case client_account_AccountKeyAlgorithm.ECDSA_SECP256R1:
+      case client_AccountKeyAlgorithm.ECDSA_SECP256R1:
         constructorFunction = src_client_Account.fromECDSASECP256R1PublicKey.bind(src_client_Account);
         break;
-      case client_account_AccountKeyAlgorithm.ED25519:
+      case client_AccountKeyAlgorithm.ED25519:
         constructorFunction = src_client_Account.fromED25519PublicKey.bind(src_client_Account);
         break;
-      case client_account_AccountKeyAlgorithm.NETWORK:
-      case client_account_AccountKeyAlgorithm.TOKEN:
-      case client_account_AccountKeyAlgorithm.STORAGE:
-      case client_account_AccountKeyAlgorithm.MULTISIG:
+      case client_AccountKeyAlgorithm.NETWORK:
+      case client_AccountKeyAlgorithm.TOKEN:
+      case client_AccountKeyAlgorithm.STORAGE:
+      case client_AccountKeyAlgorithm.MULTISIG:
         constructorFunction = function (input) {
           return src_client_Account.fromIdentifierPublicKey.bind(src_client_Account)(input, keyType);
         };
@@ -120907,25 +121738,25 @@ class src_client_Account {
    */
 
   static fromSeed(seed, index) {
-    let keyType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : client_account_AccountKeyAlgorithm.ECDSA_SECP256K1;
+    let keyType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : client_AccountKeyAlgorithm.ECDSA_SECP256K1;
     if (typeof seed === 'bigint') {
       seed = new src_client_BufferStorage(seed, 32).get();
     }
     let privateKey;
     switch (keyType) {
-      case client_account_AccountKeyAlgorithm.ECDSA_SECP256K1:
+      case client_AccountKeyAlgorithm.ECDSA_SECP256K1:
         privateKey = src_client_ECDSASECP256K1KeyPair.fromSeed(seed, index);
         break;
-      case client_account_AccountKeyAlgorithm.ECDSA_SECP256R1:
+      case client_AccountKeyAlgorithm.ECDSA_SECP256R1:
         privateKey = src_client_ECDSASECP256R1KeyPair.fromSeed(seed, index);
         break;
-      case client_account_AccountKeyAlgorithm.ED25519:
+      case client_AccountKeyAlgorithm.ED25519:
         privateKey = src_client_ED25519KeyPair.fromSeed(seed, index);
         break;
-      case client_account_AccountKeyAlgorithm.NETWORK:
-      case client_account_AccountKeyAlgorithm.TOKEN:
-      case client_account_AccountKeyAlgorithm.STORAGE:
-      case client_account_AccountKeyAlgorithm.MULTISIG:
+      case client_AccountKeyAlgorithm.NETWORK:
+      case client_AccountKeyAlgorithm.TOKEN:
+      case client_AccountKeyAlgorithm.STORAGE:
+      case client_AccountKeyAlgorithm.MULTISIG:
         privateKey = src_client_IdentifierKeyPair.fromSeed(seed, index, keyType);
         break;
     }
@@ -120934,11 +121765,11 @@ class src_client_Account {
 
   // Create a network address from the network ID
   static generateNetworkAddress(networkId) {
-    return src_client_Account.fromSeed(networkId, 0, client_account_AccountKeyAlgorithm.NETWORK);
+    return src_client_Account.fromSeed(networkId, 0, client_AccountKeyAlgorithm.NETWORK);
   }
   static generateBaseAddresses(networkId) {
     const networkAddress = this.generateNetworkAddress(networkId);
-    const baseToken = networkAddress.generateIdentifier(client_account_AccountKeyAlgorithm.TOKEN, undefined, 0);
+    const baseToken = networkAddress.generateIdentifier(client_AccountKeyAlgorithm.TOKEN, undefined, 0);
     return {
       networkAddress,
       baseToken
@@ -121183,8 +122014,8 @@ class src_client_Account {
     }
     if (this.isIdentifier()) {
       // A valid first token must be NO_PREVIOUS, generating from a network identifier, and have an operation index of 0
-      const selfIsNetwork = client_account_classPrivateFieldGet(client_keyType4, this) === client_account_AccountKeyAlgorithm.NETWORK;
-      const isGeneratingToken = type === client_account_AccountKeyAlgorithm.TOKEN;
+      const selfIsNetwork = client_account_classPrivateFieldGet(client_keyType4, this) === client_AccountKeyAlgorithm.NETWORK;
+      const isGeneratingToken = type === client_AccountKeyAlgorithm.TOKEN;
       const isFirstOperation = operationIndex === 0;
       const validFirstToken = selfIsNetwork && isGeneratingToken && isFirstOperation && isOpening;
 
@@ -121254,9 +122085,9 @@ class src_client_Account {
   get signatureSize() {
     /** EcDSA and Ed25519 both have 64-byte signatures, so hard code this value for now */
     switch (client_account_classPrivateFieldGet(client_keyType4, this)) {
-      case client_account_AccountKeyAlgorithm.ECDSA_SECP256K1:
-      case client_account_AccountKeyAlgorithm.ECDSA_SECP256R1:
-      case client_account_AccountKeyAlgorithm.ED25519:
+      case client_AccountKeyAlgorithm.ECDSA_SECP256K1:
+      case client_AccountKeyAlgorithm.ECDSA_SECP256R1:
+      case client_AccountKeyAlgorithm.ED25519:
         return 64;
       default:
         return null;
@@ -121287,22 +122118,22 @@ class src_client_Account {
     return this.keyType === checkKeyType;
   }
   isStorage() {
-    return this.isKeyType(client_account_AccountKeyAlgorithm.STORAGE);
+    return this.isKeyType(client_AccountKeyAlgorithm.STORAGE);
   }
   isNetwork() {
-    return this.isKeyType(client_account_AccountKeyAlgorithm.NETWORK);
+    return this.isKeyType(client_AccountKeyAlgorithm.NETWORK);
   }
   isToken() {
-    return this.isKeyType(client_account_AccountKeyAlgorithm.TOKEN);
+    return this.isKeyType(client_AccountKeyAlgorithm.TOKEN);
   }
   isMultisig() {
-    return this.isKeyType(client_account_AccountKeyAlgorithm.MULTISIG);
+    return this.isKeyType(client_AccountKeyAlgorithm.MULTISIG);
   }
   assertKeyType(keyType) {
     // We need to assert this type because we are changing what the constructed type is
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     if (this.keyType !== keyType) {
-      throw new Error(`Operation required ${client_account_AccountKeyAlgorithm[keyType]} but got ${client_account_AccountKeyAlgorithm[this.keyType]}`);
+      throw new Error(`Operation required ${client_AccountKeyAlgorithm[keyType]} but got ${client_AccountKeyAlgorithm[this.keyType]}`);
     }
 
     // We need to assert this type because we are changing what the constructed type is
@@ -121335,7 +122166,7 @@ client_Account = src_client_Account;
 /*
  * Make the things we export static methods since this is our default export
  */
-client_lib_account_defineProperty(src_client_Account, "AccountKeyAlgorithm", client_account_AccountKeyAlgorithm);
+client_lib_account_defineProperty(src_client_Account, "AccountKeyAlgorithm", client_AccountKeyAlgorithm);
 client_lib_account_defineProperty(src_client_Account, "ExternalKeyPair", src_client_ExternalKeyPair);
 client_lib_account_defineProperty(src_client_Account, "isInstance", client_checkableGenerator(client_Account));
 client_lib_account_defineProperty(src_client_Account, "Set", client_setGenerator(client_Account, function (account) {
@@ -121394,7 +122225,9 @@ const client_VoteErrorCodes = [
 // Errors from the blockHashesFromVote function
 'MALFORMED_HASHES_FROM_VOTE_INVALID_INPUT', 'MALFORMED_HASHES_FROM_VOTE_INVALID_TYPE', 'MALFORMED_HASHES_FROM_VOTE_INVALID_CONTEXT_SPECIFIC', 'MALFORMED_HASHES_FROM_VOTE_DATA_NEEDS_OID', 'MALFORMED_HASHES_FROM_VOTE_DATA_HASH_DATA_MUST_BE_SEQUENCE', 'MALFORMED_HASHES_FROM_VOTE_DATA_NOT_TWO_ITEMS', 'MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_FUNC', 'MALFORMED_HASHES_FROM_VOTE_DATA_UNSUPPORTED_HASH_TYPE', 'MALFORMED_HASHES_FROM_VOTE_DATA_SECOND_MUST_BE_SEQUENCE',
 // Errors from the feesFromVote function
-'MALFORMED_FEES_AMOUNT', 'MALFORMED_FEES_FROM_VOTE_INVALID_INPUT', 'MALFORMED_FEES_IN_PERMANENT_VOTE', 'MALFORMED_FEES_PAY_TO_INVALID', 'MALFORMED_FEES_TOKEN_NOT_TOKEN'];
+'MALFORMED_FEES_AMOUNT', 'MALFORMED_FEES_FROM_VOTE_INVALID_INPUT', 'MALFORMED_FEES_IN_PERMANENT_VOTE', 'MALFORMED_FEES_PAY_TO_INVALID', 'MALFORMED_FEES_TOKEN_NOT_TOKEN',
+// Fee Quote Errors
+'FEE_IS_QUOTE', 'FEE_QUOTE_MISSING_FEES', 'FEE_NOT_QUOTE', 'MALFORMED_FEES_KIND_MISSING', 'MALFORMED_FEES_QUOTE_INVALID'];
 class src_client_KeetaNetVoteError extends src_client_KeetaNetError {
   constructor(code, message) {
     super(code, message, {
@@ -121407,7 +122240,7 @@ client_KeetaNetVoteError = src_client_KeetaNetVoteError;
 client_vote_defineProperty(src_client_KeetaNetVoteError, "isInstance", client_checkableGenerator(client_KeetaNetVoteError));
 ;// ./src/lib/vote.ts
 /* provided dependency */ var client_vote_Buffer = __webpack_require__(8287)["Buffer"];
-var client_VoteHash, client_VoteBlockHash, client_PossiblyExpiredVote, client_Vote, client_VoteStapleHash, client_VoteBlockBundle, client_VoteStaple, client_VoteBuilder;
+var client_VoteHash, client_VoteBlockHash, client_VoteLikeBase, client_PossiblyExpiredVote, client_Vote, client_VoteQuote, client_VoteStapleHash, client_VoteBlockBundle, client_VoteStaple, client_BaseVoteBuilder, client_VoteBuilder, client_VoteQuoteBuilder;
 function client_vote_classPrivateMethodInitSpec(e, a) { client_vote_checkPrivateRedeclaration(e, a), a.add(e); }
 function client_vote_classPrivateFieldInitSpec(e, t, a) { client_vote_checkPrivateRedeclaration(e, t), t.set(e, a); }
 function client_vote_checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
@@ -121454,7 +122287,7 @@ const client_feeExtensionSchema = {
   type: 'context',
   value: 0,
   kind: 'explicit',
-  contains: [client_ValidateASN1.IsInteger, {
+  contains: [client_ValidateASN1.IsBoolean, client_ValidateASN1.IsInteger, {
     optional: {
       type: 'context',
       value: 0,
@@ -121564,29 +122397,33 @@ function client_feeFromVote(input) {
     }
   }();
   const feeData = feeInformation.contains;
+  const quote = feeData[0];
   const retval = {
-    amount: feeData[0]
+    quote: quote,
+    fee: {
+      amount: feeData[1]
+    }
   };
-  const payToAsn1 = feeData[1];
+  const payToAsn1 = feeData[2];
   if (payToAsn1 !== undefined) {
     const payTo = client_lib_account.fromPublicKeyAndType(client_vote_Buffer.from(payToAsn1.contains));
     if (payTo.isStorage()) {
-      retval.payTo = payTo;
+      retval.fee.payTo = payTo;
     } else {
       try {
-        retval.payTo = payTo.assertAccount();
+        retval.fee.payTo = payTo.assertAccount();
       } catch {
         throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_PAY_TO_INVALID', 'internal error: payTo is not an Account or Storage Address');
       }
     }
   }
-  const tokenAsn1 = feeData[2];
+  const tokenAsn1 = feeData[3];
   if (tokenAsn1 !== undefined) {
     const token = client_lib_account.fromPublicKeyAndType(client_vote_Buffer.from(tokenAsn1.contains));
     if (!token.isToken()) {
       throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_TOKEN_NOT_TOKEN', 'internal error: fees extension token is not a valid token');
     }
-    retval.token = token;
+    retval.fee.token = token;
   }
   return retval;
 }
@@ -121736,7 +122573,11 @@ var client_vote = /*#__PURE__*/new WeakMap();
 var client_options = /*#__PURE__*/new WeakMap();
 var client_vote_hash = /*#__PURE__*/new WeakMap();
 var client_blocksHash = /*#__PURE__*/new WeakMap();
-class src_client_PossiblyExpiredVote {
+class src_client_VoteLikeBase {
+  getClass() {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return this.constructor;
+  }
   static isValidJSON(voteJSON) {
     for (const checkField of ['issuer', 'serial', 'blocks', 'validityFrom', 'validityTo', 'signature']) {
       if (voteJSON[checkField] === undefined) {
@@ -121758,11 +122599,17 @@ class src_client_PossiblyExpiredVote {
         return false;
       }
     }
+    if ('quote' in voteJSON) {
+      if (voteJSON['quote'] === undefined) {
+        return false;
+      }
+    }
     return true;
   }
   static fromJSON(voteJSON) {
+    var _voteJSON$quote;
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    if (!src_client_PossiblyExpiredVote.isValidJSON(voteJSON)) {
+    if (!src_client_VoteLikeBase.isValidJSON(voteJSON)) {
       throw new src_client_KeetaNetVoteError('VOTE_INVALID_CONSTRUCTION_JSON', 'Cannot construct vote, it is not a valid vote JSON object');
     }
     const issuer = client_lib_account.toAccount(voteJSON.issuer);
@@ -121780,6 +122627,12 @@ class src_client_PossiblyExpiredVote {
     const validTo = new Date(voteJSON.validityTo);
     const validFrom = new Date(voteJSON.validityFrom);
     const signatureStorage = new src_client_BufferStorage(signature, signature.byteLength);
+    if (this.expectedQuoteValue !== ((_voteJSON$quote = voteJSON.quote) !== null && _voteJSON$quote !== void 0 ? _voteJSON$quote : false)) {
+      throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_QUOTE_INVALID', `internal error: fee quote mismatch found ${voteJSON.quote} - expected ${this.expectedQuoteValue}`);
+    }
+    if (voteJSON.quote === true && voteJSON.fee === undefined) {
+      throw new src_client_KeetaNetVoteError('VOTE_FEE_QUOTE_MISSING_FEES', 'internal error: requested quote but no fees provided');
+    }
     if (voteJSON.fee !== undefined) {
       voteBuilder.addFee(voteJSON.fee);
     }
@@ -121788,8 +122641,10 @@ class src_client_PossiblyExpiredVote {
       tbsCertificate,
       signatureInfo
     } = voteBuilder.generateVoteData(BigInt(voteJSON.serial), validTo, validFrom);
-    const vote = voteBuilder.createVote(voteData, tbsCertificate, signatureInfo, signatureStorage, options);
-    return vote;
+    const vote = voteBuilder.createVote(voteData, tbsCertificate, signatureInfo, signatureStorage);
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return new this(vote, options);
   }
   constructor(vote) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
@@ -121802,7 +122657,7 @@ class src_client_PossiblyExpiredVote {
     client_vote_classPrivateFieldSet(client_options, this, {
       ...options
     });
-    if (src_client_PossiblyExpiredVote.isInstance(vote, false)) {
+    if (src_client_VoteLikeBase.isInstance(vote, false)) {
       this.issuer = vote.issuer;
       this.serial = vote.serial;
       this.blocks = vote.blocks;
@@ -121810,6 +122665,7 @@ class src_client_PossiblyExpiredVote {
       this.validityTo = vote.validityTo;
       this.signature = vote.signature;
       this.fee = vote.fee;
+      this.quote = vote.quote;
       this.$trusted = vote.$trusted;
       this.$permanent = vote.$permanent;
       this.$uid = vote.$uid;
@@ -121828,10 +122684,10 @@ class src_client_PossiblyExpiredVote {
       vote = client_bufferToArrayBuffer(vote);
     }
     if (!client_util.types.isArrayBuffer(vote)) {
-      if (src_client_PossiblyExpiredVote.isValidJSON(vote)) {
-        vote = src_client_PossiblyExpiredVote.fromJSON(vote).toBytes();
+      if (src_client_VoteLikeBase.isValidJSON(vote)) {
+        vote = src_client_VoteLikeBase.fromJSON(vote).toBytes();
       } else {
-        throw new src_client_KeetaNetVoteError('VOTE_INVALID_CONSTRUCTION', 'internal error: invalid vote constructor argument in PossiblyExpiredVote');
+        throw new src_client_KeetaNetVoteError('VOTE_INVALID_CONSTRUCTION', 'internal error: invalid vote constructor argument in VoteLikeBase');
       }
     }
     client_vote_classPrivateFieldSet(client_vote, this, vote);
@@ -121948,14 +122804,14 @@ class src_client_PossiblyExpiredVote {
      * Votes must not be expired
      */
     const expirationCheckMomentISO = new Date(expirationCheckMoment).toISOString();
-    if (expirationCheckMoment < this.validityFrom.valueOf() - src_client_PossiblyExpiredVote.allowedSlop) {
+    if (expirationCheckMoment < this.validityFrom.valueOf() - src_client_VoteLikeBase.allowedSlop) {
       throw new src_client_KeetaNetVoteError('VOTE_MOMENT_BEFORE_VALIDITY_FROM', `Vote was issued in the future (issued on ${validFrom.toISOString()}; moment: ${expirationCheckMomentISO})`);
     }
 
     /**
      * If the vote is forever viable, it is a permanent vote
      */
-    if (this.validityTo.valueOf() > expirationCheckMoment + src_client_PossiblyExpiredVote.permanentVoteThreshold) {
+    if (this.validityTo.valueOf() > expirationCheckMoment + src_client_VoteLikeBase.permanentVoteThreshold) {
       this.$permanent = true;
     }
 
@@ -122023,7 +122879,7 @@ class src_client_PossiblyExpiredVote {
       throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_EXTENSIONS', 'internal error: Expected extensions to be a Sequence');
     }
     let blocks;
-    let fee;
+    let feeAndKind;
     for (const extensionInfo of extensions) {
       if (!Array.isArray(extensionInfo)) {
         throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_EXTENSIONS_VALUE', 'internal error: Expected each extension to be a Sequence');
@@ -122057,7 +122913,7 @@ class src_client_PossiblyExpiredVote {
         case '1.3.6.1.4.1.62675.0.1.0':
         case 'fees':
           // replace with fees 1.3.6.1.4.1.62675.0.1.0
-          fee = client_feeFromVote(extensionData);
+          feeAndKind = client_feeFromVote(extensionData);
           break;
         default:
           if (critical) {
@@ -122072,11 +122928,16 @@ class src_client_PossiblyExpiredVote {
       throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_NO_BLOCKS_FOUND', 'No block hashes found within vote');
     }
     this.blocks = blocks;
-    if (fee !== undefined) {
+    if (feeAndKind !== undefined) {
       if (this.$permanent) {
         throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_IN_PERMANENT_VOTE', 'Permanent Vote cannot have fees');
       }
-      this.fee = fee;
+      // Get the expected quote value from any child instances and compare
+      if (feeAndKind.quote !== this.getClass().expectedQuoteValue) {
+        throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_QUOTE_INVALID', `internal error: fee quote mismatch found ${feeAndKind.quote} - expected ${this.getClass().expectedQuoteValue}`);
+      }
+      this.fee = feeAndKind.fee;
+      this.quote = feeAndKind.quote;
     }
 
     /**
@@ -122107,7 +122968,7 @@ class src_client_PossiblyExpiredVote {
     }
     switch (voteSignatureInfoOID) {
       case `${client_hash_Hash.functionName}WithEcDSA`:
-        if (this.issuer.keyType !== client_account_AccountKeyAlgorithm.ECDSA_SECP256K1 && this.issuer.keyType !== client_account_AccountKeyAlgorithm.ECDSA_SECP256R1) {
+        if (this.issuer.keyType !== client_AccountKeyAlgorithm.ECDSA_SECP256K1 && this.issuer.keyType !== client_AccountKeyAlgorithm.ECDSA_SECP256R1) {
           throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER', 'internal error: Signature scheme does not match issuer ECDSA curve (EcDSA)');
         }
 
@@ -122118,7 +122979,7 @@ class src_client_PossiblyExpiredVote {
         toVerify = client_hash_Hash(client_vote_Buffer.from(tbsCertificate));
         break;
       case 'ed25519':
-        if (this.issuer.keyType !== client_account_AccountKeyAlgorithm.ED25519) {
+        if (this.issuer.keyType !== client_AccountKeyAlgorithm.ED25519) {
           throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_VOTE_SIGNATURE_SCHEME_DOES_NOT_MATCH_ISSUER', 'internal error: Signature scheme does not match issuer (Ed25519)');
         }
         toVerify = tbsCertificate;
@@ -122195,6 +123056,9 @@ class src_client_PossiblyExpiredVote {
     if (this.fee !== undefined) {
       additionalFields['fee'] = this.fee;
     }
+    if (this.quote !== undefined) {
+      additionalFields['quote'] = this.quote;
+    }
     return {
       issuer: this.issuer,
       serial: this.serial,
@@ -122222,21 +123086,33 @@ class src_client_PossiblyExpiredVote {
     const now = this.expirationCheckMoment();
     const from = this.validityFrom.valueOf();
     const to = this.validityTo.valueOf();
-    if (now + src_client_PossiblyExpiredVote.allowedSlop < from || now - src_client_PossiblyExpiredVote.allowedSlop > to) {
+    if (now + src_client_VoteLikeBase.allowedSlop < from || now - src_client_VoteLikeBase.allowedSlop > to) {
       return true;
     }
     return false;
   }
 }
+client_VoteLikeBase = src_client_VoteLikeBase;
+client_lib_vote_defineProperty(src_client_VoteLikeBase, "expectedQuoteValue", false);
+client_lib_vote_defineProperty(src_client_VoteLikeBase, "allowedSlop", 60 /* s */ * 1000 /* ms */);
+client_lib_vote_defineProperty(src_client_VoteLikeBase, "permanentVoteThreshold", 100 /* y */ * 365 /* d */ * 86400 /* s */ * 1000 /* ms */);
+client_lib_vote_defineProperty(src_client_VoteLikeBase, "VoteBlocksHash", src_client_VoteBlockHash);
+client_lib_vote_defineProperty(src_client_VoteLikeBase, "isInstance", client_checkableGenerator(client_VoteLikeBase));
+class src_client_PossiblyExpiredVote extends src_client_VoteLikeBase {
+  constructor(vote) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super(vote, options);
+    if (this.quote === true) {
+      throw new src_client_KeetaNetVoteError('VOTE_FEE_IS_QUOTE', `Tried to construct a vote but fee kind is QUOTE`);
+    }
+  }
+}
 
 /**
  * A vote is a certificate issued indicating that the issuer "vouches" for the
  * blocks specified will fit into the ledger of the operator/issuer.
  */
 client_PossiblyExpiredVote = src_client_PossiblyExpiredVote;
-client_lib_vote_defineProperty(src_client_PossiblyExpiredVote, "allowedSlop", 60 /* s */ * 1000 /* ms */);
-client_lib_vote_defineProperty(src_client_PossiblyExpiredVote, "permanentVoteThreshold", 100 /* y */ * 365 /* d */ * 86400 /* s */ * 1000 /* ms */);
-client_lib_vote_defineProperty(src_client_PossiblyExpiredVote, "VoteBlocksHash", src_client_VoteBlockHash);
 client_lib_vote_defineProperty(src_client_PossiblyExpiredVote, "isInstance", client_checkableGenerator(client_PossiblyExpiredVote));
 class src_client_Vote extends src_client_PossiblyExpiredVote {
   constructor(vote) {
@@ -122252,11 +123128,33 @@ class src_client_Vote extends src_client_PossiblyExpiredVote {
 }
 
 /**
- * A vote staple is a distributable block consisting of one or more blocks
- * and one or more votes.
+ * A VoteQuote is a certificate issued indicating what the issuer will charge for fees
  */
 client_Vote = src_client_Vote;
 client_lib_vote_defineProperty(src_client_Vote, "isInstance", client_checkableGenerator(client_Vote));
+class src_client_VoteQuote extends src_client_VoteLikeBase {
+  constructor(vote) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super(vote, options);
+    // We add this so both classes have different signatures
+    client_lib_vote_defineProperty(this, "isVoteQuote", true);
+    if (this.expired) {
+      const expirationCheckMomentISO = new Date(this.expirationCheckMoment()).toISOString();
+      throw new src_client_KeetaNetVoteError('VOTE_EXPIRED', `VoteQuote is expired (expired on ${this.validityTo.toISOString()}; issued on ${this.validityFrom.toISOString()}; moment: ${expirationCheckMomentISO})`);
+    }
+    if (!this.quote) {
+      throw new src_client_KeetaNetVoteError('VOTE_FEE_NOT_QUOTE', `Tried to construct a quote but fee kind is note QUOTE`);
+    }
+  }
+}
+
+/**
+ * A vote staple is a distributable block consisting of one or more blocks
+ * and one or more votes.
+ */
+client_VoteQuote = src_client_VoteQuote;
+client_lib_vote_defineProperty(src_client_VoteQuote, "expectedQuoteValue", true);
+client_lib_vote_defineProperty(src_client_VoteQuote, "isInstance", client_checkableGenerator(client_VoteQuote));
 class src_client_VoteStapleHash extends src_client_BufferStorage {
   get hashFunctionName() {
     return client_hash_Hash.functionName;
@@ -122480,8 +123378,10 @@ class src_client_VoteBlockBundle {
       votesStapled = client_bufferToArrayBuffer(votesStapled);
     }
     if (!client_util.types.isArrayBuffer(votesStapled)) {
-      if (src_client_VoteBlockBundle.isValidJSON(votesStapled)) {
-        votesStapled = src_client_VoteBlockBundle.fromJSON(votesStapled).toBytes(true);
+      if (votesStapled instanceof src_client_VoteBlockBundle) {
+        votesStapled = votesStapled.toBytes(true);
+      } else if (src_client_VoteBlockBundle.isValidJSON(votesStapled)) {
+        votesStapled = src_client_VoteBlockBundle.fromJSON(votesStapled, voteOptions).toBytes(true);
       } else {
         throw new src_client_KeetaNetVoteError('VOTE_STAPLE_INVALID_CONSTRUCTION', 'internal error: votesStapled must be an ArrayBuffer');
       }
@@ -122700,13 +123600,14 @@ client_lib_vote_defineProperty(src_client_VoteStaple, "isInstance", client_check
 var client_account = /*#__PURE__*/new WeakMap();
 var client_blocks = /*#__PURE__*/new WeakMap();
 var client_fee = /*#__PURE__*/new WeakMap();
-class src_client_VoteBuilder {
+class src_client_BaseVoteBuilder {
   constructor(account) {
     let blocks = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
     let options = arguments.length > 2 ? arguments[2] : undefined;
     client_vote_classPrivateFieldInitSpec(this, client_account, void 0);
     client_vote_classPrivateFieldInitSpec(this, client_blocks, void 0);
     client_vote_classPrivateFieldInitSpec(this, client_fee, undefined);
+    client_lib_vote_defineProperty(this, "quote", false);
     if (!client_lib_account.isInstance(account)) {
       throw new src_client_KeetaNetVoteError('VOTE_BUILDER_INVALID_CONSTRUCTION', 'internal error: account must be an Account');
     }
@@ -122746,12 +123647,13 @@ class src_client_VoteBuilder {
         fee.payTo = payTo.assertAccount();
       }
     }
-    const token = client_lib_account.toAccount(fee.token);
+    const token = client_lib_account.toAccount(feeInput.token);
     if (token !== undefined) {
       if (token.isToken()) {
         fee.token = token;
+      } else {
+        throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_TOKEN_NOT_TOKEN', 'Fee Token should be of type TOKEN');
       }
-      throw new src_client_KeetaNetVoteError('VOTE_MALFORMED_FEES_TOKEN_NOT_TOKEN', 'Fee Token should be of type TOKEN');
     }
     client_vote_classPrivateFieldSet(client_fee, this, fee);
   }
@@ -122766,7 +123668,8 @@ class src_client_VoteBuilder {
      */
     let hashData = false;
     switch (client_vote_classPrivateFieldGet(client_account, this).keyType) {
-      case client_account_AccountKeyAlgorithm.ECDSA_SECP256K1:
+      case client_AccountKeyAlgorithm.ECDSA_SECP256K1:
+      case client_AccountKeyAlgorithm.ECDSA_SECP256R1:
         {
           /*
            * Use the default hashing function
@@ -122777,7 +123680,7 @@ class src_client_VoteBuilder {
           hashData = true;
         }
         break;
-      case client_account_AccountKeyAlgorithm.ED25519:
+      case client_AccountKeyAlgorithm.ED25519:
         /* Ed25519 data does not get hashed */
         signatureInfoOID = 'ed25519';
         hashData = false;
@@ -122800,7 +123703,7 @@ class src_client_VoteBuilder {
     if (client_vote_classPrivateFieldGet(client_fee, this) !== undefined) {
       var _classPrivateFieldGet2, _classPrivateFieldGet3;
       /** Amount for this vote */
-      const feeData = [client_vote_classPrivateFieldGet(client_fee, this).amount];
+      const feeData = [this.quote, client_vote_classPrivateFieldGet(client_fee, this).amount];
 
       /** Account to pay the fee too */
       const payToPublicKey = (_classPrivateFieldGet2 = client_vote_classPrivateFieldGet(client_fee, this).payTo) === null || _classPrivateFieldGet2 === void 0 ? void 0 : _classPrivateFieldGet2.publicKeyAndType;
@@ -122929,7 +123832,6 @@ class src_client_VoteBuilder {
     };
   }
   createVote(voteData, tbsCertificate, signatureInfo, signature) {
-    let voteOptions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
     /**
      * Double-check that the signature we just created is valid for the data
      */
@@ -122953,10 +123855,9 @@ class src_client_VoteBuilder {
      * Vote: A DER-encoded certificate
      */
     const vote = certificate.toBER(false);
-    return new src_client_Vote(vote, voteOptions);
+    return vote;
   }
-  async seal(serial, validTo, validFrom) {
-    let voteOptions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  async generate(serial, validTo, validFrom) {
     if (validFrom === undefined) {
       validFrom = new Date();
     }
@@ -122977,6 +123878,9 @@ class src_client_VoteBuilder {
     if (!client_util.types.isDate(validFrom) || !client_util.types.isDate(validTo)) {
       throw new src_client_KeetaNetVoteError('VOTE_BUILDER_INVALID_VALID_TO_FROM', 'internal error: validFrom must be Date');
     }
+    if (this.quote && client_vote_classPrivateFieldGet(client_fee, this) === undefined) {
+      throw new src_client_KeetaNetVoteError('VOTE_FEE_QUOTE_MISSING_FEES', 'internal error: requested quote but no fees provided');
+    }
     const {
       voteData,
       tbsCertificate,
@@ -122986,14 +123890,42 @@ class src_client_VoteBuilder {
       raw: true,
       forCert: true
     });
-    const vote = this.createVote(voteData, tbsCertificate, signatureInfo, signature, voteOptions);
+    const voteLike = this.createVote(voteData, tbsCertificate, signatureInfo, signature);
+    return voteLike;
+  }
+}
+client_BaseVoteBuilder = src_client_BaseVoteBuilder;
+client_lib_vote_defineProperty(src_client_BaseVoteBuilder, "isInstance", client_checkableGenerator(client_BaseVoteBuilder));
+class src_client_VoteBuilder extends src_client_BaseVoteBuilder {
+  async seal(serial, validTo, validFrom) {
+    let voteOptions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const vote = await super.generate(serial, validTo, validFrom);
     return new src_client_Vote(vote, voteOptions);
   }
 }
 client_VoteBuilder = src_client_VoteBuilder;
 client_lib_vote_defineProperty(src_client_VoteBuilder, "isInstance", client_checkableGenerator(client_VoteBuilder));
-src_client_PossiblyExpiredVote.Staple = src_client_VoteStaple;
-src_client_PossiblyExpiredVote.Builder = src_client_VoteBuilder;
+class src_client_VoteQuoteBuilder extends src_client_BaseVoteBuilder {
+  constructor() {
+    super(...arguments);
+    client_lib_vote_defineProperty(this, "quote", true);
+  }
+  async seal(serial, validTo, validFrom) {
+    let voteOptions = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+    const voteQuote = await super.generate(serial, validTo, validFrom);
+    return new src_client_VoteQuote(voteQuote, voteOptions);
+  }
+}
+
+// Add respective builders to each
+client_VoteQuoteBuilder = src_client_VoteQuoteBuilder;
+client_lib_vote_defineProperty(src_client_VoteQuoteBuilder, "isInstance", client_checkableGenerator(client_VoteQuoteBuilder));
+src_client_VoteLikeBase.Builder = src_client_BaseVoteBuilder;
+src_client_VoteQuote.Builder = src_client_VoteQuoteBuilder;
+src_client_Vote.Builder = src_client_VoteBuilder;
+// Add to default export
+src_client_Vote.Staple = src_client_VoteStaple;
+src_client_Vote.Quote = src_client_VoteQuote;
 /* harmony default export */ const client_lib_vote = (src_client_Vote);
 
 /** @internal */
@@ -123008,6 +123940,7 @@ const src_client_Testing = {
 
 
 
+
 /**
  * Change of certificate indication
  */
@@ -123016,6 +123949,8 @@ const src_client_Testing = {
  * Which fields may be affected by blocks
  */
 
+;
+
 /**
  * Which accounts and fields are affected by a set of block
  */
@@ -123024,6 +123959,34 @@ const src_client_Testing = {
  * A breakdown of computed effects by account public key
  */
 
+/**
+ * Base Fee Units per Block
+ */
+const client_baseBlockFeeUnit = 1000n;
+/**
+ * Fee Unit for an Opening Block
+ */
+const client_openingBlockFeeUnit = 10000n;
+/**
+ * Operation specific Fee Units
+ */
+const client_operationFeeUnitOverrides = {
+  [client_OperationType.SEND]: 10n,
+  [client_OperationType.SET_REP]: 20n,
+  [client_OperationType.SET_INFO]: 100n,
+  [client_OperationType.MODIFY_PERMISSIONS]: 20n,
+  [client_OperationType.CREATE_IDENTIFIER]: 200n,
+  [client_OperationType.TOKEN_ADMIN_SUPPLY]: 10n,
+  [client_OperationType.TOKEN_ADMIN_MODIFY_BALANCE]: 10n,
+  [client_OperationType.RECEIVE]: 10n,
+  [client_OperationType.MANAGE_CERTIFICATE]: 100n
+};
+/**
+ * Get the Fee Unit for a given operation type
+ */
+function client_getOperationFeeUnit(operation) {
+  return client_operationFeeUnitOverrides[operation];
+}
 function client_addOrCombineRequirements(existing, addition, alwaysCombine) {
   const resp = [...existing];
   let additionTarget;
@@ -123129,6 +124092,19 @@ function client_addPermissionRequirement(state, requirement) {
   const existing = (_state$accounts$princ2 = state.accounts[principalPubKey].fields.permissionRequirements) !== null && _state$accounts$princ2 !== void 0 ? _state$accounts$princ2 : [];
   state.accounts[principalPubKey].fields.permissionRequirements = client_addOrCombineRequirements(existing, requirement, true);
 }
+function client_updateMinSignerSetLength(state, multisigAccount, count) {
+  const multisigPublicKey = multisigAccount.publicKeyString.get();
+  if (state.accounts[multisigPublicKey] === undefined) {
+    state.accounts[multisigPublicKey] = {
+      account: multisigAccount,
+      fields: {}
+    };
+  }
+  const current = state.accounts[multisigPublicKey].fields.minSignerSetLength;
+  if (current === undefined || current > count) {
+    state.accounts[multisigPublicKey].fields.minSignerSetLength = count;
+  }
+}
 function client_modifyBalanceInState(balanceState) {
   var _accountBalanceInfo$t;
   const {
@@ -123181,6 +124157,31 @@ function client_modifyBalanceInState(balanceState) {
   }
   accountBalanceInfo[tokenPubKey] = tokenField;
 }
+function client_updateAccountInfoInState(state, account, info) {
+  const accountPubKey = account.publicKeyString.get();
+  const toUpdate = {
+    name: info.name,
+    description: info.description,
+    metadata: info.metadata
+  };
+  if (account.isIdentifier()) {
+    if (info.defaultPermission !== undefined) {
+      toUpdate.defaultPermission = info.defaultPermission;
+    }
+    if (account.isMultisig() && info.multisigQuorum !== undefined) {
+      toUpdate.multisigQuorum = info.multisigQuorum;
+    }
+  } else {
+    state.possibleNewAccounts.add(account);
+  }
+  if (!state.accounts[accountPubKey]) {
+    state.accounts[accountPubKey] = {
+      account: account,
+      fields: {}
+    };
+  }
+  state.accounts[accountPubKey].fields.info = toUpdate;
+}
 
 /**
  * Compute the effect of a SEND operation
@@ -123316,33 +124317,40 @@ function client_computeEffectOfOperationCREATE_IDENTIFIER(state, block, operatio
   }
   state.possibleNewAccounts.add(operation.identifier);
   (_state$accounts$accou = state.accounts[accountPubKey].fields.createRequests) === null || _state$accounts$accou === void 0 || _state$accounts$accou.push({
-    previousBlockHash: block.previous,
-    account: block.account,
-    requestedIdentifier: operation.identifier,
-    operationIndex: context.operationIndex
-  });
-  client_addPermission(state, {
-    principal: block.account,
-    entity: operation.identifier,
-    method: src_client_Block.AdjustMethod.SET,
-    permissions: new client_permissions_Permissions(['OWNER'])
+    createdIdentifier: operation.identifier,
+    createArguments: operation.createArguments
   });
+  if (operation.identifier.isMultisig()) {
+    if (!operation.createArguments || operation.createArguments.type !== client_AccountKeyAlgorithm.MULTISIG) {
+      throw new Error('Invalid identifier creation arguments');
+    }
+    client_updateAccountInfoInState(state, operation.identifier, {
+      multisigQuorum: operation.createArguments.quorum
+    });
+    for (const multisigSigner of operation.createArguments.signers) {
+      client_addPermission(state, {
+        principal: multisigSigner,
+        entity: operation.identifier,
+        method: src_client_Block.AdjustMethod.SET,
+        permissions: new client_permissions_Permissions(['MULTISIG_SIGNER'])
+      });
+    }
+  } else {
+    client_addPermission(state, {
+      principal: block.account,
+      entity: operation.identifier,
+      method: src_client_Block.AdjustMethod.SET,
+      permissions: new client_permissions_Permissions(['OWNER'])
+    });
+  }
 }
 function client_computeEffectOfOperationSET_INFO(state, block, operation) {
-  const accountPubKey = block.account.publicKeyString.get();
-  const toUpdate = {
+  client_updateAccountInfoInState(state, block.account, {
     name: operation.name,
     description: operation.description,
-    metadata: operation.metadata
-  };
-  if (block.account.isIdentifier()) {
-    if (operation.defaultPermission !== undefined) {
-      toUpdate.defaultPermission = operation.defaultPermission;
-    }
-  } else {
-    state.possibleNewAccounts.add(block.account);
-  }
-  state.accounts[accountPubKey].fields.info = toUpdate;
+    metadata: operation.metadata,
+    defaultPermission: operation.defaultPermission
+  });
 }
 function client_computeEffectOfOperationMODIFY_PERMISSIONS(state, block, operation) {
   state.possibleNewAccounts.add(operation.principal);
@@ -123440,7 +124448,7 @@ const client_operationHandlers = {
       const baseEffect = {
         entity: operation.token || context.ledger.baseToken
       };
-      if (operation.to.keyType !== client_account_AccountKeyAlgorithm.STORAGE) {
+      if (operation.to.keyType !== client_AccountKeyAlgorithm.STORAGE) {
         return baseEffect;
       }
       return [baseEffect,
@@ -123489,13 +124497,13 @@ const client_operationHandlers = {
 
       // Different identifier accounts require different permissions to create
       switch (operation.identifier.keyType) {
-        case client_account_AccountKeyAlgorithm.TOKEN:
+        case client_AccountKeyAlgorithm.TOKEN:
           permissionFlags.push('TOKEN_ADMIN_CREATE');
           break;
-        case client_account_AccountKeyAlgorithm.STORAGE:
+        case client_AccountKeyAlgorithm.STORAGE:
           permissionFlags.push('STORAGE_CREATE');
           break;
-        case client_account_AccountKeyAlgorithm.MULTISIG:
+        case client_AccountKeyAlgorithm.MULTISIG:
           /* No additional permission is required to create a multisig */
           break;
         default:
@@ -123587,7 +124595,7 @@ function client_computePermissionEffect(state, type, effect, block, operation, c
   };
   switch (type) {
     case 'SIGNER':
-      baseRequirement.principal = block.signer;
+      baseRequirement.principal = block.principal;
       baseRequirement.entity = block.account;
       break;
     case 'ACCOUNT':
@@ -123644,7 +124652,8 @@ function client_computeEffectOfBlocks(blocks, ledger) {
     possibleNewAccounts: new client_lib_account.Set(),
     metadata: {
       blockCount: 0,
-      operationCount: 0
+      operationCount: 0,
+      feeUnits: 0n
     }
   };
   let onlyReturnTouched = false;
@@ -123667,13 +124676,26 @@ function client_computeEffectOfBlocks(blocks, ledger) {
    */
   for (const block of blocks) {
     accumulatedEffects.metadata.blockCount++;
+    accumulatedEffects.metadata.feeUnits += client_baseBlockFeeUnit;
     const blockAccountPubKey = block.account.publicKeyString.get();
-    accumulatedEffects.touched.add(block.signer);
+    const signerQueue = [block.signer];
+    while (signerQueue.length > 0) {
+      // We can assume that the signerFieldQueue is not empty here since the loop condition checks it
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      const signer = signerQueue.shift();
+      if (client_lib_account.isInstance(signer)) {
+        accumulatedEffects.touched.add(signer);
+        continue;
+      }
+      accumulatedEffects.touched.add(signer[0]);
+      signerQueue.push(...signer[1]);
+    }
     if (block.$opening) {
       accumulatedEffects.possibleNewAccounts.add(block.account);
+      accumulatedEffects.metadata.feeUnits += client_openingBlockFeeUnit;
     }
-    if (!block.signer.comparePublicKey(block.account)) {
-      accumulatedEffects.possibleNewAccounts.add(block.signer);
+    if (!block.principal.comparePublicKey(block.account)) {
+      accumulatedEffects.possibleNewAccounts.add(block.principal);
     }
     if (accumulatedEffects.accounts[blockAccountPubKey] === undefined) {
       accumulatedEffects.accounts[blockAccountPubKey] = {
@@ -123689,12 +124711,13 @@ function client_computeEffectOfBlocks(blocks, ledger) {
       const context = {
         ledger,
         operationIndex: Number(operationIndex),
-        signedByDifferent: !block.account.comparePublicKey(block.signer),
+        signedByDifferent: !block.account.comparePublicKey(block.principal),
         openingBlock: block.$opening
       };
       const operation = block.operations[operationIndex];
       const handler = client_operationHandlers[operation.type];
       accumulatedEffects.metadata.operationCount++;
+      accumulatedEffects.metadata.feeUnits += client_getOperationFeeUnit(operation.type);
       if (handler.accountPermissionACL) {
         client_computePermissionEffect(accumulatedEffects, 'ACCOUNT', handler.accountPermissionACL, block, operation, context);
       }
@@ -123704,6 +124727,29 @@ function client_computeEffectOfBlocks(blocks, ledger) {
           permissionEffect = handler.signerPermissionACL;
         }
         client_computePermissionEffect(accumulatedEffects, 'SIGNER', permissionEffect, block, operation, context);
+        if (Array.isArray(block.signer)) {
+          const signerFieldQueue = [block.signer];
+          while (signerFieldQueue.length > 0) {
+            // We can assume that the signerFieldQueue is not empty here since the loop condition checks it
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const [multisig, signers] = signerFieldQueue.shift();
+            client_updateMinSignerSetLength(accumulatedEffects, multisig, BigInt(signers.length));
+            for (const signer of signers) {
+              let principal;
+              if (client_lib_account.isInstance(signer)) {
+                principal = signer;
+              } else {
+                principal = signer[0];
+                signerFieldQueue.push(signer);
+              }
+              client_addPermissionRequirement(accumulatedEffects, {
+                entity: multisig,
+                principal: principal,
+                permissions: new client_permissions_Permissions(['MULTISIG_SIGNER'])
+              });
+            }
+          }
+        }
       }
       handler.effectGenerator(accumulatedEffects, block, operation, context);
     }
@@ -123994,6 +125040,8 @@ function client_ledger_assertClassBrand(e, t, n) { if ("function" == typeof e ?
 
 
 
+
+
 /**
  * Kind of ledger
  */
@@ -124034,10 +125082,11 @@ 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 client_transaction = /*#__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
@@ -124049,14 +125098,16 @@ class client_LedgerAtomicInterface {
     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, client_transaction, 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);
@@ -124084,16 +125135,27 @@ class client_LedgerAtomicInterface {
     client_ledger_classPrivateFieldSet(client_transaction, this, null);
     await client_ledger_classPrivateFieldGet(client_ledger_storage, this).abortTransaction(transaction);
   }
-  async vote(blocks, otherVotes) {
-    const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
-    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 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');
     }
     if (!client_ledger_classPrivateFieldGet(client_ledger_privateKey, this)) {
       throw new Error('Cannot vote on block, no private key loaded');
     }
+    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 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');
+      }
+      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);
 
     /**
      * If there are other votes, ensure one of them was issued by
@@ -124104,7 +125166,18 @@ class client_LedgerAtomicInterface {
       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');
         }
@@ -124113,14 +125186,17 @@ class client_LedgerAtomicInterface {
         }
         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 !== blocks.length;
+        let blocksDifferFromVoteBlocks = checkVote.blocks.length !== blockCount;
 
         /* If they do not differ from length alone, compare block hashes */
         if (!blocksDifferFromVoteBlocks) {
-          for (let blockIndex = 0; blockIndex < blocks.length; blockIndex++) {
+          for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
             if (!blocks[blockIndex].hash.compareHexString(checkVote.blocks[blockIndex])) {
               blocksDifferFromVoteBlocks = true;
               break;
@@ -124134,72 +125210,46 @@ class client_LedgerAtomicInterface {
           foundOurVote = true;
         }
       }
-      if (!foundOurVote) {
-        throw new client_ledger('LEDGER_NO_PERM_WITHOUT_SELF_TEMP', 'Asked to give a permanent vote without a temporary vote from us');
-      }
-    }
-
-    /**
-     * 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 blocksToCheckOurVotesFor = [];
-    const needToGetHeadFor = new client_lib_account.Set();
-    const expectedHead = {};
-    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`);
+      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');
+        }
       }
-      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`);
+      // 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 (!predecessorBeingVotedOn) {
-        const pubKey = block.account.publicKeyString.get();
-        needToGetHeadFor.add(block.account);
-        expectedHead[pubKey] = block;
+      if (!foundOurVote) {
+        throw new client_ledger('LEDGER_NO_PERM_WITHOUT_SELF_TEMP', 'Asked to give a permanent vote without a temporary vote from us');
       }
-
-      /**
-       * Ensure we have no active vote for another conflicting successor of this block's parent (previous),
-       * which could cause a fork
-       */
-      blocksToCheckOurVotesFor.push(block);
     }
+    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 pubKey in expectedHead) {
-      const expectedBlock = expectedHead[pubKey];
-      const accountHead = allHeads[pubKey];
+    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');
@@ -124213,9 +125263,14 @@ class client_LedgerAtomicInterface {
         throw new client_ledger('LEDGER_NOT_SUCCESSOR', 'The block is not the successor to the account head block');
       }
     }
-    const previousToCheckFor = blocksToCheckOurVotesFor.map(b => b.previous);
+
+    /**
+     * 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 blocksToCheckOurVotesFor) {
+    for (const block of blocks) {
       const previousVotes = allPrevious[block.previous.toString()];
       if (previousVotes !== null && previousVotes.length > 0) {
         /**
@@ -124240,35 +125295,7 @@ class client_LedgerAtomicInterface {
      * If no other votes have been supplied, validate that the blocks are valid, and issue a short vote
      */
     if (otherVotes === undefined) {
-      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()}`);
-        }
-      }
-
-      /**
-       * 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 wipVote = new src_client_VoteBuilder(privateKey);
-      for (const block of blocks) {
-        wipVote.addBlock(block);
-      }
-      const vote = await wipVote.seal(serial, pendingVoteExpiry);
+      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;
@@ -124301,6 +125328,11 @@ class client_LedgerAtomicInterface {
     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 _classPrivateFieldGet2, _classPrivateFieldGet3, _classPrivateFieldGet4, _classPrivateFieldGet5;
     const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
@@ -124651,9 +125683,13 @@ class client_LedgerAtomicInterface {
     }
     return retval;
   }
-  async gc() {
+  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);
+    return await client_ledger_classPrivateFieldGet(client_ledger_storage, this).gc(transaction, timeLimitMS);
+  }
+  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 _testingRunStorageFunction(code) {
     const transaction = client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_assertTransaction).call(this);
@@ -124738,40 +125774,64 @@ async function client_checkSingleAccountPermissions(account, requirements, accou
     }
   }
 }
-async function client_checkPermissionRequirements(allRequirements) {
+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();
-  for (const singleRequirement of allRequirements) {
-    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: []
-        };
+  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]);
       }
-      newOwners[entityKey].owners.push(principal);
     }
-    if (permissions.base.isValidForDefault && entity.isIdentifier()) {
-      needToGetAccountInfoFor.add(entity);
+    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);
+      }
     }
   }
   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}`);
+    }
+  }
   const checkPromises = [];
   for (const principalPubKey in requirementsByPrincipal) {
     const accountRequirements = requirementsByPrincipal[principalPubKey];
@@ -124795,7 +125855,7 @@ async function client_validateLedgerOutcome(blocks) {
 
   // 'ADD' or 'REMOVE' an owner from ownersByIdentifier
   const modifyOwners = (method, entity, principal) => {
-    if (entity.isIdentifier() === false) {
+    if (entity.isIdentifier() === false || entity.isMultisig()) {
       return;
     }
     const entityPubKey = entity.assertIdentifier().publicKeyString.get();
@@ -124818,22 +125878,17 @@ async function client_validateLedgerOutcome(blocks) {
         break;
     }
   };
-  const accountEffects = client_computeEffectOfBlocks(blocks, client_ledger_classPrivateFieldGet(src_client_ledger, this)).accounts;
+  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 allPermissionRequirements = [];
-  for (const accountChanges of allAccountsChanges) {
-    var _accountChanges$field;
-    const requirements = (_accountChanges$field = accountChanges.fields.permissionRequirements) !== null && _accountChanges$field !== void 0 ? _accountChanges$field : [];
-    allPermissionRequirements.push(...requirements);
-  }
   const {
     newOwners
-  } = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_checkPermissionRequirements).call(this, allPermissionRequirements);
+  } = await client_ledger_assertClassBrand(client_LedgerAtomicInterface_brand, this, client_checkPermissionRequirements).call(this, accountEffects);
   for (const entityPubKey in newOwners) {
     const {
       entity,
@@ -124855,7 +125910,7 @@ async function client_validateLedgerOutcome(blocks) {
      */
     const createRequests = (_fields$createRequest = fields.createRequests) !== null && _fields$createRequest !== void 0 ? _fields$createRequest : [];
     for (const createRequest of createRequests) {
-      modifyOwners('ADD', createRequest.requestedIdentifier, account);
+      modifyOwners('ADD', createRequest.createdIdentifier, account);
     }
 
     /**
@@ -124919,6 +125974,106 @@ async function client_validateLedgerOutcome(blocks) {
       }
     }
   }
+  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);
+
+    /**
+     * 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`);
+        }
+      }
+    }
+    if (!predecessorBeingVotedOn) {
+      allLedgerHeads.set(block.account, block);
+    }
+  }
+  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`);
+  }
+  if (!client_ledger_classPrivateFieldGet(client_ledger_privateKey, this)) {
+    throw new Error('Cannot vote on block, no private key loaded');
+  }
+  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()}`);
+    }
+  }
+
+  /**
+   * 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);
+  }
+
+  /**
+   * 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);
+  }
+  const voteOrQuote = await builder.seal(serial, pendingVoteExpiry);
+  return voteOrQuote;
 }
 var client_storage2 = /*#__PURE__*/new WeakMap();
 var src_client_config = /*#__PURE__*/new WeakMap();
@@ -124959,6 +126114,28 @@ class src_client_Ledger {
   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;
+      }
+    }
+    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;
+  }
 
   /**
    * Execute some code with a transaction held, if the code fails the
@@ -124969,16 +126146,16 @@ class src_client_Ledger {
    */
   async run(identifier, code, readOnly) {
     try {
-      var _this$node, _classPrivateFieldGet6, _classPrivateFieldGet7, _this$node4;
+      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 (((_classPrivateFieldGet6 = client_ledger_classPrivateFieldGet(src_client_config, this).transactionRetries) === null || _classPrivateFieldGet6 === void 0 ? void 0 : _classPrivateFieldGet6.maxRetries) !== undefined) {
+      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 (((_classPrivateFieldGet7 = client_ledger_classPrivateFieldGet(src_client_config, this).transactionRetries) === null || _classPrivateFieldGet7 === void 0 ? void 0 : _classPrivateFieldGet7.timeout) !== undefined) {
+      } 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
@@ -125080,182 +126257,198 @@ class src_client_Ledger {
       return await transaction.vote(...args);
     });
   }
-  async add() {
+  async quote() {
     for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
       args[_key2] = arguments[_key2];
     }
+    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);
     });
   }
   async listACLsByPrincipal() {
-    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
-      args[_key3] = arguments[_key3];
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
     }
     return await this.runReadOnly('db-listACLs', async function (transaction) {
       return await transaction.listACLsByPrincipal(...args);
     });
   }
   async listACLsByEntity() {
-    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-      args[_key4] = arguments[_key4];
+    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      args[_key5] = arguments[_key5];
     }
     return await this.runReadOnly('db-listACLs', async function (transaction) {
       return await transaction.listACLsByEntity(...args);
     });
   }
   async getBalance() {
-    for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
-      args[_key5] = arguments[_key5];
+    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+      args[_key6] = arguments[_key6];
     }
     return await this.runReadOnly('db-getBalance', async function (transaction) {
       return await transaction.getBalance(...args);
     });
   }
   async getAllBalances() {
-    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
-      args[_key6] = arguments[_key6];
+    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+      args[_key7] = arguments[_key7];
     }
     return await this.runReadOnly('db-getAllBalances', async function (transaction) {
       return await transaction.getAllBalances(...args);
     });
   }
   async getAccountCertificates() {
-    for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
-      args[_key7] = arguments[_key7];
+    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);
     });
   }
   async getAccountCertificateByHash() {
-    for (var _len8 = arguments.length, args = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
-      args[_key8] = arguments[_key8];
+    for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
+      args[_key9] = arguments[_key9];
     }
     return await this.runReadOnly('db-getAccountCertificateByHash', async function (transaction) {
       return await transaction.getAccountCertificateByHash(...args);
     });
   }
   async votingPower() {
-    for (var _len9 = arguments.length, args = new Array(_len9), _key9 = 0; _key9 < _len9; _key9++) {
-      args[_key9] = arguments[_key9];
+    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);
     });
   }
   async getVotes() {
-    for (var _len10 = arguments.length, args = new Array(_len10), _key10 = 0; _key10 < _len10; _key10++) {
-      args[_key10] = arguments[_key10];
+    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);
     });
   }
   async getVotesFromMultiplePrevious() {
-    for (var _len11 = arguments.length, args = new Array(_len11), _key11 = 0; _key11 < _len11; _key11++) {
-      args[_key11] = arguments[_key11];
+    for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
+      args[_key12] = arguments[_key12];
     }
     return await this.runReadOnly('db-getVotesFromMultiplePrevious', async function (transaction) {
       return await transaction.getVotesFromMultiplePrevious(...args);
     });
   }
   async getBlockFromPrevious() {
-    for (var _len12 = arguments.length, args = new Array(_len12), _key12 = 0; _key12 < _len12; _key12++) {
-      args[_key12] = arguments[_key12];
+    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);
     });
   }
   async getHeadBlocks() {
-    for (var _len13 = arguments.length, args = new Array(_len13), _key13 = 0; _key13 < _len13; _key13++) {
-      args[_key13] = arguments[_key13];
+    for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
+      args[_key14] = arguments[_key14];
     }
     return await this.runReadOnly('db-getHeadBlocks', async function (transaction) {
       return await transaction.getHeadBlocks(...args);
     });
   }
   async getHeadBlock() {
-    for (var _len14 = arguments.length, args = new Array(_len14), _key14 = 0; _key14 < _len14; _key14++) {
-      args[_key14] = arguments[_key14];
+    for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
+      args[_key15] = arguments[_key15];
     }
     return await this.runReadOnly('db-getHeadBlock', async function (transaction) {
       return await transaction.getHeadBlock(...args);
     });
   }
   async getAccountRep() {
-    for (var _len15 = arguments.length, args = new Array(_len15), _key15 = 0; _key15 < _len15; _key15++) {
-      args[_key15] = arguments[_key15];
+    for (var _len16 = arguments.length, args = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {
+      args[_key16] = arguments[_key16];
     }
     return await this.runReadOnly('db-getAccountRep', async function (transaction) {
       return await transaction.getAccountRep(...args);
     });
   }
   async getAccountInfo() {
-    for (var _len16 = arguments.length, args = new Array(_len16), _key16 = 0; _key16 < _len16; _key16++) {
-      args[_key16] = arguments[_key16];
+    for (var _len17 = arguments.length, args = new Array(_len17), _key17 = 0; _key17 < _len17; _key17++) {
+      args[_key17] = arguments[_key17];
     }
     return await this.runReadOnly('db-getAccountInfo', async function (transaction) {
       return await transaction.getAccountInfo(...args);
     });
   }
   async getBlock() {
-    for (var _len17 = arguments.length, args = new Array(_len17), _key17 = 0; _key17 < _len17; _key17++) {
-      args[_key17] = arguments[_key17];
+    for (var _len18 = arguments.length, args = new Array(_len18), _key18 = 0; _key18 < _len18; _key18++) {
+      args[_key18] = arguments[_key18];
     }
     return await this.runReadOnly('db-getBlock', async function (transaction) {
       return await transaction.getBlock(...args);
     });
   }
   async getVoteStaple() {
-    for (var _len18 = arguments.length, args = new Array(_len18), _key18 = 0; _key18 < _len18; _key18++) {
-      args[_key18] = arguments[_key18];
+    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);
     });
   }
   async getVoteStaples() {
-    for (var _len19 = arguments.length, args = new Array(_len19), _key19 = 0; _key19 < _len19; _key19++) {
-      args[_key19] = arguments[_key19];
+    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);
     });
   }
   async getHistory() {
-    for (var _len20 = arguments.length, args = new Array(_len20), _key20 = 0; _key20 < _len20; _key20++) {
-      args[_key20] = arguments[_key20];
+    for (var _len21 = arguments.length, args = new Array(_len21), _key21 = 0; _key21 < _len21; _key21++) {
+      args[_key21] = arguments[_key21];
     }
     return await this.runReadOnly('db-getHistory', async function (transaction) {
       return await transaction.getHistory(...args);
     });
   }
   async getStaplesFromBlockHashes() {
-    for (var _len21 = arguments.length, args = new Array(_len21), _key21 = 0; _key21 < _len21; _key21++) {
-      args[_key21] = arguments[_key21];
+    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);
     });
   }
   async getVoteStaplesAfter() {
-    for (var _len22 = arguments.length, args = new Array(_len22), _key22 = 0; _key22 < _len22; _key22++) {
-      args[_key22] = arguments[_key22];
+    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);
     });
   }
   async gc() {
-    for (var _len23 = arguments.length, args = new Array(_len23), _key23 = 0; _key23 < _len23; _key23++) {
-      args[_key23] = arguments[_key23];
+    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);
     });
   }
+  async getFee() {
+    for (var _len25 = arguments.length, args = new Array(_len25), _key25 = 0; _key25 < _len25; _key25++) {
+      args[_key25] = arguments[_key25];
+    }
+    return await this.run('db-getFee', async function (transaction) {
+      return await transaction.getFee(...args);
+    });
+  }
   async stats() {
     try {
       var _this$node5;
@@ -125671,9 +126864,12 @@ function client_getDurationRange(duration) {
 /* harmony default export */ const client_stats = (client_Stats);
 // EXTERNAL MODULE: ws (ignored)
 var client_ws_ignored_ = __webpack_require__(4708);
+;// ./src/version.ts
+const client_version = '0.14.0+g8b0bdc16c0cba85135437a9ffb3a8cea2dae170d';
+/* 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"];
-var client_P2PWebSocket, client_P2PSwitch;
+var client_P2PHttpConnection, client_P2PWebSocket, client_P2PSwitch;
 function client_p2p_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_p2p_classPrivateMethodInitSpec(e, a) { client_p2p_checkPrivateRedeclaration(e, a), a.add(e); }
 function client_p2p_defineProperty(e, r, t) { return (r = client_p2p_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
@@ -125696,6 +126892,7 @@ function client_p2p_assertClassBrand(e, t, n) { if ("function" == typeof e ? e =
 
 
 
+
 /**
  * Peer to Peer connection configuration
  */
@@ -125708,7 +126905,8 @@ const client_defaultP2PConfig = {
   manualPeersCheckInFreq: 10 /* m */ * 60 /* s */ * 1000 /* ms */,
   seenMessageTTL: 1 /* m */ * 60 /* s */ * 1000 /* ms */,
   forwardingPeerCount: 16,
-  kv: null
+  kv: null,
+  useHTTPRepublish: false
 };
 
 /**
@@ -125735,7 +126933,7 @@ const client_defaultP2PConfig = {
 /**
  * Convert a peer to a printable string
  */
-function client_printablePeer(peer) {
+function client_printablePeer(peer, endpoint) {
   if (peer === null) {
     return 'null (not yet greeted)';
   }
@@ -125743,7 +126941,7 @@ function client_printablePeer(peer) {
     case client_node_NodeKind.PARTICIPANT:
       return `listener_${peer.id}`;
     case client_node_NodeKind.REPRESENTATIVE:
-      return `rep_${peer.key.publicKeyString.get()}@${peer.endpoints.p2p}`;
+      return `rep_${peer.key.publicKeyString.get()}@${endpoint !== null && endpoint !== void 0 ? endpoint : peer.endpoints.p2p}`;
   }
   return null;
 }
@@ -125773,7 +126971,7 @@ function client_validateP2PPeer(peer) {
           if (!client_p2p_Buffer.isBuffer(checkSignature)) {
             return false;
           }
-          const toVerifyJS = [checkVersion, peer.endpoints.p2p, peer.endpoints.api, peer.kind, peer.key.publicKeyAndType];
+          const toVerifyJS = [checkVersion, peer.endpoints.p2p, peer.endpoints.api, peer.preferUpdates, peer.kind, peer.key.publicKeyAndType];
           const toVerify = client_JStoASN1(toVerifyJS).toBER();
           const verification = peer.key.verify(toVerify, checkSignature);
           return verification;
@@ -125790,7 +126988,7 @@ async function client_generateP2PPeerSignature(peer) {
     case client_node_NodeKind.REPRESENTATIVE:
       {
         const version = 0;
-        const toSignJS = [version, peer.endpoints.p2p, peer.endpoints.api, peer.kind, peer.key.publicKeyAndType];
+        const toSignJS = [version, peer.endpoints.p2p, peer.endpoints.api, peer.preferUpdates, peer.kind, peer.key.publicKeyAndType];
         const toSign = client_JStoASN1(toSignJS).toBER();
         const signature = await peer.key.sign(toSign);
         const signatureWrapperJS = [version, signature.getBuffer()];
@@ -125844,13 +127042,20 @@ function client_P2PPeerFromJSO(object) {
         if (typeof endpoints.p2p !== 'string' || typeof endpoints.api !== 'string') {
           return null;
         }
+        if (typeof object.preferUpdates !== 'string') {
+          return null;
+        }
+        if (object.preferUpdates !== 'http' && object.preferUpdates !== 'websocket') {
+          return null;
+        }
         if (typeof object.key !== 'string') {
           return null;
         }
         const retvalUnsigned = {
           kind: client_node_NodeKind.REPRESENTATIVE,
           key: client_lib_account.fromPublicKeyString(object.key).assertAccount(),
-          endpoints: endpoints
+          endpoints: endpoints,
+          preferUpdates: object.preferUpdates
         };
         let retval;
         if (typeof object.signature === 'string') {
@@ -125910,6 +127115,7 @@ function client_P2PPeerToJSO(peer) {
         return {
           kind: peer.kind,
           endpoints: peer.endpoints,
+          preferUpdates: peer.preferUpdates,
           key: peer.key.publicKeyString.get(),
           ...additionalAttributes
         };
@@ -125943,6 +127149,12 @@ function client_isP2PPeer(checkObject) {
       if (!('p2p' in checkObject.endpoints) || !('api' in checkObject.endpoints)) {
         return false;
       }
+      if (!('preferUpdates' in checkObject)) {
+        return false;
+      }
+      if (checkObject.preferUpdates !== 'http' && checkObject.preferUpdates !== 'websocket') {
+        return false;
+      }
       if (!('key' in checkObject)) {
         return false;
       }
@@ -126060,13 +127272,84 @@ async function client_waitForPeer(conn) {
     }, 10);
   });
 }
+var client_switch = /*#__PURE__*/new WeakMap();
+class src_client_P2PHttpConnection {
+  /**
+   * Initiate an outbound http connection and attach it to the specified switch
+   */
+  static async initiate(peer, p2pSwitch) {
+    if (!('endpoints' in peer)) {
+      return null;
+    }
+    if (!('api' in peer.endpoints)) {
+      return null;
+    }
+    if (!('preferUpdates' in peer) || peer.preferUpdates !== 'http') {
+      return null;
+    }
+    const conn = new src_client_P2PHttpConnection(peer, p2pSwitch);
+    await p2pSwitch.registerConnection(conn);
+    return conn;
+  }
+  constructor(peer, p2pSwitch) {
+    client_p2p_classPrivateFieldInitSpec(this, client_switch, void 0);
+    client_p2p_defineProperty(this, "abort", false);
+    client_p2p_defineProperty(this, "validatedPeer", null);
+    client_p2p_defineProperty(this, "timeout", 0);
+    this.peer = peer;
+    client_p2p_classPrivateFieldSet(client_switch, this, p2pSwitch);
+  }
+  get connString() {
+    if (this.peerString === null) {
+      throw new Error('HTTP Connection should have a peerString');
+    }
+    return this.peerString;
+  }
+  get peerString() {
+    if (this.peer.kind === client_node_NodeKind.PARTICIPANT) {
+      throw new Error('HTTP Connections cannot be participants');
+    }
+    return client_printablePeer(this.peer, this.peer.endpoints.api);
+  }
+  async send(messageBuffer) {
+    if (this.peer.kind !== client_node_NodeKind.REPRESENTATIVE) {
+      return false;
+    }
+    client_p2p_classPrivateFieldGet(client_switch, this)._log.debug(`Called send on http connection: ${this.peerString}`);
+    const localGreetingInfo = await client_p2p_classPrivateFieldGet(client_switch, this).getOutgoingGreetingInfo();
+    const fetchURL = `${this.peer.endpoints.api}/p2p/message`;
+    try {
+      await fetch(fetchURL, {
+        method: 'POST',
+        headers: {
+          'content-type': 'application/json',
+          'user-agent': `KeetaNet/v${client_version} (JS)`
+        },
+        body: JSON.stringify({
+          message: messageBuffer.toString(),
+          greeting: localGreetingInfo
+        })
+      });
+    } catch (postMessageError) {
+      client_p2p_classPrivateFieldGet(client_switch, this)._log.debug(`Failed to post message: ${postMessageError}`);
+    }
+    return true;
+  }
+  async close() {
+    this.abort = true;
+    client_p2p_classPrivateFieldGet(client_switch, this)._log.debug(`Called close on http connection: ${this.peerString}`);
+    await client_p2p_classPrivateFieldGet(client_switch, this).unregisterConnection(this);
+  }
+}
 
 /**
  * A P2PConnection using the "ws" package
  */
+client_P2PHttpConnection = src_client_P2PHttpConnection;
+client_p2p_defineProperty(src_client_P2PHttpConnection, "isInstance", client_checkableGenerator(client_P2PHttpConnection));
 var client_underlyingSocket = /*#__PURE__*/new WeakMap();
 var client_socket = /*#__PURE__*/new WeakMap();
-var client_switch = /*#__PURE__*/new WeakMap();
+var client_switch2 = /*#__PURE__*/new WeakMap();
 class src_client_P2PWebSocket {
   /**
    * Initiate an outbound websocket connection and attach it to the specified switch
@@ -126178,7 +127461,7 @@ class src_client_P2PWebSocket {
   constructor(socket, p2pSwitch, underlyingSocket) {
     client_p2p_classPrivateFieldInitSpec(this, client_underlyingSocket, void 0);
     client_p2p_classPrivateFieldInitSpec(this, client_socket, void 0);
-    client_p2p_classPrivateFieldInitSpec(this, client_switch, void 0);
+    client_p2p_classPrivateFieldInitSpec(this, client_switch2, void 0);
     client_p2p_defineProperty(this, "validatedPeer", null);
     if (socket === undefined) {
       throw new Error('internal error: socket is required');
@@ -126190,14 +127473,14 @@ class src_client_P2PWebSocket {
     client_p2p_classPrivateFieldSet(client_underlyingSocket, this, underlyingSocket);
     this.peer = null;
     this.abort = false;
-    client_p2p_classPrivateFieldSet(client_switch, this, p2pSwitch);
+    client_p2p_classPrivateFieldSet(client_switch2, this, p2pSwitch);
     this.timeout = Date.now() + 100000;
     client_p2p_classPrivateFieldGet(client_socket, this).on('message', async data => {
       if (!Array.isArray(data)) {
         data = [data];
       }
       for (const messageBuffer of data) {
-        await client_p2p_classPrivateFieldGet(client_switch, this).recvMessageFromPeer(this, messageBuffer);
+        await client_p2p_classPrivateFieldGet(client_switch2, this).recvMessageFromPeer(this, messageBuffer);
       }
     });
     client_p2p_classPrivateFieldGet(client_socket, this).on('close', async () => {
@@ -126206,7 +127489,7 @@ class src_client_P2PWebSocket {
     });
     client_p2p_classPrivateFieldGet(client_socket, this).on('error', async error => {
       this.abort = true;
-      client_p2p_classPrivateFieldGet(client_switch, this)._log.error('Peering error:', error);
+      client_p2p_classPrivateFieldGet(client_switch2, this)._log.error('Peering error:', error);
       await this.close();
     });
 
@@ -126231,13 +127514,13 @@ class src_client_P2PWebSocket {
   async send(messageBuffer) {
     const promise = new Promise(resolve => {
       if (this.abort) {
-        client_p2p_classPrivateFieldGet(client_switch, this)._log.error('Attempt to send to aborted connection', this.connString);
+        client_p2p_classPrivateFieldGet(client_switch2, this)._log.error('Attempt to send to aborted connection', this.connString);
         resolve(false);
         return;
       }
       client_p2p_classPrivateFieldGet(client_socket, this).send(messageBuffer.toString('utf-8'), async error => {
         if (error) {
-          client_p2p_classPrivateFieldGet(client_switch, this)._log.error('Failed to send to', this.connString, error);
+          client_p2p_classPrivateFieldGet(client_switch2, this)._log.error('Failed to send to', this.connString, error);
           await this.close();
           resolve(false);
         } else {
@@ -126389,7 +127672,13 @@ class src_client_P2PSwitch {
      * been confirmed
      */
     const repLastSeenLimit = Math.max(this.config.timeoutIdle, this.config.manualPeersCheckInFreq) * 10;
-    let knownPeers = await this.config.kv.getAll('knownPeers');
+    const potentialKnownPeers = await this.config.kv.getAll('knownPeers');
+    // Filter for only valid entries in case the format becomes invalidated in the future
+    let knownPeers = Object.fromEntries(Object.entries(potentialKnownPeers).filter(_ref => {
+      let [_, value] = _ref;
+      const peer = client_P2PPeerFromJSO(value);
+      return peer !== null;
+    }));
     const lastSeenPeers = await this.config.kv.getAll('lastSeenPeers');
     const retval = [];
 
@@ -126672,6 +127961,13 @@ class src_client_P2PSwitch {
   async selfPeer() {
     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');
+    }
+    return client_P2PPeerToJSO(greetingInfo);
+  }
   /**
    * Receive a message from a connection
    *
@@ -126726,7 +128022,7 @@ class src_client_P2PSwitch {
       let forward = true;
       let acceptable = true;
       let rebroadcastOnly = false;
-      if (from.peer === null) {
+      if (from.peer === null || src_client_P2PHttpConnection.isInstance(from) && message.type === 'greeting') {
         /**
          * By default do not forward messages from un-greeted peers
          */
@@ -127204,6 +128500,26 @@ class src_client_P2PSwitch {
     }
     return false;
   }
+
+  /**
+   * TODO - make this private after refactoring websockets to handle higher load
+   * https://github.com/KeetaNetwork/node/issues/785
+   */
+  async haveAnyFilter(data) {
+    const kvFilters = await this.config.kv.getAll('messageFilters');
+    for (const key in kvFilters) {
+      const kvFilter = kvFilters[key];
+      if (kvFilter && typeof kvFilter === 'string') {
+        const filter = client_lib_account.fromPublicKeyAndType(kvFilter);
+        const voteStaple = new src_client_VoteStaple(data);
+        const {
+          touched
+        } = client_computeEffectOfBlocks(voteStaple.blocks);
+        return touched.has(filter);
+      }
+    }
+    return false;
+  }
 }
 client_P2PSwitch = src_client_P2PSwitch;
 async function client_connectedPeerConnection(peer) {
@@ -127367,7 +128683,8 @@ async function client_getLocalPeerInfo() {
           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');
@@ -127382,11 +128699,7 @@ async function client_getLocalPeerInfo() {
 }
 async function client_emitOutgoingGreeting(to) {
   const messageID = client_esm_browser_v4();
-  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');
-  }
-  const greeting = client_P2PPeerToJSO(greetingInfo);
+  const greeting = await this.getOutgoingGreetingInfo();
   this._log.debug('Sending greeting to', to.connString);
   return await this.sendMessage(to, messageID, 'greeting', greeting, 0);
 }
@@ -127457,13 +128770,17 @@ function client_updateConnTimeout(conn) {
 }
 async function client_connectToPeer(peer, logId) {
   this._log.debug(`[${logId}]`, 'Trying to connect to peer', client_printablePeer(peer));
-  let ws = null;
-  try {
-    ws = await src_client_P2PWebSocket.initiate(peer, this);
-  } catch (connectError) {
-    /* Ignored */
+  let p2pConnection = null;
+  if (peer.kind === client_node_NodeKind.REPRESENTATIVE && peer.preferUpdates === 'http') {
+    p2pConnection = await src_client_P2PHttpConnection.initiate(peer, this);
+  } else {
+    try {
+      p2pConnection = await src_client_P2PWebSocket.initiate(peer, this);
+    } catch (connectError) {
+      /* Ignored */
+    }
   }
-  if (ws === null) {
+  if (p2pConnection === null) {
     return null;
   }
 
@@ -127471,9 +128788,9 @@ async function client_connectToPeer(peer, logId) {
    * Since we established an outbound connection to this
    * peer we already know their information
    */
-  ws.validatedPeer = peer;
-  await this.registerConnection(ws);
-  await client_waitForPeer(ws);
+  p2pConnection.validatedPeer = peer;
+  await this.registerConnection(p2pConnection);
+  await client_waitForPeer(p2pConnection);
 
   /*
    * Since we successfully connected to the peer, update the
@@ -127492,7 +128809,7 @@ async function client_connectToPeer(peer, logId) {
   } catch (addPeerError) {
     this._log.error('Failed to add peer:', addPeerError);
   }
-  return ws;
+  return p2pConnection;
 }
 async function client_passesFilter(target, data) {
   let filter = client_p2p_classPrivateFieldGet(client_messageFilterCache, this)[target.connString];
@@ -127925,7 +129242,7 @@ async function client_generateInitialVoteStaple(options) {
       blocks.recipientSupply = blocks.recipient;
       blocks.recipient = await new client_lib_block.Builder({
         network: network,
-        signer: recipient,
+        account: recipient,
         previous: getPrevious(recipient),
         operations: [{
           type: client_lib_block.OperationType.SET_REP,
@@ -127994,9 +129311,6 @@ async function client_generateInitialVoteStaple(options) {
     Certificate: client_utils_certificate_namespaceObject
   }
 });
-;// ./src/version.ts
-const client_version = '0.12.2+g77a8a16ada9dfab5604b605cbe69d373a414d204';
-/* harmony default export */ const client_src_version = ((/* unused pure expression or super */ null && (client_version)));
 ;// ./src/lib/error/client.ts
 var client_KeetaNetClientError;
 function client_client_defineProperty(e, r, t) { return (r = client_client_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
@@ -128038,6 +129352,7 @@ function client_builder_assertClassBrand(e, t, n) { if ("function" == typeof e ?
 
 
 
+
 /** @expandType GetPrevFunction */
 
 /** @useDeclaredType */
@@ -128366,7 +129681,7 @@ class src_client_UserClientBuilder {
     };
     return await src_client_UserClientBuilder.FromPendingJSON(client_builder_classPrivateFieldGet(client_defaultOptions, this), getPrivateKey, [this.pendingToJSON()]);
   }
-  async publish(client) {
+  async publish(options, client) {
     if (client === undefined) {
       client = client_builder_classPrivateFieldGet(client_userClient, this);
     }
@@ -128378,10 +129693,67 @@ class src_client_UserClientBuilder {
       retval = await client.publishBuilder(this);
     } else {
       const blocks = await this.computeBlocks(client);
-      retval = await client.client.transmit(blocks.blocks);
+      retval = await client.client.transmit(blocks.blocks, options);
     }
     return retval;
   }
+  async computeFeeBlock(staple) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    let renderOptions = arguments.length > 2 ? arguments[2] : undefined;
+    client_builder_assertClassBrand(client_UserClientBuilder_brand, this, client_useOptions).call(this, options);
+    if (renderOptions === undefined) {
+      renderOptions = client_builder_classPrivateFieldGet(client_userClient, this);
+    }
+    if (renderOptions === undefined) {
+      throw new src_client_KeetaNetClientError('CLIENT_BUILDER_USER_CLIENT_REQUIRED', 'UserClient is required to compute blocks');
+    }
+    if (!('getPrevious' in renderOptions)) {
+      renderOptions = client_builder_assertClassBrand(client_UserClientBuilder_brand, this, client_getRenderOptionsFromClient).call(this, renderOptions);
+    }
+    const previousByKey = {};
+    for (const existing of staple.blocks) {
+      const previous = existing.previous.toString();
+      const pubKey = existing.account.publicKeyString.get();
+      if (!previousByKey[pubKey] || previousByKey[pubKey].toString() === previous) {
+        previousByKey[pubKey] = existing.hash.toString();
+      }
+    }
+    const {
+      account,
+      signer
+    } = client_builder_classPrivateFieldGet(client_pendingOptions, this);
+    const accountPubKey = account.publicKeyString.get();
+    let previous = previousByKey[accountPubKey];
+    if (!previous) {
+      var _await$renderOptions$;
+      previous = (_await$renderOptions$ = await renderOptions.getPrevious(account)) !== null && _await$renderOptions$ !== void 0 ? _await$renderOptions$ : src_client_Block.NO_PREVIOUS;
+    }
+    const {
+      baseToken
+    } = client_src_lib.Account.generateBaseAddresses(renderOptions.network);
+    const operations = [];
+    for (const vote of staple.votes) {
+      if (vote.fee !== undefined) {
+        var _vote$fee$payTo, _vote$fee$token;
+        operations.push({
+          type: client_OperationType.SEND,
+          amount: vote.fee.amount,
+          to: (_vote$fee$payTo = vote.fee.payTo) !== null && _vote$fee$payTo !== void 0 ? _vote$fee$payTo : vote.issuer,
+          token: (_vote$fee$token = vote.fee.token) !== null && _vote$fee$token !== void 0 ? _vote$fee$token : baseToken
+        });
+      }
+    }
+    const block = await new src_client_Block.Builder({
+      version: 2,
+      purpose: client_BlockPurpose.FEE,
+      account: account,
+      signer: signer,
+      network: renderOptions.network,
+      previous: previous,
+      operations: operations
+    }).seal();
+    return block;
+  }
   async computeBlocks(renderOptions) {
     if (this.rendered) {
       return {
@@ -128415,8 +129787,8 @@ class src_client_UserClientBuilder {
       const accountPubKey = account.publicKeyString.get();
       let previous = previousByKey[accountPubKey];
       if (!previous) {
-        var _await$renderOptions$;
-        previous = (_await$renderOptions$ = await renderOptions.getPrevious(account)) !== null && _await$renderOptions$ !== void 0 ? _await$renderOptions$ : src_client_Block.NO_PREVIOUS;
+        var _await$renderOptions$2;
+        previous = (_await$renderOptions$2 = await renderOptions.getPrevious(account)) !== null && _await$renderOptions$2 !== void 0 ? _await$renderOptions$2 : src_client_Block.NO_PREVIOUS;
       }
       for (const {
         type,
@@ -128499,7 +129871,7 @@ class src_client_UserClientBuilder {
             continue;
           }
           operations.push({
-            token: src_client_Account.toAccount(token).assertKeyType(client_account_AccountKeyAlgorithm.TOKEN),
+            token: src_client_Account.toAccount(token).assertKeyType(client_AccountKeyAlgorithm.TOKEN),
             amount: amount,
             type: src_client_Block.OperationType.SEND,
             to: otherParty
@@ -128587,7 +129959,7 @@ class src_client_UserClientBuilder {
         }
         operations.push({
           type: src_client_Block.OperationType.TOKEN_ADMIN_MODIFY_BALANCE,
-          token: src_client_Account.toAccount(tokenPubKey).assertKeyType(client_account_AccountKeyAlgorithm.TOKEN),
+          token: src_client_Account.toAccount(tokenPubKey).assertKeyType(client_AccountKeyAlgorithm.TOKEN),
           method: method,
           amount: amount
         });
@@ -128703,7 +130075,7 @@ class src_client_UserClientBuilder {
   modifyTokenSupply(amount) {
     let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     client_builder_assertClassBrand(client_UserClientBuilder_brand, this, client_useOptions).call(this, options);
-    if (client_builder_classPrivateFieldGet(client_pendingOptions, this).account.keyType !== client_account_AccountKeyAlgorithm.TOKEN) {
+    if (client_builder_classPrivateFieldGet(client_pendingOptions, this).account.keyType !== client_AccountKeyAlgorithm.TOKEN) {
       throw new Error('The current account when using modifyTokenSupply() must be a token account');
     }
     if (!client_builder_classPrivateFieldGet(client_pendingOperations, this).tokenSupply) {
@@ -128928,6 +130300,7 @@ function client_client_assertClassBrand(e, t, n) { if ("function" == typeof e ?
 
 
 
+
 
 
 /*
@@ -129166,15 +130539,6 @@ class src_client_Client {
     return await builder.computeBlocks(client_client_assertClassBrand(client_Client_brand, this, client_getBuilderRenderOptions).call(this, network));
   }
 
-  /**
-   * Transmit a set of blocks to the network.  This will request short
-   * votes and permanent votes for the blocks and then publish them to
-   * the network.
-   *
-   * @param blocks The blocks or UserClientBuilder to transmit
-   * @return The result of the publish operation
-   */
-
   /**
    * Transmit a set of blocks to the network.  This will request short
    * votes and permanent votes for the blocks and then publish them to
@@ -129182,33 +130546,41 @@ class src_client_Client {
    *
    * The `blocks` builder will be computed using {@link computeBuilderBlocks} and then transmitted.
    *
-   * @param blocks The UserClientBuilder to compute and transmit transmit
+   * @param builder The UserClientBuilder to compute and transmit transmit
    * @param network The network to use for the builder (if using a builder)
    * @return The result of the publish operation
    */
+  async transmitBuilder(builder, network, options) {
+    const blocks = await this.computeBuilderBlocks(network, builder);
+    return await this.transmit(blocks.blocks, options);
+  }
 
   /**
    * Transmit a set of blocks to the network.  This will request short
    * votes and permanent votes for the blocks and then publish them to
-   * the network.
-   *
-   * If `blocks` is a {@link UserClientBuilder} then the blocks will be
-   * computed and then transmitted.  If `blocks` is an array of blocks
-   * then they will be transmitted as-is.
+   * the network.  Optionally it will generate a fee block from a user
+   * provided function if fees are required.
    *
-   * @param blocks The blocks or UserClientBuilder to transmit
-   * @param network The network to use for the builder (if using a builder)
+   * @param blocks The blocks to transmit
+   * @param options User provided options {@link PublishOptions }
    * @return The result of the publish operation
    */
-  async transmit(blocks, network) {
-    if (src_client_UserClientBuilder.isInstance(blocks)) {
-      if (network === undefined) {
-        throw new Error('Network must be defined when using transmit() with a builder');
+  async transmit(blocks, options) {
+    const tempVotes = await client_client_assertClassBrand(client_Client_brand, this, client_requestVotes).call(this, blocks, undefined, undefined, options === null || options === void 0 ? void 0 : options.quotes);
+    let requiresFee = false;
+    for (const vote of tempVotes) {
+      if (vote.fee !== undefined) {
+        requiresFee = true;
+      }
+    }
+    if (requiresFee) {
+      if ((options === null || options === void 0 ? void 0 : options.generateFeeBlock) === undefined) {
+        throw new Error('Votes require fees but generateFeeBlock was not defined');
       }
-      await this.computeBuilderBlocks(network, blocks);
-      blocks = blocks.blocks;
+      const staple = src_client_VoteStaple.fromVotesAndBlocks(tempVotes, blocks);
+      const feeBlock = await options.generateFeeBlock(staple);
+      blocks.push(feeBlock);
     }
-    const tempVotes = await client_client_assertClassBrand(client_Client_brand, this, client_requestVotes).call(this, blocks);
     const permVotes = await client_client_assertClassBrand(client_Client_brand, this, client_requestVotes).call(this, blocks, tempVotes);
     const votesAndBlocks = client_src_lib.Vote.Staple.fromVotesAndBlocks(permVotes, blocks);
     return await this.transmitStaple(votesAndBlocks);
@@ -129734,7 +131106,7 @@ class src_client_Client {
    * that it will always return at least 1 vote staple if there are any
    * vote staples available.
    *
-   * @param account The account to get the history for
+   * @param account The account to get the history for -- if null then the history for all accounts will be returned
    * @param options The options to use for the request
    * @param options.startBlocksHash The block hash to start from -- this is used to paginate the request
    * @param options.depth The maximum number of vote staples to return -- this is used to limit the number of vote staples returned
@@ -129761,19 +131133,18 @@ class src_client_Client {
       const query = {
         limit: String(limit)
       };
+      if (startVoteStapleID !== undefined) {
+        query.start = startVoteStapleID;
+      }
       let history;
-      if (startVoteStapleID === undefined) {
-        history = await client_client_assertClassBrand(client_Client_brand, this, src_client_api).call(this, 'ANY', 'GET /node/ledger/account/:account/history', {
-          args: {
-            account
-          },
+      if (account === null) {
+        history = await client_client_assertClassBrand(client_Client_brand, this, src_client_api).call(this, 'ANY', 'GET /node/ledger/history', {
           queryParams: query
         });
       } else {
-        history = await client_client_assertClassBrand(client_Client_brand, this, src_client_api).call(this, 'ANY', 'GET /node/ledger/account/:account/history/start/:block', {
+        history = await client_client_assertClassBrand(client_Client_brand, this, src_client_api).call(this, 'ANY', 'GET /node/ledger/account/:account/history', {
           args: {
-            account: account,
-            block: startVoteStapleID
+            account
           },
           queryParams: query
         });
@@ -129783,7 +131154,7 @@ class src_client_Client {
       }
       for (const historyEntry of history.history) {
         const voteStapleInfo = historyEntry.voteStaple;
-        if (!voteStapleInfo['$binary']) {
+        if (voteStapleInfo['$binary'] === undefined) {
           throw new Error('Vote Staple is missing binary data');
         }
         const voteStapleBinary = client_client_Buffer.from(voteStapleInfo['$binary'], 'base64');
@@ -130200,6 +131571,9 @@ class src_client_Client {
     }
     return voteStaple;
   }
+  async getVoteQuotes(blocks) {
+    return await client_client_assertClassBrand(client_Client_brand, this, client_requestQuotes).call(this, blocks);
+  }
 
   /** Work in progress */
   async getLedgerChecksum() {
@@ -130371,55 +131745,29 @@ async function src_client_api(rep, api) {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
   return await client_client_assertClassBrand(client_Client_brand, this, client_apiRaw).call(this, rep, path, method, options);
 }
-async function client_requestVotes(blocks, otherVotes) {
+async function client_requestVoteOrQuote(api, request) {
   let reps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : client_client_classPrivateFieldGet(client_reps, this);
-  // Wait for reps promise to ensure we have the right list of reps and their weight
-  await client_client_classPrivateFieldGet(client_updateRepsPromise, this);
-  const request = {
-    blocks: blocks.map(function (block) {
-      return client_client_Buffer.from(block.toBytes()).toString('base64');
-    })
-  };
-  if (otherVotes !== undefined) {
-    if (otherVotes.length === 0) {
-      throw new Error('requestVotes() otherVotes must not have a length of 0');
-    }
-    request.votes = otherVotes.map(function (vote) {
-      return client_client_Buffer.from(vote.toBytes()).toString('base64');
-    });
-    if (reps === client_client_classPrivateFieldGet(client_reps, this)) {
-      reps = otherVotes.map(vote => {
-        const voteRepPubKey = vote.issuer.publicKeyString.get();
-        return client_client_classPrivateFieldGet(client_reps, this).find(function (rep) {
-          const checkRepPubKey = rep.key.publicKeyString.get();
-          if (checkRepPubKey === voteRepPubKey) {
-            return true;
-          }
-          return false;
-        });
-      }).filter(function (rep) {
-        if (rep === undefined) {
-          return false;
-        }
-        return true;
-      });
-    }
-  }
+  let quotes = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
   let recentVotingError;
   let recentVotingErrorWeight;
+  const quoteMap = new Map();
+  for (const quote of quotes) {
+    quoteMap.set(quote.issuer.publicKeyAndTypeString, quote);
+  }
   const votePromises = [];
   for (const rep of reps) {
+    const quote = quoteMap.get(rep.key.publicKeyAndTypeString);
+    if (quote !== undefined) {
+      request.quote = client_client_Buffer.from(quote.toBytes()).toString('base64');
+    }
     votePromises.push((async () => {
       try {
-        const apiResult = await client_client_assertClassBrand(client_Client_brand, this, src_client_api).call(this, rep, 'POST /vote/_root', {
+        const apiResult = await client_client_assertClassBrand(client_Client_brand, this, src_client_api).call(this, rep, api, {
           body: request
         });
         return apiResult;
       } catch (voteError) {
         var _rep$weight;
-        if (otherVotes !== undefined) {
-          throw voteError;
-        }
         const weight = (_rep$weight = rep.weight) !== null && _rep$weight !== void 0 ? _rep$weight : 0n;
         if (recentVotingErrorWeight === undefined || weight > recentVotingErrorWeight) {
           recentVotingError = voteError;
@@ -130441,9 +131789,19 @@ async function client_requestVotes(blocks, otherVotes) {
     if (voteObjectWrapper === undefined) {
       continue;
     }
-    const voteObject = voteObjectWrapper['vote'];
-    const voteBin = client_client_Buffer.from(voteObject['$binary'], 'base64');
-    retval.push(new client_src_lib.Vote(voteBin));
+    if ('vote' in voteObjectWrapper) {
+      const voteObject = voteObjectWrapper['vote'];
+      const voteBin = client_client_Buffer.from(voteObject['$binary'], 'base64');
+      const vote = new client_src_lib.Vote(voteBin);
+      retval.push(vote);
+    } else if ('quote' in voteObjectWrapper) {
+      const voteObject = voteObjectWrapper['quote'];
+      const quoteBin = client_client_Buffer.from(voteObject['$binary'], 'base64');
+      const quote = new client_src_lib.Vote.Quote(quoteBin);
+      retval.push(quote);
+    } else {
+      throw new Error('Vote or Quote not in response');
+    }
   }
   if (retval.length === 0 && recentVotingError !== undefined) {
     if (recentVotingError !== undefined) {
@@ -130464,6 +131822,56 @@ async function client_requestVotes(blocks, otherVotes) {
   }
   return retval;
 }
+async function client_requestQuotes(blocks) {
+  let reps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : client_client_classPrivateFieldGet(client_reps, this);
+  // Wait for reps promise to ensure we have the right list of reps and their weight
+  await client_client_classPrivateFieldGet(client_updateRepsPromise, this);
+  const request = {
+    blocks: blocks.map(function (block) {
+      return client_client_Buffer.from(block.toBytes()).toString('base64');
+    })
+  };
+  const quotes = await client_client_assertClassBrand(client_Client_brand, this, client_requestVoteOrQuote).call(this, 'POST /vote/quote', request, reps);
+  return quotes;
+}
+async function client_requestVotes(blocks, otherVotes) {
+  let reps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : client_client_classPrivateFieldGet(client_reps, this);
+  let quotes = arguments.length > 3 ? arguments[3] : undefined;
+  // Wait for reps promise to ensure we have the right list of reps and their weight
+  await client_client_classPrivateFieldGet(client_updateRepsPromise, this);
+  const request = {
+    blocks: blocks.map(function (block) {
+      return client_client_Buffer.from(block.toBytes()).toString('base64');
+    })
+  };
+  if (otherVotes !== undefined) {
+    if (otherVotes.length === 0) {
+      throw new Error('requestVotes() otherVotes must not have a length of 0');
+    }
+    request.votes = otherVotes.map(function (vote) {
+      return client_client_Buffer.from(vote.toBytes()).toString('base64');
+    });
+    if (reps === client_client_classPrivateFieldGet(client_reps, this)) {
+      reps = otherVotes.map(vote => {
+        const voteRepPubKey = vote.issuer.publicKeyString.get();
+        return client_client_classPrivateFieldGet(client_reps, this).find(function (rep) {
+          const checkRepPubKey = rep.key.publicKeyString.get();
+          if (checkRepPubKey === voteRepPubKey) {
+            return true;
+          }
+          return false;
+        });
+      }).filter(function (rep) {
+        if (rep === undefined) {
+          return false;
+        }
+        return true;
+      });
+    }
+  }
+  const votes = await client_client_assertClassBrand(client_Client_brand, this, client_requestVoteOrQuote).call(this, 'POST /vote/_root', request, reps, quotes);
+  return votes;
+}
 async function client_getVotes(blockhash) {
   let side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'main';
   let rep = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'ANY';
@@ -130537,7 +131945,7 @@ function client_urlSeparatedAccounts(accounts) {
 function client_formatAllBalances(balances) {
   return balances.map(function (entry) {
     return {
-      token: client_src_lib.Account.fromPublicKeyString(entry.token).assertKeyType(client_account_AccountKeyAlgorithm.TOKEN),
+      token: client_src_lib.Account.fromPublicKeyString(entry.token).assertKeyType(client_AccountKeyAlgorithm.TOKEN),
       balance: BigInt(entry.balance)
     };
   });
@@ -130865,7 +132273,14 @@ class src_client_UserClient {
     } = client_src_lib.Account.generateBaseAddresses(config.network);
     this.networkAddress = networkAddress;
     this.baseToken = baseToken;
-    client_client_classPrivateFieldSet(client_client_config, this, config);
+    client_client_classPrivateFieldSet(client_client_config, this, {
+      generateFeeBlock: async staple => {
+        const builder = this.initBuilder();
+        const block = await builder.computeFeeBlock(staple);
+        return block;
+      },
+      ...config
+    });
 
     // For event listeners/polling
     client_client_classPrivateFieldSet(client_listeners, this, {});
@@ -131009,11 +132424,15 @@ class src_client_UserClient {
    * instead of this one.
    *
    * @param builder The builder to publish
+   * @param options options for publishing {@link PublishOptions }
    * @return The vote staple that was generated and whether it was able to be published
    */
   async publishBuilder(builder) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+      generateFeeBlock: client_client_classPrivateFieldGet(client_client_config, this).generateFeeBlock
+    };
     if (!client_client_classPrivateFieldGet(client_client_config, this).usePublishAid) {
-      return await client_client_classPrivateFieldGet(client_client, this).transmit(builder, this.network);
+      return await client_client_classPrivateFieldGet(client_client, this).transmitBuilder(builder, this.network, options);
     }
     await client_client_classPrivateFieldGet(client_client, this).computeBuilderBlocks(this.network, builder);
     const retval = await client_client_assertClassBrand(client_UserClient_brand, this, client_publishWithPublishAid).call(this, builder.blocks);
@@ -131149,6 +132568,15 @@ class src_client_UserClient {
     throw new Error('Unreachable code reached in UserClient.send');
   }
 
+  /**
+   * Gets a quote for the cost for a given set of blocks from each representative
+   * @param blocks
+   * @returns A list of quotes from representatives the client knows about
+   */
+  async getQuotes(blocks) {
+    return await client_client_classPrivateFieldGet(client_client, this).getVoteQuotes(blocks);
+  }
+
   /**
    * Generate a new identifier for the given type and publish the blocks
    *