@aeternity/aepp-sdk 14.1.1 → 15.0.0

package/dist/aepp-sdk.cjs

@@ -7353,6 +7353,7 @@ __webpack_require__.d(__webpack_exports__, {
   connectionProxy: () => (/* reexport */ connection_proxy),
   createGeneralizedAccount: () => (/* reexport */ createGeneralizedAccount),
   decode: () => (/* reexport */ decode),
+  defaultProtocolParameters: () => (/* reexport */ defaultProtocolParameters),
   encode: () => (/* reexport */ encode),
   encodeContractAddress: () => (/* reexport */ buildContractId),
   encodeUnsigned: () => (/* reexport */ encodeUnsigned),
@@ -7363,6 +7364,7 @@ __webpack_require__.d(__webpack_exports__, {
   genSalt: () => (/* reexport */ genSalt),
   getAccount: () => (/* reexport */ getAccount),
   getBalance: () => (/* reexport */ getBalance),
+  getCachedProtocolParameters: () => (/* reexport */ getCachedProtocolParameters),
   getContract: () => (/* reexport */ getContract),
   getContractByteCode: () => (/* reexport */ getContractByteCode),
   getCurrentGeneration: () => (/* reexport */ getCurrentGeneration),
@@ -7399,6 +7401,7 @@ __webpack_require__.d(__webpack_exports__, {
   prefixedAmount: () => (/* reexport */ prefixedAmount),
   produceNameId: () => (/* reexport */ produceNameId),
   readInt: () => (/* reexport */ readInt),
+  rebuildUnpackedTx: () => (/* reexport */ rebuildUnpackedTx),
   resolveName: () => (/* reexport */ resolveName),
   sendTransaction: () => (/* reexport */ sendTransaction),
   signJwt: () => (/* reexport */ signJwt),
@@ -7476,6 +7479,8 @@ __webpack_require__.d(mappers_namespaceObject, {
   ContractCallTx: () => (ContractCallTx),
   ContractCreateTx: () => (ContractCreateTx),
   ContractObject: () => (ContractObject),
+  ContractTxBaseGas: () => (ContractTxBaseGas),
+  ContractVersion: () => (ContractVersion),
   CountResponse: () => (CountResponse),
   CreateContractUnsignedTx: () => (CreateContractUnsignedTx),
   Currency: () => (Currency),
@@ -7502,16 +7507,61 @@ __webpack_require__.d(mappers_namespaceObject, {
   Image: () => (Image),
   KeyBlock: () => (KeyBlock),
   MicroBlockHeader: () => (MicroBlockHeader),
+  NameAuctionTimeout: () => (NameAuctionTimeout),
   NameClaimTx: () => (NameClaimTx),
   NameEntry: () => (NameEntry),
+  NameEntryPointersItem: () => (NameEntryPointersItem),
   NameHash: () => (NameHash),
   NamePointer: () => (NamePointer),
-  NamePointerComplete: () => (NamePointerComplete),
   NamePreclaimTx: () => (NamePreclaimTx),
   NameRevokeTx: () => (NameRevokeTx),
   NameTransferTx: () => (NameTransferTx),
   NameUpdateTx: () => (NameUpdateTx),
   NextNonceResponse: () => (NextNonceResponse),
+  NodeGetAccountByPubkeyAndHashExceptionHeaders: () => (NodeGetAccountByPubkeyAndHashExceptionHeaders),
+  NodeGetAccountByPubkeyAndHeightExceptionHeaders: () => (NodeGetAccountByPubkeyAndHeightExceptionHeaders),
+  NodeGetAccountByPubkeyExceptionHeaders: () => (NodeGetAccountByPubkeyExceptionHeaders),
+  NodeGetAccountNextNonceExceptionHeaders: () => (NodeGetAccountNextNonceExceptionHeaders),
+  NodeGetAuctionEntryByNameExceptionHeaders: () => (NodeGetAuctionEntryByNameExceptionHeaders),
+  NodeGetChainEndsExceptionHeaders: () => (NodeGetChainEndsExceptionHeaders),
+  NodeGetChannelByPubkeyExceptionHeaders: () => (NodeGetChannelByPubkeyExceptionHeaders),
+  NodeGetContractCodeExceptionHeaders: () => (NodeGetContractCodeExceptionHeaders),
+  NodeGetContractExceptionHeaders: () => (NodeGetContractExceptionHeaders),
+  NodeGetContractPoIExceptionHeaders: () => (NodeGetContractPoIExceptionHeaders),
+  NodeGetCurrencyExceptionHeaders: () => (NodeGetCurrencyExceptionHeaders),
+  NodeGetCurrentGenerationExceptionHeaders: () => (NodeGetCurrentGenerationExceptionHeaders),
+  NodeGetCurrentKeyBlockExceptionHeaders: () => (NodeGetCurrentKeyBlockExceptionHeaders),
+  NodeGetCurrentKeyBlockHashExceptionHeaders: () => (NodeGetCurrentKeyBlockHashExceptionHeaders),
+  NodeGetCurrentKeyBlockHeightExceptionHeaders: () => (NodeGetCurrentKeyBlockHeightExceptionHeaders),
+  NodeGetGenerationByHashExceptionHeaders: () => (NodeGetGenerationByHashExceptionHeaders),
+  NodeGetGenerationByHeightExceptionHeaders: () => (NodeGetGenerationByHeightExceptionHeaders),
+  NodeGetHyperchainContractPubkeysExceptionHeaders: () => (NodeGetHyperchainContractPubkeysExceptionHeaders),
+  NodeGetKeyBlockByHashExceptionHeaders: () => (NodeGetKeyBlockByHashExceptionHeaders),
+  NodeGetKeyBlockByHeightExceptionHeaders: () => (NodeGetKeyBlockByHeightExceptionHeaders),
+  NodeGetMicroBlockHeaderByHashExceptionHeaders: () => (NodeGetMicroBlockHeaderByHashExceptionHeaders),
+  NodeGetMicroBlockTransactionByHashAndIndexExceptionHeaders: () => (NodeGetMicroBlockTransactionByHashAndIndexExceptionHeaders),
+  NodeGetMicroBlockTransactionsByHashExceptionHeaders: () => (NodeGetMicroBlockTransactionsByHashExceptionHeaders),
+  NodeGetMicroBlockTransactionsCountByHashExceptionHeaders: () => (NodeGetMicroBlockTransactionsCountByHashExceptionHeaders),
+  NodeGetNameEntryByNameExceptionHeaders: () => (NodeGetNameEntryByNameExceptionHeaders),
+  NodeGetNameEntryByNameHashExceptionHeaders: () => (NodeGetNameEntryByNameHashExceptionHeaders),
+  NodeGetNodeSettingsExceptionHeaders: () => (NodeGetNodeSettingsExceptionHeaders),
+  NodeGetOracleByPubkeyExceptionHeaders: () => (NodeGetOracleByPubkeyExceptionHeaders),
+  NodeGetOracleQueriesByPubkeyExceptionHeaders: () => (NodeGetOracleQueriesByPubkeyExceptionHeaders),
+  NodeGetOracleQueryByPubkeyAndQueryIdExceptionHeaders: () => (NodeGetOracleQueryByPubkeyAndQueryIdExceptionHeaders),
+  NodeGetPeerPubkeyExceptionHeaders: () => (NodeGetPeerPubkeyExceptionHeaders),
+  NodeGetPendingAccountTransactionsByPubkeyExceptionHeaders: () => (NodeGetPendingAccountTransactionsByPubkeyExceptionHeaders),
+  NodeGetPendingKeyBlockExceptionHeaders: () => (NodeGetPendingKeyBlockExceptionHeaders),
+  NodeGetPinningTxExceptionHeaders: () => (NodeGetPinningTxExceptionHeaders),
+  NodeGetProtocolParametersExceptionHeaders: () => (NodeGetProtocolParametersExceptionHeaders),
+  NodeGetRecentGasPricesExceptionHeaders: () => (NodeGetRecentGasPricesExceptionHeaders),
+  NodeGetStatusExceptionHeaders: () => (NodeGetStatusExceptionHeaders),
+  NodeGetSyncStatusExceptionHeaders: () => (NodeGetSyncStatusExceptionHeaders),
+  NodeGetTopHeaderExceptionHeaders: () => (NodeGetTopHeaderExceptionHeaders),
+  NodeGetTransactionByHashExceptionHeaders: () => (NodeGetTransactionByHashExceptionHeaders),
+  NodeGetTransactionInfoByHashExceptionHeaders: () => (NodeGetTransactionInfoByHashExceptionHeaders),
+  NodePostTransactionExceptionHeaders: () => (NodePostTransactionExceptionHeaders),
+  NodeProtectedDryRunTxsExceptionHeaders: () => (NodeProtectedDryRunTxsExceptionHeaders),
+  NodeSettings: () => (NodeSettings),
   OffChainCallContract: () => (OffChainCallContract),
   OffChainDeposit: () => (OffChainDeposit),
   OffChainNewContract: () => (OffChainNewContract),
@@ -7536,19 +7586,22 @@ __webpack_require__.d(mappers_namespaceObject, {
   PoI: () => (PoI),
   PostTxResponse: () => (PostTxResponse),
   Protocol: () => (Protocol),
+  ProtocolConsensusParameters: () => (ProtocolConsensusParameters),
+  ProtocolParameters: () => (ProtocolParameters),
   PubKey: () => (PubKey),
   RegisteredOracle: () => (RegisteredOracle),
   RelativeTTL: () => (RelativeTTL),
   SignedTx: () => (SignedTx),
   SignedTxs: () => (SignedTxs),
   SpendTx: () => (SpendTx),
+  SpendTxInput: () => (SpendTxInput),
+  StateGasPerBlock: () => (StateGasPerBlock),
   Status: () => (Status),
   SyncStatus: () => (SyncStatus),
   TokenSupply: () => (TokenSupply),
   Ttl: () => (Ttl),
   Tx: () => (Tx),
   TxInfoObject: () => (TxInfoObject),
-  UnsignedTx: () => (UnsignedTx),
   discriminators: () => (discriminators)
 });
 
@@ -8796,10 +8849,28 @@ function wrapWithProxy(valueCb) {
     return typeof res === 'function' && name === 'get' ? res.bind(target) : res;
   }])));
 }
+
+/**
+ * Returns the value a proxy wraps. Anything keyed by a node must key by this: `onNode` is a proxy
+ * created once per sdk instance and its identity doesn't change on `selectNode`, so a cache keyed
+ * by the proxy would apply one network's values on another.
+ */
 function unwrapProxy(value) {
   var _wrappedValue;
   return (_wrappedValue = value._wrappedValue) !== null && _wrappedValue !== void 0 ? _wrappedValue : value;
 }
+
+/**
+ * The same as {@link unwrapProxy}, but returns `undefined` instead of throwing when the proxy has
+ * nothing to unwrap — an sdk instance with no node selected wraps a value that isn't there yet.
+ */
+function unwrapProxyIfPossible(value) {
+  try {
+    return unwrapProxy(value);
+  } catch {
+    return undefined;
+  }
+}
 // EXTERNAL MODULE: external "tweetnacl"
 var external_tweetnacl_ = __webpack_require__(1655);
 var external_tweetnacl_default = /*#__PURE__*/__webpack_require__.n(external_tweetnacl_);
@@ -9157,8 +9228,13 @@ const DRY_RUN_ACCOUNT = {
 };
 
 /**
+ * The maximum gas of a generalized account authentication function as it was at the moment of the
+ * SDK release. It is a node policy setting rather than a consensus parameter.
  * @category account generalized
- * @deprecated transaction builder will ensure that gas doesn't exceed the maximum value by itself
+ * @deprecated the transaction builder ensures that gas doesn't exceed the maximum by itself, and a
+ * node may accept another maximum than this constant. Use
+ * `(await getCachedProtocolParameters(node)).maxAuthFunGas` for the value the connected node
+ * reports, or `defaultProtocolParameters.maxAuthFunGas` for this one.
  */
 const MAX_AUTH_FUN_GAS = 50000;
 /**
@@ -9170,7 +9246,11 @@ const MAX_AUTH_FUN_GAS = 50000;
  */
 
 /**
+ * The consensus minimum gas price as it was at the moment of the SDK release.
  * @category transaction builder
+ * @deprecated a node may run another minimum gas price, and this constant is wrong on it. Use
+ * `(await getCachedProtocolParameters(node)).minGasPrice` for the value the connected node
+ * reports, or `defaultProtocolParameters.minGasPrice` for this one.
  */
 const MIN_GAS_PRICE = 1e9; // TODO: don't use number for ae
 /**
@@ -9243,6 +9323,7 @@ const NAME_BID_RANGES = mapObject({
  */
 let ConsensusProtocolVersion = /*#__PURE__*/function (ConsensusProtocolVersion) {
   ConsensusProtocolVersion[ConsensusProtocolVersion["Ceres"] = 6] = "Ceres";
+  ConsensusProtocolVersion[ConsensusProtocolVersion["Arcus"] = 7] = "Arcus";
   return ConsensusProtocolVersion;
 }({});
 
@@ -9996,6 +10077,20 @@ const ProtocolToVmAbi = {
       vmVersion: [],
       abiVersion: [AbiVersion.NoAbi, AbiVersion.Fate]
     }
+  },
+  [ConsensusProtocolVersion.Arcus]: {
+    'contract-create': {
+      vmVersion: [VmVersion.Fate3],
+      abiVersion: [AbiVersion.Fate]
+    },
+    'contract-call': {
+      vmVersion: [],
+      abiVersion: [AbiVersion.Fate]
+    },
+    'oracle-call': {
+      vmVersion: [],
+      abiVersion: [AbiVersion.NoAbi, AbiVersion.Fate]
+    }
   }
 };
 function getProtocolDetails(protocolVersion, type) {
@@ -10032,6 +10127,24 @@ function getProtocolDetails(protocolVersion, type) {
     };
   }
 });
+;// ./src/tx/builder/field-types/interface.ts
+// TODO: give `Field` an optional `validate` that `buildTx` runs before `serialize` and
+//  `rebuildUnpackedTx` skips, so that a field can't check a value without being asked to. Needs
+//  `packRecord` to stop passing params and options through the same channel first — a string key
+//  in that channel would be forgeable from `JSON.parse`, which is why this is a symbol — and
+//  `fee` to stop sharing its fixpoint between the default and the check [breaking change]
+/**
+ * Set in the params of a transaction that is re-serialized rather than built — see
+ * `rebuildUnpackedTx`. Fields that check their value against the protocol parameters serialize it
+ * as it is instead: the transaction already exists, its values may belong to other parameters than
+ * the ones this build runs against, and re-checking them would reject a valid transaction that is
+ * serialized verbatim anyway.
+ *
+ * A symbol so that it can't come out of a `JSON.parse`. It is not a trust boundary either way —
+ * `protocolParameters` decides what those same checks compare against and is a plain string key,
+ * as are `fee`, `gasPrice`, and `gasLimit`.
+ */
+const serializeAsIsParam = Symbol('serializeAsIs');
 ;// ./src/tx/builder/field-types/abi-version.ts
 
 
@@ -10220,32 +10333,611 @@ function genEnumerationField(enm) {
     }
   };
 }
+;// ./src/tx/builder/protocol-parameters.ts
+
+
+
+
+
+/**
+ * Consensus parameters and node policy settings the transaction builder needs to produce a
+ * transaction the node would accept — see {@link getCachedProtocolParameters}.
+ * @category transaction builder
+ */
+
+/**
+ * Transaction option to build a transaction against specific consensus parameters. `buildTxAsync`
+ * sets it to the parameters it requests from node, provide it to build a transaction offline for a
+ * node that doesn't run the protocol version the current SDK release was made for.
+ * @category transaction builder
+ */
+
+const BASE_GAS = 15000;
+const defaultStateGasPerBlock = {
+  part: 32000,
+  whole: Math.floor(60 * 24 * 365 / 3)
+};
+
+/**
+ * Protocol parameters are shared between every transaction built against them, and
+ * {@link defaultProtocolParameters} is shared process-wide. `readonly` guards them at compile time
+ * only, so freeze them to make sure a transaction can't be mispriced by an unrelated component
+ * mutating parameters it doesn't own.
+ */
+function freezeParameters(parameters) {
+  Object.values(parameters.contractTxBaseGas).forEach(Object.freeze);
+  Object.values(parameters.stateGasPerBlock).forEach(Object.freeze);
+  Object.freeze(parameters.txBaseGas);
+  Object.freeze(parameters.contractTxBaseGas);
+  Object.freeze(parameters.stateGasPerBlock);
+  return Object.freeze(parameters);
+}
+
+/**
+ * Protocol parameters of Ceres as they were at the moment of the SDK release. Used to build
+ * transactions without a node connection, and on nodes that don't provide the protocol parameters
+ * endpoint yet.
+ * @category transaction builder
+ * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}
+ */
+const defaultProtocolParameters = freezeParameters({
+  minGasPrice: BigInt(MIN_GAS_PRICE),
+  minMinerGasPrice: BigInt(MIN_GAS_PRICE),
+  gasPerByte: 20,
+  blockGasLimit: 6e6,
+  maxAuthFunGas: MAX_AUTH_FUN_GAS,
+  txBaseGas: {
+    ...Object.fromEntries(Object.values(Tag).filter(tag => typeof tag === 'number')
+    // node reports the base gas of contract-executing types in `contract_tx_base_gas`,
+    // `SignedTx` is not a chargeable transaction type
+    .filter(tag => ![Tag.SignedTx, Tag.ContractCreateTx, Tag.ContractCallTx, Tag.GaAttachTx, Tag.GaMetaTx].includes(tag)).map(tag => [tag, BASE_GAS])),
+    [Tag.ChannelForceProgressTx]: 30 * BASE_GAS,
+    [Tag.ChannelOffChainTx]: 0,
+    [Tag.PayingForTx]: BASE_GAS / 5
+  },
+  contractTxBaseGas: {
+    [Tag.ContractCreateTx]: {
+      [AbiVersion.Sophia]: 5 * BASE_GAS,
+      [AbiVersion.Fate]: 5 * BASE_GAS
+    },
+    [Tag.ContractCallTx]: {
+      [AbiVersion.Sophia]: 12 * BASE_GAS,
+      [AbiVersion.Fate]: 12 * BASE_GAS
+    },
+    [Tag.GaAttachTx]: {
+      [AbiVersion.Sophia]: 5 * BASE_GAS,
+      [AbiVersion.Fate]: 5 * BASE_GAS
+    },
+    [Tag.GaMetaTx]: {
+      [AbiVersion.Sophia]: 5 * BASE_GAS,
+      [AbiVersion.Fate]: 5 * BASE_GAS
+    }
+  },
+  stateGasPerBlock: Object.fromEntries([Tag.OracleRegisterTx, Tag.OracleExtendTx, Tag.OracleQueryTx, Tag.OracleRespondTx].map(tag => [tag, {
+    ...defaultStateGasPerBlock
+  }]))
+});
+
+// node names transaction types after `aetx:type_to_swagger_name/1`, it matches `Tag` except of these
+const txTypeToTag = {
+  GAAttachTx: Tag.GaAttachTx,
+  GAMetaTx: Tag.GaMetaTx
+};
+function getTag(txType) {
+  // node controls these keys, `isKeyOfObject` also accepts anything inherited from
+  // `Object.prototype` (`constructor`, `toString`) — a name of a transaction type is neither
+  const isOwnKeyOf = object => Object.prototype.hasOwnProperty.call(object, txType);
+  if (isOwnKeyOf(txTypeToTag) && isKeyOfObject(txType, txTypeToTag)) return txTypeToTag[txType];
+  if (!isOwnKeyOf(Tag) || !isKeyOfObject(txType, Tag)) return undefined;
+  // `Tag` is a numeric enum, so it is also indexable by a member value (`Tag['12'] === 'SpendTx'`)
+  const tag = Tag[txType];
+  return typeof tag === 'number' ? tag : undefined;
+}
+
+// Node decides these values and they multiply into the fee the user pays, so a node that is
+// compromised, misconfigured, or impersonated could make the SDK build a transaction with an
+// extreme fee. A hard fork may legitimately raise them, but not by orders of magnitude — refuse to
+// build against a value far above the one the SDK was released with rather than silently overpay.
+const maxRaiseFactor = 1000;
+function excessiveError(name, value, limit) {
+  return new NodeError(`Node reports ${name} as ${String(value)}, which is outside of the range the SDK considers` + ` plausible (0..${limit}). Provide \`protocolParameters\` in options to build a transaction` + ' against these parameters anyway.');
+}
+
+/**
+ * A value that doesn't match the schema node declares for it — the api client passes `null`,
+ * booleans, strings, and fractions through unchanged. Not a {@link NodeError}: the parameters are
+ * unreadable rather than implausible, so {@link getCachedProtocolParameters} falls back to
+ * {@link defaultProtocolParameters}, as for a node without the endpoint (which a node can force
+ * with a 404 anyway).
+ */
+function malformedError(name, value) {
+  return new InternalError(`Node reports ${name} as ${String(value)}, which doesn't match the schema it declares for it`);
+}
+
+/**
+ * Checks a value node reports against the one the SDK was released with, returns the factor it is
+ * raised by.
+ */
+function checkNotExcessive(name, value, sdkValue) {
+  // a parameter the SDK release has at 0 can only stay at 0, it raises the fee by nothing
+  const raise = number => sdkValue === 0 ? 1 : number / sdkValue;
+  const limit = sdkValue * maxRaiseFactor;
+  // a bigint matches the schema whatever its magnitude, so one out of range is an implausible
+  // value rather than an unreadable one. Compared as a bigint: a value far enough above the limit
+  // can't be counted in a number, and that is what makes it implausible in the first place
+  if (typeof value === 'bigint') {
+    if (value < 0n || value > BigInt(limit)) throw excessiveError(name, value, limit);
+    return raise(Number(value));
+  }
+  if (!Number.isSafeInteger(value)) throw malformedError(name, value);
+  if (value < 0 || value > limit) throw excessiveError(name, value, limit);
+  return raise(value);
+}
+
+/**
+ * `Math.max(...array)` passes every element as an argument and overflows the stack on an array
+ * node can make arbitrarily long — it reports one entry per transaction type and abi version.
+ */
+function maxOf(numbers) {
+  return numbers.reduce((max, number) => number > max ? number : max, -Infinity);
+}
+
+// TODO: express the bound in aettos instead — a defaulted value may not commit the user to more
+//  than a fixed coin amount — rather than as a ratio against the parameters of the SDK release.
+//  That states the actual requirement directly and holds on any network, but it defaults a higher
+//  gas limit on a network that raised the block gas limit, so it is a behavior change, not a
+//  refactor [behavior change on networks running other parameters]
+/**
+ * How much node's parameters raise each product a transaction costs, against the SDK release.
+ * Kept out of {@link ProtocolParameters} because they are not consensus parameters but a property
+ * of where the parameters came from — the ones a caller provides in options don't go through here.
+ *
+ * One per gas amount the SDK picks itself, and not one per parameter: each is charged to the value
+ * it bounds, so that a raise of one doesn't shrink a value it has nothing to do with.
+ */
+
+const parameterRaises = new WeakMap();
+
+// parameters this process built itself are checked where they are built — the ones of the SDK
+// release by construction, the ones node reports by `checkParametersNotExcessive`. This remembers
+// the caller-provided ones already walked, a build reads them once per field and per rebuild pass
+const usableParameters = new WeakSet();
+function checkUsableGas(name, value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new ArgumentError(`protocolParameters.${name}`, 'a non-negative safe integer', value);
+  }
+}
+
+/**
+ * Checks that parameters a caller provided in options can price a transaction at all — only values
+ * that would produce `NaN`, `Infinity`, or a division by zero, not their magnitude: options are the
+ * way out of the bounds {@link convertProtocolParameters} applies, bounding them here would leave
+ * no way to build against a network the SDK release doesn't know. They are as trusted as `fee` and
+ * `gasLimit`: must not come from untrusted input, this only turns an unusable value into an error
+ * naming the field. See `serializeAsIsParam`.
+ * @param parameters - Parameters provided in options
+ */
+function checkParametersUsable(parameters) {
+  // built by this process, or already walked
+  if (parameterRaises.has(parameters) || usableParameters.has(parameters)) return;
+  if (typeof parameters.minGasPrice !== 'bigint' || parameters.minGasPrice < 1n) {
+    throw new ArgumentError('protocolParameters.minGasPrice', 'a positive bigint (a transaction can’t be priced against 0)', parameters.minGasPrice);
+  }
+  if (typeof parameters.minMinerGasPrice !== 'bigint' || parameters.minMinerGasPrice < 0n) {
+    throw new ArgumentError('protocolParameters.minMinerGasPrice', 'a non-negative bigint', parameters.minMinerGasPrice);
+  }
+  checkUsableGas('gasPerByte', parameters.gasPerByte);
+  checkUsableGas('blockGasLimit', parameters.blockGasLimit);
+  checkUsableGas('maxAuthFunGas', parameters.maxAuthFunGas);
+  Object.entries(parameters.txBaseGas).forEach(([tag, gas]) => {
+    var _Tag$tag;
+    return checkUsableGas(`txBaseGas.${(_Tag$tag = Tag[+tag]) !== null && _Tag$tag !== void 0 ? _Tag$tag : tag}`, gas);
+  });
+  Object.entries(parameters.contractTxBaseGas).forEach(([tag, byAbiVersion]) => Object.entries(byAbiVersion !== null && byAbiVersion !== void 0 ? byAbiVersion : {}).forEach(([abiVersion, gas]) => {
+    var _Tag$tag2;
+    return checkUsableGas(`contractTxBaseGas.${(_Tag$tag2 = Tag[+tag]) !== null && _Tag$tag2 !== void 0 ? _Tag$tag2 : tag}.${abiVersion}`, gas);
+  }));
+  Object.entries(parameters.stateGasPerBlock).forEach(([tag, fraction]) => {
+    var _Tag$tag3, _fraction$whole;
+    const name = `stateGasPerBlock.${(_Tag$tag3 = Tag[+tag]) !== null && _Tag$tag3 !== void 0 ? _Tag$tag3 : tag}`;
+    checkUsableGas(`${name}.part`, fraction?.part);
+    // a `whole` of 0 makes the state gas — and so the fee — infinite
+    if (!Number.isSafeInteger(fraction?.whole) || ((_fraction$whole = fraction?.whole) !== null && _fraction$whole !== void 0 ? _fraction$whole : 0) < 1) {
+      throw new ArgumentError(`${name}.whole`, 'a positive safe integer', fraction?.whole);
+    }
+  });
+  usableParameters.add(parameters);
+}
+function checkRatioNotExcessive(name, {
+  part,
+  whole
+}, sdkRatio) {
+  if (!Number.isSafeInteger(part) || !Number.isSafeInteger(whole)) {
+    throw malformedError(name, `${String(part)}/${String(whole)}`);
+  }
+  const limit = sdkRatio * maxRaiseFactor;
+  // a `whole` of 0 would make the fee infinite, `0 / 0` is NaN — both fail the check below
+  const ratio = part >= 0 && whole > 0 ? part / whole : NaN;
+  if (!(ratio >= 0) || ratio > limit) throw excessiveError(name, `${part}/${whole}`, limit);
+  return ratio / sdkRatio;
+}
+
+/**
+ * The base gas the SDK release charges for a transaction type, whichever of the two tables it is
+ * in. `getTxBaseGas` reads `contractTxBaseGas` before `txBaseGas`, so an entry node adds to
+ * `contractTxBaseGas` overrides the `txBaseGas` of that very type — checking it against a
+ * type-independent constant would let node raise, say, a `PayingForTx` (3000) to 15000000 and
+ * still be counted as a raise of 1000.
+ */
+function defaultBaseGasOf(tag) {
+  var _d$contractTxBaseGas$;
+  const d = defaultProtocolParameters;
+  const values = [d.txBaseGas[tag], ...Object.values((_d$contractTxBaseGas$ = d.contractTxBaseGas[tag]) !== null && _d$contractTxBaseGas$ !== void 0 ? _d$contractTxBaseGas$ : {})].filter(value => value != null);
+  const max = values.length !== 0 ? maxOf(values) : BASE_GAS;
+  // a type charged 0 (`ChannelOffChainTx`) would get a budget of 0, and node reporting any gas for
+  // it would refuse the whole response. Give it an ordinary type's budget instead — a node charging
+  // more than `maxRaiseFactor` base gas units for it is still refused
+  return max !== 0 ? max : BASE_GAS;
+}
+function checkRaiseNotExcessive(what, raise) {
+  if (raise <= maxRaiseFactor) return;
+  throw new NodeError(`Node reports parameters raising ${what} ${Math.round(raise)} times above the one of the SDK` + ` release, more than the ${maxRaiseFactor} times the SDK considers plausible. Provide` + ' `protocolParameters` in options to build a transaction against these parameters anyway.');
+}
+
+/**
+ * Refuses the parameters if node reports values far above the ones of the SDK release, and returns
+ * the factors the two products a transaction costs may be raised by — see {@link ParameterRaises}.
+ */
+function checkParametersNotExcessive(parameters) {
+  const d = defaultProtocolParameters;
+  const defaultMinGasPrice = Number(d.minGasPrice);
+  // a gas price of 0 makes every fee 0 — the network would reject the transaction, and the
+  // `minFee / minGasPrice` of the demand-based fee is a division by zero
+  if (parameters.minGasPrice < 1n) {
+    throw new NodeError(`Node reports the minimum gas price as ${parameters.minGasPrice}, a transaction can't be` + ' priced against it. Provide `protocolParameters` in options to build a transaction' + ' against these parameters anyway.');
+  }
+  // both raise the gas price the fee is counted from: the consensus minimum directly, the miner
+  // minimum as the floor `getCachedIncreasedGasPrice` lifts the gas price to. Bounding the miner
+  // minimum on its own — as this used to — leaves node the product of the two to raise the fee by.
+  const gasPriceRaise = maxOf([checkNotExcessive('the minimum gas price', parameters.minGasPrice, defaultMinGasPrice), checkNotExcessive('the miner minimum gas price', parameters.minMinerGasPrice, defaultMinGasPrice)]);
+
+  // every one of these is a gas amount the fee is counted from, the biggest raise among them is
+  // the most a transaction's gas can grow by
+  const gasRaises = [checkNotExcessive('the gas per byte', parameters.gasPerByte, d.gasPerByte)];
+  Object.entries(parameters.txBaseGas).forEach(([tag, gas]) => {
+    // against the default of this very type and not against the biggest default of all types: a
+    // `ChannelForceProgressTx` costs 30 times a `SpendTx`, that is not a budget for a `SpendTx`
+    gasRaises.push(checkNotExcessive(`the base gas of ${Tag[+tag]}`, gas, defaultBaseGasOf(+tag)));
+  });
+  Object.entries(parameters.contractTxBaseGas).forEach(([tag, byAbiVersion]) => {
+    const sdkValue = defaultBaseGasOf(+tag);
+    Object.entries(byAbiVersion).forEach(([abiVersion, gas]) => {
+      const name = `the base gas of ${Tag[+tag]} at abi version ${abiVersion}`;
+      gasRaises.push(checkNotExcessive(name, gas, sdkValue));
+    });
+  });
+  const defaultStateGasRatio = defaultStateGasPerBlock.part / defaultStateGasPerBlock.whole;
+  Object.entries(parameters.stateGasPerBlock).forEach(([tag, fraction]) => {
+    const name = `the state gas per block of ${Tag[+tag]}`;
+    gasRaises.push(checkRatioNotExcessive(name, fraction, defaultStateGasRatio));
+  });
+
+  // the minimum fee is `gasPrice * (baseGas + size * gasPerByte + stateGas)`, so each product is
+  // bounded rather than each parameter — otherwise node could combine them into a fee
+  // `maxRaiseFactor` squared above the one of the SDK release
+  const feeGasRaise = maxOf(gasRaises);
+  checkRaiseNotExcessive('the minimum transaction fee', gasPriceRaise * feeGasRaise);
+
+  // the two bound different transaction types, but both are a gas limit multiplied by the same
+  // gas price — the bigger of them is what the worst case costs
+  const blockGasLimitRaise = checkNotExcessive('the block gas limit', parameters.blockGasLimit, d.blockGasLimit);
+  const maxAuthFunGasRaise = checkNotExcessive('the max auth fun gas', parameters.maxAuthFunGas, d.maxAuthFunGas);
+  const gasLimitRaise = maxOf([blockGasLimitRaise, maxAuthFunGasRaise]);
+  checkRaiseNotExcessive('the cost of a contract transaction', gasPriceRaise * gasLimitRaise);
+
+  // the gas above is multiplied by a gas price that doesn't come from these parameters, and that
+  // is bounded on its own — so the raises are reported to lower those bounds by the same factors,
+  // see `getGasPriceDivisor` and `getGasLimitDivisor`
+  return {
+    fee: maxOf([1, feeGasRaise]),
+    blockGasLimit: maxOf([1, blockGasLimitRaise]),
+    maxAuthFunGas: maxOf([1, maxAuthFunGasRaise])
+  };
+}
+
+/**
+ * Factor the gas price ceiling of `gas-price.ts` is lowered by, so that the worst case fee doesn't
+ * become the product of that ceiling and the fee gas bound of {@link convertProtocolParameters}.
+ * The gas limit raise is charged to the gas limit default instead ({@link getGasLimitDivisor}).
+ * It is 1 unless the parameters came from node.
+ *
+ * The biggest raise among all transaction types, not the one of the type being built — so a node
+ * repricing one type lowers the ceiling for every type. The ceiling is 100000 times the minimum
+ * gas price, far above the demand-based price this bounds in practice.
+ * @param parameters - Parameters a transaction is built against
+ */
+function getGasPriceDivisor(parameters) {
+  var _parameterRaises$get$;
+  return (_parameterRaises$get$ = parameterRaises.get(parameters)?.fee) !== null && _parameterRaises$get$ !== void 0 ? _parameterRaises$get$ : 1;
+}
+
+/**
+ * The cost of a contract transaction is `gasPrice * gasLimit`, and the gas limit the SDK defaults
+ * to comes from `blockGasLimit` — from `maxAuthFunGas` on a `GaMetaTx`. This is the factor node
+ * raises the one `tag` reads by, so that lowering the default by it keeps the product within the
+ * one of the SDK release. It is 1 unless the parameters came from node.
+ *
+ * Only the limit `tag` reads: charging the other one would shrink a gas limit because node raised
+ * something that transaction never reads. The fee gas raise is charged to the gas price ceiling
+ * ({@link getGasPriceDivisor}) instead.
+ * @param parameters - Parameters a transaction is built against
+ * @param tag - Type of the transaction the gas limit is defaulted for
+ */
+function getGasLimitDivisor(parameters, tag) {
+  const raises = parameterRaises.get(parameters);
+  if (raises == null) return 1;
+  return tag === Tag.GaMetaTx ? raises.maxAuthFunGas : raises.blockGasLimit;
+}
+function mapByTxType(entries, map) {
+  return Object.fromEntries(entries.map(([txType, value]) => [getTag(txType), map(value)])
+  // a transaction type the SDK doesn't implement, or won't ever build (`ChannelClientReconnectTx`)
+  .filter(entry => entry[0] != null));
+}
+
+/**
+ * Converts the node responses to the shape the transaction builder uses, rejecting values far
+ * above the ones the SDK was released with. Not a part of the public api, it is exported for
+ * tests — use {@link getCachedProtocolParameters}.
+ * @param response - Response of the `/v3/protocol-parameters` endpoint
+ * @param nodeSettings - Response of the `/v3/node-settings` endpoint
+ */
+function convertProtocolParameters(response, nodeSettings) {
+  const {
+    currentProtocolVersion,
+    protocols
+  } = response;
+  const protocol = protocols.find(({
+    version
+  }) => version === currentProtocolVersion);
+  if (protocol == null) {
+    throw new InternalError(`Node doesn't provide parameters of the current protocol ${currentProtocolVersion}`);
+  }
+
+  // starts from the values of the SDK release so that a type or an abi version node doesn't report
+  // keeps building against them, as the SDK did before this endpoint existed, instead of failing
+  const contractTxBaseGas = Object.fromEntries(Object.entries(defaultProtocolParameters.contractTxBaseGas).map(([tag, byAbiVersion]) => [tag, {
+    ...byAbiVersion
+  }]));
+  protocol.contractTxBaseGas.forEach(({
+    txType,
+    abiVersion,
+    txBaseGas
+  }) => {
+    var _contractTxBaseGas$ta;
+    const tag = getTag(txType);
+    // node controls `abiVersion` and the api client passes a value that doesn't match the schema
+    // node declares for it through unchanged. A `__proto__` key would be written into the
+    // prototype: invisible to the `Object.values` of the check below, and still returned by the
+    // `byAbiVersion[abiVersion]` lookup the fee is calculated from
+    if (tag == null || !Number.isInteger(abiVersion)) return;
+    const byAbiVersion = (_contractTxBaseGas$ta = contractTxBaseGas[tag]) !== null && _contractTxBaseGas$ta !== void 0 ? _contractTxBaseGas$ta : contractTxBaseGas[tag] = {};
+    byAbiVersion[abiVersion] = txBaseGas;
+  });
+  const reportedTxBaseGas = mapByTxType(Object.entries(protocol.txBaseGas), gas => gas);
+  const parameters = freezeParameters({
+    minGasPrice: protocol.minimumGasPrice,
+    minMinerGasPrice: nodeSettings.minMinerGasPrice,
+    gasPerByte: protocol.gasPerByte,
+    blockGasLimit: nodeSettings.blockGasLimit,
+    maxAuthFunGas: nodeSettings.maxAuthFunGas,
+    txBaseGas: {
+      // see the note on `contractTxBaseGas` above
+      ...defaultProtocolParameters.txBaseGas,
+      ...reportedTxBaseGas
+    },
+    contractTxBaseGas,
+    stateGasPerBlock: {
+      // see the note on `contractTxBaseGas` above
+      ...defaultProtocolParameters.stateGasPerBlock,
+      ...mapByTxType(Object.entries(protocol.stateGasPerBlock), fraction => ({
+        part: fraction.part,
+        whole: fraction.whole
+      }))
+    }
+  });
+  parameterRaises.set(parameters, checkParametersNotExcessive(parameters));
+  return parameters;
+}
+const cache = new WeakMap();
+// protocol parameters change on a hard fork, or when the node operator edits the node config,
+// neither happens often enough to justify a request per transaction built
+const cacheTtl = 10 * 60 * 1000;
+// a node that can't be reached, or that reports parameters the SDK refuses to build against, may
+// be reachable or reconfigured in a moment — don't keep the whole `cacheTtl` worth of transactions
+// building against the parameters of the SDK release, or failing, because of one bad response.
+// Still cached rather than retried per transaction: both outcomes cost a round trip to reproduce.
+const transientCacheTtl = 30 * 1000;
+
+/**
+ * Requests protocol parameters from node, the result is cached per node instance.
+ *
+ * Falls back to {@link defaultProtocolParameters} for a node that doesn't provide the endpoints,
+ * can't be reached, or answers something this SDK release can't read. Rejects only when node
+ * reports parameters that would price a transaction far above the SDK release — see
+ * {@link ProtocolParametersOption} for the way out of that.
+ *
+ * The cache is keyed by the `Node` object, so code that constructs a `Node` per request (a
+ * serverless handler, an edge worker) requests the parameters again for each one. Keep one `Node`
+ * instance per endpoint to get the benefit of the cache.
+ * @category transaction builder
+ * @param nodeOrProxy - Node to request the parameters from
+ */
+async function getCachedProtocolParameters(nodeOrProxy) {
+  const node = unwrapProxy(nodeOrProxy);
+  const entry = cache.get(node);
+  if (entry != null && entry.expiresAt > Date.now()) return entry.parameters;
+
+  // node is expected to respond with 404 until it gets the endpoints, and a node whose operator
+  // disabled the `node_info`/`node_settings` endpoint groups with 403 — neither changes within
+  // `cacheTtl`, while anything else is worth asking again about sooner
+  let ttl = cacheTtl;
+  // the request and the conversion both run in here so that only a deliberate refusal — a
+  // `NodeError` on implausible parameters — comes out as a rejection; anything unreadable falls
+  // back to the parameters of the SDK release instead of making every transaction unbuildable
+  const parameters = (async () => {
+    const fallBack = reason => {
+      ttl = transientCacheTtl;
+      console.warn("Can't get protocol parameters from node, using the ones of the SDK release instead." + ' A transaction may be rejected if this node runs other parameters.' + ` Reason: ${reason instanceof Error ? reason.message : String(reason)}`);
+      return defaultProtocolParameters;
+    };
+
+    // a node object without the methods (a test double, another SDK copy's `Node`) won't grow
+    // them within `transientCacheTtl` — treat like the 404 of an old node: full-interval cache,
+    // and no warning per 30 seconds for the life of the process
+    if (typeof node.getProtocolParameters !== 'function' || typeof node.getNodeSettings !== 'function') {
+      return defaultProtocolParameters;
+    }
+
+    // retrying the 404 on every transaction built would only add latency
+    const noRetry = {
+      requestOptions: {
+        customHeaders: {
+          '__no-retry': 'true'
+        }
+      }
+    };
+    let response;
+    let nodeSettings;
+    try {
+      // consensus parameters and this node's own policy are two endpoints, and a transaction is
+      // priced by both — requested together so that a build waits for one round trip and not two,
+      // and taken as a set: parameters half from node and half from the SDK release would be
+      // neither ones node accepts nor ones the SDK was tested against
+      [response, nodeSettings] = await Promise.all([node.getProtocolParameters(noRetry), node.getNodeSettings(noRetry)]);
+    } catch (error) {
+      // the 404/403 of the note above — neither is worth a warning, or an earlier retry.
+      // Read off the error rather than through `instanceof RestError`: that would import
+      // `@azure/core-rest-pipeline` as a value into the transaction builder, which is otherwise
+      // free of it, and pull the http stack into the bundle of an application that only packs
+      // transactions. The api client is the only thing that rejects here, and it sets this
+      const {
+        statusCode
+      } = error;
+      if (statusCode === 404 || statusCode === 403) return defaultProtocolParameters;
+      // node is syncing (503), a proxy in between is down, the request timed out
+      return fallBack(error);
+    }
+    try {
+      return convertProtocolParameters(response, nodeSettings);
+    } catch (error) {
+      // node reports parameters that would price a transaction far above the SDK release — falling
+      // back would build a transaction this node rejects, so the caller is told to decide instead
+      if (error instanceof NodeError) throw error;
+      return fallBack(error);
+    }
+  })();
+
+  // until it settles the entry keeps concurrent builds on this one request
+  const cacheEntry = {
+    expiresAt: Date.now() + cacheTtl,
+    parameters
+  };
+  parameters.then(() => {
+    cacheEntry.expiresAt = Date.now() + ttl;
+  },
+  // see `transientCacheTtl`
+  () => {
+    cacheEntry.expiresAt = Date.now() + transientCacheTtl;
+  });
+  cache.set(node, cacheEntry);
+  return parameters;
+}
 ;// ./src/tx/builder/field-types/gas-price.ts
 
 
 
 
 
+
+
 const gasPriceCache = new WeakMap();
-async function getCachedIncreasedGasPrice(node) {
-  const cache = gasPriceCache.get(node);
-  if (cache != null && cache.time > Date.now() - 20 * 1000) {
-    return cache.gasPrice;
+
+// the ceiling is based on the gas price of the SDK release and not on the one node reports, so
+// that node can't raise its own limit — a node asking for more than the ceiling gets an
+// underpriced transaction rather than the user an unbounded fee. Max microblock fee is 600ae or
+// 35usd, counted with the gas of the SDK release — see `getGasPriceDivisor`
+const maxSafeGasPrice = defaultProtocolParameters.minGasPrice * 100000n;
+
+/**
+ * Gas price the recent demand of the network suggests, cached per node. Depends on the network
+ * only — the miner floor is applied by the caller, so that a caller providing its own
+ * {@link ProtocolParameters} doesn't put a gas price based on them into a cache others share.
+ *
+ * The request is cached rather than its result, and this body has no `await` before registering
+ * it: `buildTxAsync` prepares fields concurrently, so `fee.prepare` and `gasPrice.prepare` both
+ * ask before either could write a result, and sharing the promise keeps that one round trip.
+ */
+function getCachedDemandGasPrice(node) {
+  const cached = gasPriceCache.get(node);
+  if (cached != null && cached.time > Date.now() - 20 * 1000) {
+    return cached;
   }
-  const {
-    minGasPrice,
-    utilization
-  } = (await node.getRecentGasPrices())[0];
-  let gasPrice = utilization < 70 ? 0n : BigInt(new (external_bignumber_js_default())(minGasPrice.toString()).times(1.01).integerValue().toFixed());
-  const maxSafeGasPrice = BigInt(MIN_GAS_PRICE) * 100000n; // max microblock fee is 600ae or 35usd
-  if (gasPrice > maxSafeGasPrice) {
-    console.warn(`Estimated gas price ${gasPrice} exceeds the maximum safe value for unknown reason.` + ` It will be limited to ${maxSafeGasPrice}.` + ' To overcome this restriction provide `gasPrice`/`fee` in options.');
-    gasPrice = maxSafeGasPrice;
-  }
-  gasPriceCache.set(node, {
+  const gasPrice = (async () => {
+    const {
+      minGasPrice,
+      utilization
+    } = (await node.getRecentGasPrices())[0];
+    const price = utilization < 70 ? 0n : BigInt(new (external_bignumber_js_default())(minGasPrice.toString()).times(1.01).integerValue().toFixed());
+    if (price <= maxSafeGasPrice) return price;
+    console.warn(`Estimated gas price ${price} exceeds the maximum safe value for unknown reason.` + ` It will be limited to ${maxSafeGasPrice}.` + ' To overcome this restriction provide `gasPrice`/`fee` in options.');
+    return maxSafeGasPrice;
+  })();
+  const entry = {
     gasPrice,
     time: Date.now()
+  };
+  gasPriceCache.set(node, entry);
+  gasPrice.then(() => {
+    // the interval is about how long the value stays representative, and it starts when the
+    // value is known — stamping the request instead would shorten it by the round trip, and on
+    // a link slower than the interval every build would open a request of its own
+    entry.time = Date.now();
+  },
+  // a request that failed may succeed on the next transaction built, and a gas price that can't
+  // be requested fails the build — unlike `getCachedProtocolParameters`, which caches its
+  // failures because it falls back to the parameters of the SDK release and the build goes on
+  () => {
+    if (gasPriceCache.get(node) === entry) gasPriceCache.delete(node);
   });
+  return entry;
+}
+async function getCachedIncreasedGasPrice(nodeOrProxy, parameters) {
+  const node = unwrapProxy(nodeOrProxy);
+  const demandEntry = getCachedDemandGasPrice(node);
+  // the caller may have been given the parameters to build against, requesting them from node
+  // would both waste a request and ignore the `minMinerGasPrice` it was asked to use
+  const [protocolParameters, demandGasPrice] = await Promise.all([parameters !== null && parameters !== void 0 ? parameters : getCachedProtocolParameters(node), demandEntry.gasPrice]);
+  let gasPrice = demandGasPrice;
+
+  // 0n means "the consensus minimum", it is below what the miner of this node accepts
+  const minerFloor = protocolParameters.minMinerGasPrice > protocolParameters.minGasPrice ? protocolParameters.minMinerGasPrice : 0n;
+  if (gasPrice < minerFloor) gasPrice = minerFloor;
+
+  // the ceiling goes down by the factor the parameters raise the fee gas by — see
+  // `getGasPriceDivisor`. Counted in thousandths so that a hard fork raising the gas a few percent
+  // lowers the ceiling a few percent, rather than halving it by rounding the factor up
+  const gasRaise = BigInt(Math.ceil(getGasPriceDivisor(protocolParameters) * 1000));
+  // this can't cut the miner floor applied above: `checkParametersNotExcessive` bounds the miner
+  // minimum times the fee gas raise by `maxRaiseFactor`, and the ceiling is 100 times
+  // `maxRaiseFactor` above the minimum gas price, so it stays 100 times above the floor
+  const ceiling = maxSafeGasPrice * 1000n / gasRaise;
+  if (gasPrice > ceiling) {
+    if (gasRaise > 1000n && demandEntry.ceilingWarned !== true) {
+      demandEntry.ceilingWarned = true;
+      console.warn(`Estimated gas price ${gasPrice} exceeds the maximum safe value ${ceiling} for the` + ' protocol parameters node reports. It will be limited to it, so the transaction may be' + ' not mined while the demand stays above it. To overcome this restriction provide' + ' `gasPrice`/`fee`, or `protocolParameters` in options.');
+    }
+    gasPrice = ceiling;
+  }
   return gasPrice;
 }
 
@@ -10254,21 +10946,27 @@ async function getCachedIncreasedGasPrice(node) {
   ...coin_amount,
   async prepare(value, params, {
     onNode,
-    denomination
+    denomination,
+    protocolParameters
   }) {
     if (value != null) return value;
     if (onNode == null) {
       throw new ArgumentError('onNode', 'provided (or provide `gasPrice` instead)', onNode);
     }
-    const gasPrice = await getCachedIncreasedGasPrice(onNode);
+    const gasPrice = await getCachedIncreasedGasPrice(onNode, protocolParameters);
     if (gasPrice === 0n) return undefined;
     return formatAmount(gasPrice, {
       targetDenomination: denomination
     });
   },
-  serializeAettos(value = MIN_GAS_PRICE.toString()) {
-    if (+value < MIN_GAS_PRICE) {
-      throw new IllegalArgumentError(`Gas price ${value.toString()} must be bigger than ${MIN_GAS_PRICE}`);
+  serializeAettos(value, params, {
+    protocolParameters = defaultProtocolParameters
+  }) {
+    const minGasPrice = protocolParameters.minGasPrice.toString();
+    if (value == null) return minGasPrice;
+    if (params[serializeAsIsParam] === true) return value;
+    if (new (external_bignumber_js_default())(value).lt(minGasPrice)) {
+      throw new IllegalArgumentError(`Gas price ${value} must be bigger than ${minGasPrice}`);
     }
     return value;
   }
@@ -10282,67 +10980,65 @@ async function getCachedIncreasedGasPrice(node) {
 
 
 
-const BASE_GAS = 15000;
-const GAS_PER_BYTE = 20;
-const KEY_BLOCK_INTERVAL = 3;
+
 
 /**
- * Calculate the base gas
+ * Get the base gas
  * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}
- * @param txType - The transaction type
+ * @param txObject - The unpacked transaction
+ * @param protocolParameters - The protocol parameters
  * @returns The base gas
- * @example
- * ```js
- * TX_BASE_GAS(Tag.ChannelForceProgressTx) => 30 * 15000
- * ```
  */
-const TX_BASE_GAS = txType => {
-  var _feeFactors;
-  const feeFactors = {
-    [Tag.ChannelForceProgressTx]: 30,
-    [Tag.ChannelOffChainTx]: 0,
-    [Tag.ContractCreateTx]: 5,
-    [Tag.ContractCallTx]: 12,
-    [Tag.GaAttachTx]: 5,
-    [Tag.GaMetaTx]: 5,
-    [Tag.PayingForTx]: 1 / 5
-  };
-  const factor = (_feeFactors = feeFactors[txType]) !== null && _feeFactors !== void 0 ? _feeFactors : 1;
-  return factor * BASE_GAS;
-};
+function getTxBaseGas(txObject, protocolParameters) {
+  const {
+    tag
+  } = txObject;
+  const byAbiVersion = protocolParameters.contractTxBaseGas[tag];
+  if (byAbiVersion != null) {
+    var _txObject$ctVersion$a;
+    const abiVersion = (_txObject$ctVersion$a = txObject.ctVersion?.abiVersion) !== null && _txObject$ctVersion$a !== void 0 ? _txObject$ctVersion$a : txObject.abiVersion;
+    // read only what the checks in `protocol-parameters.ts` iterate, so that the two can't
+    // disagree about what the parameters hold — anything inherited is not a base gas
+    const gas = Object.prototype.hasOwnProperty.call(byAbiVersion, abiVersion) ? byAbiVersion[abiVersion] : undefined;
+    if (gas != null) return gas;
+    // node charges the maximum base gas for an abi version it doesn't know
+    const knownAbiVersions = Object.values(byAbiVersion);
+    // the maximum of nothing is `-Infinity`, fall through to `txBaseGas` instead
+    if (knownAbiVersions.length !== 0) return maxOf(knownAbiVersions);
+  }
+  const gas = protocolParameters.txBaseGas[tag];
+  if (gas == null) throw new InternalError(`Base gas of ${Tag[tag]} is not known`);
+  return gas;
+}
 
 /**
  * Calculate gas for other types of transactions
  * @see {@link https://github.com/aeternity/protocol/blob/master/consensus/README.md#gas}
  * @param txType - The transaction type
  * @param txSize - The transaction size
- * @returns parameters - The transaction parameters
- * @returns parameters.relativeTtl - The relative ttl
- * @returns parameters.innerTxSize - The size of the inner transaction
+ * @param parameters - The transaction parameters
+ * @param parameters.relativeTtl - The relative ttl
+ * @param parameters.innerTxSize - The size of the inner transaction
+ * @param protocolParameters - The protocol parameters
  * @returns The other gas
- * @example
- * ```js
- * TX_OTHER_GAS(Tag.OracleRespondTx, 10, { relativeTtl: 12, innerTxSize: 0 })
- *  => 10 * 20 + Math.ceil(32000 * 12 / Math.floor(60 * 24 * 365 / 3))
- * ```
  */
-const TX_OTHER_GAS = (txType, txSize, {
+function getTxOtherGas(txType, txSize, {
   relativeTtl,
   innerTxSize
-}) => {
-  switch (txType) {
-    case Tag.OracleRegisterTx:
-    case Tag.OracleExtendTx:
-    case Tag.OracleQueryTx:
-    case Tag.OracleRespondTx:
-      return txSize * GAS_PER_BYTE + Math.ceil(32000 * relativeTtl / Math.floor(60 * 24 * 365 / KEY_BLOCK_INTERVAL));
-    case Tag.GaMetaTx:
-    case Tag.PayingForTx:
-      return (txSize - innerTxSize) * GAS_PER_BYTE;
-    default:
-      return txSize * GAS_PER_BYTE;
-  }
-};
+}, protocolParameters) {
+  const {
+    gasPerByte
+  } = protocolParameters;
+  // the inner transaction of a meta transaction pays for its own bytes in its own fee. The
+  // deduction is separate from the state gas below: node reporting a state gas fraction for
+  // `GaMetaTx`/`PayingForTx` must not cancel it — that would charge the inner transaction twice
+  const isMeta = txType === Tag.GaMetaTx || txType === Tag.PayingForTx;
+  const sizeGas = (isMeta ? txSize - innerTxSize : txSize) * gasPerByte;
+  // oracle transactions pay a state rent for the time their entry occupies the state tree
+  const stateGas = protocolParameters.stateGasPerBlock[txType];
+  if (stateGas == null) return sizeGas;
+  return sizeGas + Math.ceil(stateGas.part * relativeTtl / stateGas.whole);
+}
 function getOracleRelativeTtl(params) {
   const ttlKeys = {
     [Tag.OracleRegisterTx]: 'oracleTtlValue',
@@ -10360,19 +11056,25 @@ function getOracleRelativeTtl(params) {
 /**
  * Calculate gas based on tx type and params
  */
-function buildGas(builtTx, unpackTx, buildTx) {
+function buildGas(builtTx, unpackTx, buildTx, protocolParameters) {
   const {
     length
   } = decode(builtTx);
   const txObject = unpackTx(builtTx);
   let innerTxSize = 0;
   if (txObject.tag === Tag.GaMetaTx || txObject.tag === Tag.PayingForTx) {
-    innerTxSize = decode(buildTx(txObject.tx.encodedTx)).length;
+    // this rebuild only measures the size of an already signed inner transaction, its values are
+    // serialized as they are — see `serializeAsIsParam`
+    const innerTx = {
+      ...txObject.tx.encodedTx,
+      [serializeAsIsParam]: true
+    };
+    innerTxSize = decode(buildTx(innerTx)).length;
   }
-  return TX_BASE_GAS(txObject.tag) + TX_OTHER_GAS(txObject.tag, length, {
+  return getTxBaseGas(txObject, protocolParameters) + getTxOtherGas(txObject.tag, length, {
     relativeTtl: getOracleRelativeTtl(txObject),
     innerTxSize
-  });
+  }, protocolParameters);
 }
 
 /**
@@ -10380,12 +11082,13 @@ function buildGas(builtTx, unpackTx, buildTx) {
  * @category transaction builder
  * @param rebuildTx - Callback to get built transaction with specific fee
  */
-function calculateMinFee(rebuildTx, unpackTx, buildTx) {
+function calculateMinFee(rebuildTx, unpackTx, buildTx, protocolParameters) {
+  const minGasPrice = new (external_bignumber_js_default())(protocolParameters.minGasPrice.toString());
   let fee = new (external_bignumber_js_default())(0);
   let previousFee;
   do {
     previousFee = fee;
-    fee = new (external_bignumber_js_default())(MIN_GAS_PRICE).times(buildGas(rebuildTx(fee), unpackTx, buildTx));
+    fee = minGasPrice.times(buildGas(rebuildTx(fee), unpackTx, buildTx, protocolParameters));
   } while (!fee.eq(previousFee));
   return fee;
 }
@@ -10397,29 +11100,33 @@ const gasPricePrefix = '_gas-price:';
 /* harmony default export */ const fee = ({
   ...coin_amount,
   async prepare(value, params, {
-    onNode
+    onNode,
+    protocolParameters
   }) {
     if (value != null) return value;
     if (onNode == null) {
       throw new ArgumentError('onNode', 'provided (or provide `fee` instead)', onNode);
     }
-    const gasPrice = await getCachedIncreasedGasPrice(onNode);
+    const gasPrice = await getCachedIncreasedGasPrice(onNode, protocolParameters);
     if (gasPrice === 0n) return undefined;
     return gasPricePrefix + gasPrice;
   },
-  serializeAettos(_value, {
-    rebuildTx,
-    unpackTx,
-    buildTx,
-    _computingMinFee
-  }, {
-    _canIncreaseFee
+  serializeAettos(_value, params, {
+    _canIncreaseFee,
+    protocolParameters = defaultProtocolParameters
   }) {
+    const {
+      rebuildTx,
+      unpackTx,
+      buildTx,
+      _computingMinFee
+    } = params;
     if (_computingMinFee != null) return _computingMinFee.toFixed();
+    if (params[serializeAsIsParam] === true && _value != null) return new (external_bignumber_js_default())(_value).toFixed();
     const minFee = calculateMinFee(fee => rebuildTx({
       _computingMinFee: fee
-    }), unpackTx, buildTx);
-    const value = _value?.startsWith(gasPricePrefix) === true ? minFee.dividedBy(MIN_GAS_PRICE).times(_value.replace(gasPricePrefix, '')) : new (external_bignumber_js_default())(_value !== null && _value !== void 0 ? _value : minFee);
+    }), unpackTx, buildTx, protocolParameters);
+    const value = _value?.startsWith(gasPricePrefix) === true ? minFee.dividedBy(protocolParameters.minGasPrice.toString()).times(_value.replace(gasPricePrefix, '')) : new (external_bignumber_js_default())(_value !== null && _value !== void 0 ? _value : minFee);
     if (minFee.gt(value)) {
       if (_canIncreaseFee === true) return minFee.toFixed();
       throw new IllegalArgumentError(`Fee ${value.toString()} must be bigger than ${minFee}`);
@@ -10448,26 +11155,37 @@ const gasPricePrefix = '_gas-price:';
 
 
 
-function calculateGasLimitMax(gasMax, rebuildTx, unpackTx, buildTx) {
-  return gasMax - +buildGas(rebuildTx(gasMax), unpackTx, buildTx);
+
+
+function calculateGasLimitMax(gasMax, rebuildTx, unpackTx, buildTx, protocolParameters) {
+  return gasMax - +buildGas(rebuildTx(gasMax), unpackTx, buildTx, protocolParameters);
 }
 /* harmony default export */ const gas_limit = ({
   ...short_u_int,
-  serialize(_value, {
-    tag,
-    rebuildTx,
-    unpackTx,
-    buildTx,
-    _computingGasLimit
-  }, {
-    gasMax = 6e6
+  serialize(_value, params, {
+    gasMax,
+    protocolParameters = defaultProtocolParameters
   }) {
+    const {
+      tag,
+      rebuildTx,
+      unpackTx,
+      buildTx,
+      _computingGasLimit
+    } = params;
     if (_computingGasLimit != null) return short_u_int.serialize(_computingGasLimit);
-    const gasLimitMax = tag === Tag.GaMetaTx ? MAX_AUTH_FUN_GAS : calculateGasLimitMax(gasMax, gasLimit => rebuildTx({
+    if (params[serializeAsIsParam] === true && _value != null) return short_u_int.serialize(_value);
+    const gasLimitMax = tag === Tag.GaMetaTx ? protocolParameters.maxAuthFunGas : calculateGasLimitMax(gasMax !== null && gasMax !== void 0 ? gasMax : protocolParameters.blockGasLimit, gasLimit => rebuildTx({
       _computingGasLimit: gasLimit,
       _canIncreaseFee: true
-    }), unpackTx, buildTx);
-    const value = _value !== null && _value !== void 0 ? _value : gasLimitMax;
+    }), unpackTx, buildTx, protocolParameters);
+    // node raises the ceiling above through the parameter this tag reads, so the value defaulted
+    // here is lowered by that raise — see `getGasLimitDivisor`. Only the default: a caller passing
+    // `gasLimit`, or capping it with `gasMax`, chose it itself — except on `GaMetaTx`, whose
+    // ceiling is `maxAuthFunGas` and never reads `gasMax`
+    const capped = gasMax != null && tag !== Tag.GaMetaTx;
+    const raise = capped ? 1 : getGasLimitDivisor(protocolParameters, tag);
+    const value = _value !== null && _value !== void 0 ? _value : raise > 1 ? Math.floor(gasLimitMax / raise) : gasLimitMax;
     if (value > gasLimitMax) {
       throw new IllegalArgumentError(`Gas limit ${value} must be less or equal to ${gasLimitMax}`);
     }
@@ -10504,9 +11222,15 @@ function calculateGasLimitMax(gasMax, rebuildTx, unpackTx, buildTx) {
 
 
 
+
 /* harmony default export */ const name_fee = ({
   ...coin_amount,
   serializeAettos(_value, txFields) {
+    // SDK-release table, node reports it as `nameClaimFees` (all zeroes on a protocol that doesn't
+    // enforce it) — skipped on re-serialization, see `serializeAsIsParam`
+    if (txFields[serializeAsIsParam] === true && _value != null) {
+      return new (external_bignumber_js_default())(_value).toFixed();
+    }
     const minNameFee = getMinimumNameFee(txFields.name);
     const value = new (external_bignumber_js_default())(_value !== null && _value !== void 0 ? _value : minNameFee);
     if (minNameFee.gt(value)) throw new InsufficientNameFeeError(value, minNameFee);
@@ -10581,6 +11305,7 @@ function genNonceField(senderKey) {
 
 
 
+
 const ID_TAG = Buffer.from([1]);
 const DATA_TAG = Buffer.from([2]);
 const DATA_LENGTH_MAX = 1024;
@@ -10593,10 +11318,13 @@ const addressAny = genAddressField(...idTagToEncoding);
    * Helper function to build pointers for name update TX
    * @param pointers - Array of pointers
    * `([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])`
+   * @param params - Transaction params
    * @returns Serialized pointers array
    */
-  serialize(pointers) {
-    if (pointers.length > 32) {
+  serialize(pointers, params) {
+    // SDK-release limit, node reports it as `namePointersMaxCount` (omitted on a protocol that
+    // imposes no limit) — skipped on re-serialization, see `serializeAsIsParam`
+    if (params[serializeAsIsParam] !== true && pointers.length > 32) {
       throw new IllegalArgumentError(`Expected 32 pointers or less, got ${pointers.length} instead`);
     }
     return pointers.map(({
@@ -10705,11 +11433,15 @@ function genShortUIntConstField(constValue, optional) {
 });
 ;// ./src/tx/builder/field-types/transaction.ts
 
+
 function genTransactionField(tag) {
   return {
-    serialize(txParams, {
-      buildTx
-    }) {
+    nestedTransaction: true,
+    serialize(txParams, options) {
+      const {
+        buildTx,
+        protocolParameters
+      } = options;
       if (ArrayBuffer.isView(txParams)) return Buffer.from(txParams);
       if (typeof txParams === 'string' && txParams.startsWith('tx_')) {
         return decode(txParams);
@@ -10718,6 +11450,17 @@ function genTransactionField(tag) {
         ...txParams,
         ...(tag != null && {
           tag
+        }),
+        // a nested transaction that is not built yet is built against the parameters of the
+        // outer one, otherwise it would be priced by the parameters of the SDK release
+        ...(protocolParameters != null && {
+          protocolParameters
+        }),
+        // a transaction nested in one that is only re-serialized is re-serialized as well —
+        // without this the innermost transaction of a `PayingForTx` wrapping a `GaMetaTx` gets
+        // its already fixed values checked against the parameters of the outermost one
+        ...(options[serializeAsIsParam] === true && {
+          [serializeAsIsParam]: true
         })
       }));
     },
@@ -10777,7 +11520,7 @@ function withFormatting(format, field) {
   return {
     ...field,
     serialize(value, params, options) {
-      return field.serialize(format(value), params, options);
+      return field.serialize(format(value, params), params, options);
     }
   };
 }
@@ -10861,6 +11604,7 @@ let EntryTag = /*#__PURE__*/function (EntryTag) {
 
 
 
+
 
 
 /**
@@ -10882,9 +11626,12 @@ const clientTtl = withDefault(60 * 60, short_u_int);
 /**
  * Name ttl represented in number of blocks (Max value is 50000 blocks)
  */
-const nameTtl = withFormatting(value => {
+const nameTtl = withFormatting((value, params) => {
   const NAME_TTL = 180000;
   value !== null && value !== void 0 ? value : value = NAME_TTL;
+  // SDK-release limit, node reports it as `nameClaimMaxExpiration` — skipped on re-serialization,
+  // see `serializeAsIsParam`
+  if (params[serializeAsIsParam] === true) return value;
   if (value >= 1 && value <= NAME_TTL) return value;
   throw new ArgumentError('nameTtl', `a number between 1 and ${NAME_TTL} blocks`, value);
 }, short_u_int);
@@ -11723,6 +12470,7 @@ const schemas = [{
 
 
 
+
 const encodingTag = [[EntryTag.CallsMtree, Encoding.CallStateTree], [EntryTag.StateTrees, Encoding.StateTrees], [EntryTag.TreesPoi, Encoding.Poi]];
 
 /**
@@ -11734,6 +12482,11 @@ const encodingTag = [[EntryTag.CallsMtree, Encoding.CallStateTree], [EntryTag.St
 
 function packEntry(params) {
   var _encodingTag$find$;
+  // `GaMetaTxAuthData` holds a `gasPrice` priced by them, see the note in `buildTx`
+  const {
+    protocolParameters
+  } = params;
+  if (protocolParameters != null) checkParametersUsable(protocolParameters);
   const encoding = (_encodingTag$find$ = encodingTag.find(([tag]) => tag === params.tag)?.[1]) !== null && _encodingTag$find$ !== void 0 ? _encodingTag$find$ : Encoding.Bytearray;
   return packRecord(schemas, EntryTag, params, {
     packEntry
@@ -11764,6 +12517,8 @@ function unpackEntry(encoded, expectedTag) {
 
 
 
+
+
 /**
  * JavaScript-based Transaction builder
  */
@@ -11777,6 +12532,11 @@ function builder_getSchema(tag, version) {
  * @param params - Transaction params
  */
 function buildTx(params) {
+  // as trusted as `fee` is, see `checkParametersUsable`
+  const {
+    protocolParameters
+  } = params;
+  if (protocolParameters != null) checkParametersUsable(protocolParameters);
   return packRecord(txSchema, Tag, params, {
     // eslint-disable-next-line @typescript-eslint/no-use-before-define
     unpackTx,
@@ -11788,6 +12548,58 @@ function buildTx(params) {
     packEntry: packEntry
   }, Encoding.Transaction);
 }
+
+/**
+ * Serializes a transaction that already exists — the result of an `unpackTx` — back to its
+ * `tx_`-encoded form.
+ *
+ * Use it instead of `buildTx` for a round trip. The values of such a transaction are fixed, and
+ * belong to the protocol parameters of the node it was built for: a node running a lower minimum
+ * gas price than the SDK release, a hyperchain or a devnet, produces a transaction that plain
+ * `buildTx` would refuse to serialize again because its fee is below the minimum this process
+ * computes. Nothing about it can be changed by re-serializing it, so nothing about it is checked.
+ * @category transaction builder
+ * @param params - Unpacked transaction, as returned by `unpackTx`
+ */
+function rebuildUnpackedTx(params) {
+  return buildTx({
+    ...params,
+    [serializeAsIsParam]: true
+  });
+}
+// the fields the protocol parameters price
+const parametrizedFields = ['fee', 'gasPrice', 'gasLimit'];
+
+/**
+ * The parameters are needed to compute a priced value the caller didn't provide, and to check one
+ * it did against what node accepts. A build that provides every priced field of its type, and
+ * nests no transaction that still has to be built, serializes to the same bytes with or without
+ * them — requesting them would turn a build that needs no node into one that waits for it, as it
+ * would for a caller that passes `fee` exactly to avoid the round trip.
+ */
+function needsProtocolParameters(schema, params) {
+  return schema.some(([key, field]) => {
+    const value = params[key];
+    if (parametrizedFields.includes(key)) return value == null;
+    // a nested transaction that is neither built (`tx_`) nor serialized (a buffer) yet is built
+    // here, and priced by these parameters in turn
+    if (field.nestedTransaction !== true) return false;
+    if (value == null || typeof value === 'string' || ArrayBuffer.isView(value)) return false;
+    // it is built here, but that doesn't mean anything in it is priced — the `SignedTx` wrapping
+    // an already serialized transaction that `AccountGeneralized` nests in its `GaMetaTx` has no
+    // priced field of its own
+    const nested = value;
+    let nestedSchema;
+    try {
+      nestedSchema = builder_getSchema(nested.tag, nested.version);
+    } catch {
+      // an unknown tag or version fails later in `buildTx` with a better message than here
+      return true;
+    }
+    return needsProtocolParameters(nestedSchema, nested);
+  });
+}
+
 // TODO: require onNode because it is the only reason this builder is async [breaking change]
 /**
  * Build transaction async (may request node for additional data)
@@ -11796,14 +12608,42 @@ function buildTx(params) {
  * @returns tx_-encoded transaction
  */
 async function buildTxAsync(params) {
-  await Promise.all(builder_getSchema(params.tag, params.version).map(async ([key, field]) => {
+  var _target$protocolParam;
+  // the caller may build another transaction out of the same object, and `prepare` writing the
+  // value it computed back would make the next build reuse them — the same nonce above all, and a
+  // `fee` that makes it skip the request for the parameters that priced this one
+  const paramsCopy = {
+    ...params
+  };
+  const {
+    onNode
+  } = paramsCopy;
+  const target = paramsCopy;
+  const schema = builder_getSchema(paramsCopy.tag, paramsCopy.version);
+  // `onNode` of an sdk instance is a proxy that is not `null` even when no node is selected, and
+  // dereferencing it throws — a transaction that needs no node is still buildable in that case
+  const node = onNode != null ? unwrapProxyIfPossible(onNode) : undefined;
+  // started before the `prepare` calls below so that it runs in parallel with them: they read the
+  // parameters, but get this very request from the cache it registers synchronously. Below the
+  // `Promise.all` it would make `prepare` the originator and serialize the two requests
+  const parametersPromise = node != null && target.protocolParameters == null && needsProtocolParameters(schema, paramsCopy) ? getCachedProtocolParameters(node) : undefined;
+  // it is awaited after the `prepare` calls below, don't report it as an unhandled rejection if
+  // one of them throws first
+  parametersPromise?.catch(() => {});
+  await Promise.all(schema.map(async ([key, field]) => {
     if (field.prepare == null) return;
-    // @ts-expect-error the type of `params[key]` can't be determined accurately
-    params[key] = await field.prepare(params[key], params, params);
+    // @ts-expect-error the type of `paramsCopy[key]` can't be determined accurately
+    paramsCopy[key] = await field.prepare(paramsCopy[key], paramsCopy, paramsCopy);
   }));
+  const protocolParameters = (_target$protocolParam = target.protocolParameters) !== null && _target$protocolParam !== void 0 ? _target$protocolParam : await parametersPromise;
 
   // @ts-expect-error after preparation properties should be compatible with sync tx builder
-  return buildTx(params);
+  return buildTx({
+    ...paramsCopy,
+    ...(protocolParameters != null && {
+      protocolParameters
+    })
+  });
 }
 
 /**
@@ -12226,6 +13066,9 @@ const SignedTx = {
         }
       },
       hash: {
+        constraints: {
+          Pattern: new RegExp("^th_\\w+$")
+        },
         serializedName: "hash",
         required: true,
         type: {
@@ -12233,6 +13076,9 @@ const SignedTx = {
         }
       },
       encodedTx: {
+        constraints: {
+          Pattern: new RegExp("^tx_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "encoded_tx",
         type: {
           name: "String"
@@ -12244,6 +13090,9 @@ const SignedTx = {
         type: {
           name: "Sequence",
           element: {
+            constraints: {
+              Pattern: new RegExp("^sg_\\w+$")
+            },
             type: {
               name: "String"
             }
@@ -12418,6 +13267,9 @@ const Tx = {
         }
       },
       offchainTrees: {
+        constraints: {
+          Pattern: new RegExp("^ss_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "offchain_trees",
         type: {
           name: "String"
@@ -12444,6 +13296,9 @@ const Tx = {
         }
       },
       poi: {
+        constraints: {
+          Pattern: new RegExp("^pi_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "poi",
         type: {
           name: "String"
@@ -12543,6 +13398,9 @@ const Tx = {
         }
       },
       queryId: {
+        constraints: {
+          Pattern: new RegExp("^oq_\\w+$")
+        },
         serializedName: "query_id",
         type: {
           name: "String"
@@ -12555,6 +13413,9 @@ const Tx = {
         }
       },
       commitmentId: {
+        constraints: {
+          Pattern: new RegExp("^cm_\\w+$")
+        },
         serializedName: "commitment_id",
         type: {
           name: "String"
@@ -12586,6 +13447,9 @@ const Tx = {
         }
       },
       nameId: {
+        constraints: {
+          Pattern: new RegExp("^nm_\\w+$")
+        },
         serializedName: "name_id",
         type: {
           name: "String"
@@ -12630,6 +13494,9 @@ const Tx = {
         }
       },
       code: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "code",
         type: {
           name: "String"
@@ -12676,6 +13543,9 @@ const Tx = {
         }
       },
       callData: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "call_data",
         type: {
           name: "String"
@@ -12709,6 +13579,9 @@ const Tx = {
         }
       },
       authData: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "auth_data",
         type: {
           name: "String"
@@ -12866,6 +13739,9 @@ const NamePointer = {
         }
       },
       encodedKey: {
+        constraints: {
+          Pattern: new RegExp("^ba_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "encoded_key",
         type: {
           name: "String"
@@ -12887,6 +13763,9 @@ const AuctionEntry = {
     className: "AuctionEntry",
     modelProperties: {
       id: {
+        constraints: {
+          Pattern: new RegExp("^nm_\\w+$")
+        },
         serializedName: "id",
         required: true,
         type: {
@@ -13148,6 +14027,9 @@ const ByteCode = {
     className: "ByteCode",
     modelProperties: {
       bytecode: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "bytecode",
         required: true,
         type: {
@@ -13163,6 +14045,9 @@ const PoI = {
     className: "PoI",
     modelProperties: {
       poi: {
+        constraints: {
+          Pattern: new RegExp("^pi_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "poi",
         required: true,
         type: {
@@ -13351,12 +14236,18 @@ const DryRunInputItem = {
     className: "DryRunInputItem",
     modelProperties: {
       tx: {
+        constraints: {
+          Pattern: new RegExp("^tx_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "tx",
         type: {
           name: "String"
         }
       },
       txHash: {
+        constraints: {
+          Pattern: new RegExp("^th_\\w+$")
+        },
         serializedName: "tx_hash",
         type: {
           name: "String"
@@ -13378,6 +14269,9 @@ const DryRunCallReq = {
     className: "DryRunCallReq",
     modelProperties: {
       calldata: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "calldata",
         required: true,
         type: {
@@ -13452,12 +14346,18 @@ const DryRunCallContext = {
     className: "DryRunCallContext",
     modelProperties: {
       tx: {
+        constraints: {
+          Pattern: new RegExp("^tx_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "tx",
         type: {
           name: "String"
         }
       },
       txHash: {
+        constraints: {
+          Pattern: new RegExp("^th_\\w+$")
+        },
         serializedName: "tx_hash",
         type: {
           name: "String"
@@ -13621,6 +14521,9 @@ const ContractCallObject = {
         }
       },
       returnValue: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "return_value",
         required: true,
         type: {
@@ -13667,6 +14570,9 @@ const mappers_Event = {
         }
       },
       data: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "data",
         required: true,
         type: {
@@ -13762,8 +14668,10 @@ const KeyBlock = {
         }
       },
       flags: {
+        constraints: {
+          Pattern: new RegExp("^ba_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "flags",
-        required: true,
         type: {
           name: "String"
         }
@@ -13827,6 +14735,9 @@ const KeyBlock = {
         }
       },
       info: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "info",
         required: true,
         type: {
@@ -13893,6 +14804,9 @@ const Header = {
         }
       },
       flags: {
+        constraints: {
+          Pattern: new RegExp("^ba_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "flags",
         type: {
           name: "String"
@@ -13956,12 +14870,18 @@ const Header = {
         }
       },
       info: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "info",
         type: {
           name: "String"
         }
       },
       pofHash: {
+        constraints: {
+          Pattern: new RegExp("^(no_fraud|bf_\\w+)$")
+        },
         serializedName: "pof_hash",
         type: {
           name: "String"
@@ -13974,6 +14894,9 @@ const Header = {
         }
       },
       signature: {
+        constraints: {
+          Pattern: new RegExp("^sg_\\w+$")
+        },
         serializedName: "signature",
         type: {
           name: "String"
@@ -14124,6 +15047,9 @@ const MicroBlockHeader = {
         }
       },
       pofHash: {
+        constraints: {
+          Pattern: new RegExp("^(no_fraud|bf_\\w+)$")
+        },
         serializedName: "pof_hash",
         required: true,
         type: {
@@ -14159,6 +15085,9 @@ const MicroBlockHeader = {
         }
       },
       signature: {
+        constraints: {
+          Pattern: new RegExp("^sg_\\w+$")
+        },
         serializedName: "signature",
         required: true,
         type: {
@@ -14182,6 +15111,15 @@ const MicroBlockHeader = {
         type: {
           name: "Number"
         }
+      },
+      flags: {
+        constraints: {
+          Pattern: new RegExp("^ba_[0-9A-Za-z+/=]+$")
+        },
+        serializedName: "flags",
+        type: {
+          name: "String"
+        }
       }
     }
   }
@@ -14211,6 +15149,9 @@ const NameEntry = {
     className: "NameEntry",
     modelProperties: {
       id: {
+        constraints: {
+          Pattern: new RegExp("^nm_\\w+$")
+        },
         serializedName: "id",
         required: true,
         type: {
@@ -14242,7 +15183,7 @@ const NameEntry = {
           element: {
             type: {
               name: "Composite",
-              className: "NamePointerComplete"
+              className: "NameEntryPointersItem"
             }
           }
         }
@@ -14250,35 +15191,6 @@ const NameEntry = {
     }
   }
 };
-const NamePointerComplete = {
-  type: {
-    name: "Composite",
-    className: "NamePointerComplete",
-    modelProperties: {
-      key: {
-        serializedName: "key",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      encodedKey: {
-        serializedName: "encoded_key",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      id: {
-        serializedName: "id",
-        required: true,
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
 const RegisteredOracle = {
   type: {
     name: "Composite",
@@ -14368,6 +15280,9 @@ const OracleQuery = {
     className: "OracleQuery",
     modelProperties: {
       id: {
+        constraints: {
+          Pattern: new RegExp("^oq_\\w+$")
+        },
         serializedName: "id",
         required: true,
         type: {
@@ -14501,83 +15416,142 @@ const GasPricesItem = {
     }
   }
 };
-const Status = {
+const NodeSettings = {
   type: {
     name: "Composite",
-    className: "Status",
+    className: "NodeSettings",
     modelProperties: {
-      genesisKeyBlockHash: {
-        serializedName: "genesis_key_block_hash",
+      minMinerGasPrice: {
+        serializedName: "min_miner_gas_price",
         required: true,
         type: {
-          name: "String"
+          // @ts-expect-error we are extending autorest with BigInt support
+          name: "BigInt"
         }
       },
-      solutions: {
+      maxAuthFunGas: {
         constraints: {
           InclusiveMaximum: 18446744073709552000,
           InclusiveMinimum: 0
         },
-        serializedName: "solutions",
+        serializedName: "max_auth_fun_gas",
         required: true,
         type: {
           name: "Number"
         }
       },
-      difficulty: {
+      mempoolTxTtl: {
         constraints: {
           InclusiveMaximum: 18446744073709552000,
           InclusiveMinimum: 0
         },
-        serializedName: "difficulty",
+        serializedName: "mempool_tx_ttl",
         required: true,
         type: {
           name: "Number"
         }
       },
-      hashrate: {
+      mempoolNonceOffset: {
         constraints: {
           InclusiveMaximum: 18446744073709552000,
           InclusiveMinimum: 0
         },
-        serializedName: "hashrate",
+        serializedName: "mempool_nonce_offset",
         required: true,
         type: {
           name: "Number"
         }
       },
-      syncing: {
-        serializedName: "syncing",
+      dryRunGasLimit: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "dry_run_gas_limit",
         required: true,
         type: {
-          name: "Boolean"
+          name: "Number"
         }
       },
-      syncProgress: {
+      blockGasLimit: {
         constraints: {
-          InclusiveMaximum: 100,
+          InclusiveMaximum: 18446744073709552000,
           InclusiveMinimum: 0
         },
-        serializedName: "sync_progress",
+        serializedName: "block_gas_limit",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const ProtocolParameters = {
+  type: {
+    name: "Composite",
+    className: "ProtocolParameters",
+    modelProperties: {
+      networkId: {
+        serializedName: "network_id",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      currentProtocolVersion: {
+        constraints: {
+          InclusiveMaximum: 4294967295,
+          InclusiveMinimum: 0
+        },
+        serializedName: "current_protocol_version",
+        required: true,
         type: {
           name: "Number"
         }
       },
-      uptime: {
-        serializedName: "uptime",
+      lockedCoinsHolderAccount: {
+        serializedName: "locked_coins_holder_account",
         required: true,
         type: {
           name: "String"
         }
       },
-      listening: {
-        serializedName: "listening",
+      expectedBlockMineRate: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "expected_block_mine_rate",
+        type: {
+          name: "Number"
+        }
+      },
+      childBlockTime: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "child_block_time",
+        type: {
+          name: "Number"
+        }
+      },
+      microBlockCycle: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "micro_block_cycle",
         required: true,
         type: {
-          name: "Boolean"
+          name: "Number"
         }
       },
       protocols: {
+        constraints: {
+          MinItems: 1
+        },
         serializedName: "protocols",
         required: true,
         type: {
@@ -14585,81 +15559,144 @@ const Status = {
           element: {
             type: {
               name: "Composite",
-              className: "Protocol"
+              className: "ProtocolConsensusParameters"
             }
           }
         }
-      },
-      nodeVersion: {
-        serializedName: "node_version",
+      }
+    }
+  }
+};
+const ContractTxBaseGas = {
+  type: {
+    name: "Composite",
+    className: "ContractTxBaseGas",
+    modelProperties: {
+      txType: {
+        serializedName: "tx_type",
         required: true,
         type: {
           name: "String"
         }
       },
-      nodeRevision: {
-        serializedName: "node_revision",
+      abiVersion: {
+        constraints: {
+          InclusiveMaximum: 65535,
+          InclusiveMinimum: 0
+        },
+        serializedName: "abi_version",
         required: true,
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      peerCount: {
+      txBaseGas: {
         constraints: {
-          InclusiveMaximum: 4294967295,
+          InclusiveMaximum: 18446744073709552000,
           InclusiveMinimum: 0
         },
-        serializedName: "peer_count",
+        serializedName: "tx_base_gas",
         required: true,
         type: {
           name: "Number"
         }
-      },
-      peerConnections: {
-        serializedName: "peer_connections",
+      }
+    }
+  }
+};
+const StateGasPerBlock = {
+  type: {
+    name: "Composite",
+    className: "StateGasPerBlock",
+    modelProperties: {
+      part: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "part",
+        required: true,
         type: {
-          name: "Composite",
-          className: "PeerConnections"
+          name: "Number"
         }
       },
-      pendingTransactionsCount: {
+      whole: {
         constraints: {
-          InclusiveMaximum: 4294967295,
+          InclusiveMaximum: 18446744073709552000,
           InclusiveMinimum: 0
         },
-        serializedName: "pending_transactions_count",
+        serializedName: "whole",
         required: true,
         type: {
           name: "Number"
         }
-      },
-      networkId: {
-        serializedName: "network_id",
+      }
+    }
+  }
+};
+const NameAuctionTimeout = {
+  type: {
+    name: "Composite",
+    className: "NameAuctionTimeout",
+    modelProperties: {
+      length: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "length",
         required: true,
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      peerPubkey: {
-        serializedName: "peer_pubkey",
+      bidTimeout: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "bid_timeout",
         required: true,
         type: {
-          name: "String"
+          name: "Number"
         }
       },
-      topKeyBlockHash: {
-        serializedName: "top_key_block_hash",
+      bidExtension: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "bid_extension",
         required: true,
         type: {
-          name: "String"
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const ContractVersion = {
+  type: {
+    name: "Composite",
+    className: "ContractVersion",
+    modelProperties: {
+      vmVersion: {
+        constraints: {
+          InclusiveMaximum: 65535,
+          InclusiveMinimum: 0
+        },
+        serializedName: "vm_version",
+        required: true,
+        type: {
+          name: "Number"
         }
       },
-      topBlockHeight: {
+      abiVersion: {
         constraints: {
-          InclusiveMaximum: 18446744073709552000,
+          InclusiveMaximum: 65535,
           InclusiveMinimum: 0
         },
-        serializedName: "top_block_height",
+        serializedName: "abi_version",
         required: true,
         type: {
           name: "Number"
@@ -14698,6 +15735,173 @@ const Protocol = {
     }
   }
 };
+const Status = {
+  type: {
+    name: "Composite",
+    className: "Status",
+    modelProperties: {
+      genesisKeyBlockHash: {
+        serializedName: "genesis_key_block_hash",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      solutions: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "solutions",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      difficulty: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "difficulty",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      hashrate: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "hashrate",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      syncing: {
+        serializedName: "syncing",
+        required: true,
+        type: {
+          name: "Boolean"
+        }
+      },
+      syncProgress: {
+        constraints: {
+          InclusiveMaximum: 100,
+          InclusiveMinimum: 0
+        },
+        serializedName: "sync_progress",
+        type: {
+          name: "Number"
+        }
+      },
+      uptime: {
+        serializedName: "uptime",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      listening: {
+        serializedName: "listening",
+        required: true,
+        type: {
+          name: "Boolean"
+        }
+      },
+      protocols: {
+        serializedName: "protocols",
+        required: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "Protocol"
+            }
+          }
+        }
+      },
+      nodeVersion: {
+        serializedName: "node_version",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      nodeRevision: {
+        serializedName: "node_revision",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      peerCount: {
+        constraints: {
+          InclusiveMaximum: 4294967295,
+          InclusiveMinimum: 0
+        },
+        serializedName: "peer_count",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      peerConnections: {
+        serializedName: "peer_connections",
+        type: {
+          name: "Composite",
+          className: "PeerConnections"
+        }
+      },
+      pendingTransactionsCount: {
+        constraints: {
+          InclusiveMaximum: 4294967295,
+          InclusiveMinimum: 0
+        },
+        serializedName: "pending_transactions_count",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      networkId: {
+        serializedName: "network_id",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      peerPubkey: {
+        serializedName: "peer_pubkey",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      topKeyBlockHash: {
+        serializedName: "top_key_block_hash",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      topBlockHeight: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "top_block_height",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
 const PeerConnections = {
   type: {
     name: "Composite",
@@ -14778,6 +15982,9 @@ const EncodedTx = {
     className: "EncodedTx",
     modelProperties: {
       tx: {
+        constraints: {
+          Pattern: new RegExp("^tx_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "tx",
         required: true,
         type: {
@@ -14793,6 +16000,9 @@ const PostTxResponse = {
     className: "PostTxResponse",
     modelProperties: {
       txHash: {
+        constraints: {
+          Pattern: new RegExp("^th_\\w+$")
+        },
         serializedName: "tx_hash",
         required: true,
         type: {
@@ -14876,6 +16086,9 @@ const GAObject = {
         }
       },
       returnValue: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "return_value",
         required: true,
         type: {
@@ -15035,6 +16248,9 @@ const ChannelCloseSoloTx = {
         }
       },
       poi: {
+        constraints: {
+          Pattern: new RegExp("^pi_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "poi",
         required: true,
         type: {
@@ -15258,6 +16474,9 @@ const ChannelForceProgressTx = {
         }
       },
       payload: {
+        constraints: {
+          Pattern: new RegExp("^tx_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "payload",
         required: true,
         type: {
@@ -15321,6 +16540,9 @@ const ChannelForceProgressTx = {
         }
       },
       offchainTrees: {
+        constraints: {
+          Pattern: new RegExp("^ss_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "offchain_trees",
         type: {
           name: "String"
@@ -15565,6 +16787,9 @@ const ChannelSlashTx = {
         }
       },
       poi: {
+        constraints: {
+          Pattern: new RegExp("^pi_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "poi",
         required: true,
         type: {
@@ -15738,6 +16963,9 @@ const CommitmentId = {
     className: "CommitmentId",
     modelProperties: {
       commitmentId: {
+        constraints: {
+          Pattern: new RegExp("^cm_\\w+$")
+        },
         serializedName: "commitment_id",
         required: true,
         type: {
@@ -15842,6 +17070,9 @@ const ContractCallTx = {
         }
       },
       callData: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "call_data",
         required: true,
         type: {
@@ -15874,6 +17105,9 @@ const ContractCreateTx = {
         }
       },
       code: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "code",
         required: true,
         type: {
@@ -15968,6 +17202,9 @@ const ContractCreateTx = {
         }
       },
       callData: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "call_data",
         required: true,
         type: {
@@ -15977,21 +17214,6 @@ const ContractCreateTx = {
     }
   }
 };
-const UnsignedTx = {
-  type: {
-    name: "Composite",
-    className: "UnsignedTx",
-    modelProperties: {
-      tx: {
-        serializedName: "tx",
-        required: true,
-        type: {
-          name: "String"
-        }
-      }
-    }
-  }
-};
 const GAAttachTx = {
   type: {
     name: "Composite",
@@ -16015,6 +17237,9 @@ const GAAttachTx = {
         }
       },
       code: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "code",
         required: true,
         type: {
@@ -16087,6 +17312,9 @@ const GAAttachTx = {
         }
       },
       callData: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "call_data",
         required: true,
         type: {
@@ -16173,6 +17401,9 @@ const GAMetaTx = {
         }
       },
       authData: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
         serializedName: "auth_data",
         required: true,
         type: {
@@ -16268,6 +17499,9 @@ const NameHash = {
     className: "NameHash",
     modelProperties: {
       nameId: {
+        constraints: {
+          Pattern: new RegExp("^nm_\\w+$")
+        },
         serializedName: "name_id",
         required: true,
         type: {
@@ -16283,60 +17517,66 @@ const NamePreclaimTx = {
     className: "NamePreclaimTx",
     modelProperties: {
       commitmentId: {
-        serializedName: "commitment_id",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      fee: {
-        constraints: {
-          InclusiveMinimum: 0
-        },
-        serializedName: "fee",
-        required: true,
-        type: {
-          // @ts-expect-error we are extending autorest with BigInt support
-          name: "BigInt"
-        }
-      },
-      ttl: {
         constraints: {
-          InclusiveMaximum: 18446744073709552000,
-          InclusiveMinimum: 0
+          Pattern: new RegExp("^cm_\\w+$")
         },
-        serializedName: "ttl",
-        type: {
-          name: "Number"
-        }
-      },
-      accountId: {
-        serializedName: "account_id",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      nonce: {
-        constraints: {
-          InclusiveMaximum: 18446744073709552000,
-          InclusiveMinimum: 0
-        },
-        serializedName: "nonce",
-        type: {
-          name: "Number"
-        }
-      }
-    }
-  }
-};
-const NameRevokeTx = {
-  type: {
-    name: "Composite",
-    className: "NameRevokeTx",
-    modelProperties: {
-      nameId: {
-        serializedName: "name_id",
+        serializedName: "commitment_id",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      fee: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "fee",
+        required: true,
+        type: {
+          // @ts-expect-error we are extending autorest with BigInt support
+          name: "BigInt"
+        }
+      },
+      ttl: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "ttl",
+        type: {
+          name: "Number"
+        }
+      },
+      accountId: {
+        serializedName: "account_id",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      nonce: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "nonce",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NameRevokeTx = {
+  type: {
+    name: "Composite",
+    className: "NameRevokeTx",
+    modelProperties: {
+      nameId: {
+        constraints: {
+          Pattern: new RegExp("^nm_\\w+$")
+        },
+        serializedName: "name_id",
         required: true,
         type: {
           name: "String"
@@ -16389,6 +17629,9 @@ const NameTransferTx = {
     className: "NameTransferTx",
     modelProperties: {
       nameId: {
+        constraints: {
+          Pattern: new RegExp("^nm_\\w+$")
+        },
         serializedName: "name_id",
         required: true,
         type: {
@@ -16449,6 +17692,9 @@ const NameUpdateTx = {
     className: "NameUpdateTx",
     modelProperties: {
       nameId: {
+        constraints: {
+          Pattern: new RegExp("^nm_\\w+$")
+        },
         serializedName: "name_id",
         required: true,
         type: {
@@ -16866,6 +18112,9 @@ const OracleRespondTx = {
     className: "OracleRespondTx",
     modelProperties: {
       queryId: {
+        constraints: {
+          Pattern: new RegExp("^oq_\\w+$")
+        },
         serializedName: "query_id",
         required: true,
         type: {
@@ -17106,10 +18355,10 @@ const PubKey = {
     }
   }
 };
-const SpendTx = {
+const SpendTxInput = {
   type: {
     name: "Composite",
-    className: "SpendTx",
+    className: "SpendTxInput",
     modelProperties: {
       recipientId: {
         serializedName: "recipient_id",
@@ -17142,114 +18391,1184 @@ const SpendTx = {
       },
       ttl: {
         constraints: {
-          InclusiveMaximum: 18446744073709552000,
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "ttl",
+        type: {
+          name: "Number"
+        }
+      },
+      senderId: {
+        serializedName: "sender_id",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      nonce: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "nonce",
+        type: {
+          name: "Number"
+        }
+      },
+      payload: {
+        serializedName: "payload",
+        required: true,
+        type: {
+          name: "any"
+        }
+      }
+    }
+  }
+};
+const TokenSupply = {
+  type: {
+    name: "Composite",
+    className: "TokenSupply",
+    modelProperties: {
+      accounts: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "accounts",
+        type: {
+          name: "Number"
+        }
+      },
+      contracts: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "contracts",
+        type: {
+          name: "Number"
+        }
+      },
+      contractOracles: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "contract_oracles",
+        type: {
+          name: "Number"
+        }
+      },
+      locked: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "locked",
+        type: {
+          name: "Number"
+        }
+      },
+      oracles: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "oracles",
+        type: {
+          name: "Number"
+        }
+      },
+      oracleQueries: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "oracle_queries",
+        type: {
+          name: "Number"
+        }
+      },
+      pendingRewards: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "pending_rewards",
+        type: {
+          name: "Number"
+        }
+      },
+      total: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "total",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const OffChainCallContract = {
+  serializedName: "OffChainCallContract",
+  type: {
+    name: "Composite",
+    className: "OffChainCallContract",
+    uberParent: "OffChainUpdate",
+    polymorphicDiscriminator: OffChainUpdate.type.polymorphicDiscriminator,
+    modelProperties: {
+      ...OffChainUpdate.type.modelProperties,
+      caller: {
+        serializedName: "caller",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      contract: {
+        serializedName: "contract",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      abiVersion: {
+        constraints: {
+          InclusiveMaximum: 65535,
+          InclusiveMinimum: 0
+        },
+        serializedName: "abi_version",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      amount: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "amount",
+        required: true,
+        type: {
+          // @ts-expect-error we are extending autorest with BigInt support
+          name: "BigInt"
+        }
+      },
+      gas: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "gas",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      gasPrice: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "gas_price",
+        required: true,
+        type: {
+          // @ts-expect-error we are extending autorest with BigInt support
+          name: "BigInt"
+        }
+      },
+      callData: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
+        serializedName: "call_data",
+        required: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+const OffChainDeposit = {
+  serializedName: "OffChainDeposit",
+  type: {
+    name: "Composite",
+    className: "OffChainDeposit",
+    uberParent: "OffChainUpdate",
+    polymorphicDiscriminator: OffChainUpdate.type.polymorphicDiscriminator,
+    modelProperties: {
+      ...OffChainUpdate.type.modelProperties,
+      from: {
+        serializedName: "from",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      amount: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "amount",
+        required: true,
+        type: {
+          // @ts-expect-error we are extending autorest with BigInt support
+          name: "BigInt"
+        }
+      }
+    }
+  }
+};
+const OffChainNewContract = {
+  serializedName: "OffChainNewContract",
+  type: {
+    name: "Composite",
+    className: "OffChainNewContract",
+    uberParent: "OffChainUpdate",
+    polymorphicDiscriminator: OffChainUpdate.type.polymorphicDiscriminator,
+    modelProperties: {
+      ...OffChainUpdate.type.modelProperties,
+      owner: {
+        serializedName: "owner",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      vmVersion: {
+        constraints: {
+          InclusiveMaximum: 65535,
+          InclusiveMinimum: 0
+        },
+        serializedName: "vm_version",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      abiVersion: {
+        constraints: {
+          InclusiveMaximum: 65535,
+          InclusiveMinimum: 0
+        },
+        serializedName: "abi_version",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      code: {
+        serializedName: "code",
+        type: {
+          name: "Composite",
+          className: "ByteCode"
+        }
+      },
+      deposit: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "deposit",
+        required: true,
+        type: {
+          // @ts-expect-error we are extending autorest with BigInt support
+          name: "BigInt"
+        }
+      },
+      callData: {
+        constraints: {
+          Pattern: new RegExp("^cb_[0-9A-Za-z+/=]+$")
+        },
+        serializedName: "call_data",
+        required: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+const OffChainTransfer = {
+  serializedName: "OffChainTransfer",
+  type: {
+    name: "Composite",
+    className: "OffChainTransfer",
+    uberParent: "OffChainUpdate",
+    polymorphicDiscriminator: OffChainUpdate.type.polymorphicDiscriminator,
+    modelProperties: {
+      ...OffChainUpdate.type.modelProperties,
+      from: {
+        serializedName: "from",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      to: {
+        serializedName: "to",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      amount: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "amount",
+        required: true,
+        type: {
+          // @ts-expect-error we are extending autorest with BigInt support
+          name: "BigInt"
+        }
+      }
+    }
+  }
+};
+const OffChainWithdrawal = {
+  serializedName: "OffChainWithdrawal",
+  type: {
+    name: "Composite",
+    className: "OffChainWithdrawal",
+    uberParent: "OffChainUpdate",
+    polymorphicDiscriminator: OffChainUpdate.type.polymorphicDiscriminator,
+    modelProperties: {
+      ...OffChainUpdate.type.modelProperties,
+      to: {
+        serializedName: "to",
+        required: true,
+        type: {
+          name: "String"
+        }
+      },
+      amount: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "amount",
+        required: true,
+        type: {
+          // @ts-expect-error we are extending autorest with BigInt support
+          name: "BigInt"
+        }
+      }
+    }
+  }
+};
+const NameEntryPointersItem = {
+  type: {
+    name: "Composite",
+    className: "NameEntryPointersItem",
+    modelProperties: {
+      ...NamePointer.type.modelProperties
+    }
+  }
+};
+const ProtocolConsensusParameters = {
+  type: {
+    name: "Composite",
+    className: "ProtocolConsensusParameters",
+    modelProperties: {
+      ...Protocol.type.modelProperties,
+      minimumGasPrice: {
+        serializedName: "minimum_gas_price",
+        required: true,
+        type: {
+          // @ts-expect-error we are extending autorest with BigInt support
+          name: "BigInt"
+        }
+      },
+      gasPerByte: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "gas_per_byte",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      storeByteGas: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "store_byte_gas",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      txBaseGas: {
+        serializedName: "tx_base_gas",
+        required: true,
+        type: {
+          name: "Dictionary",
+          value: {
+            type: {
+              name: "Number"
+            },
+            constraints: {
+              InclusiveMaximum: 18446744073709552000,
+              InclusiveMinimum: 0
+            }
+          }
+        }
+      },
+      contractTxBaseGas: {
+        serializedName: "contract_tx_base_gas",
+        required: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ContractTxBaseGas"
+            }
+          }
+        }
+      },
+      stateGasPerBlock: {
+        serializedName: "state_gas_per_block",
+        required: true,
+        type: {
+          name: "Dictionary",
+          value: {
+            type: {
+              name: "Composite",
+              className: "StateGasPerBlock"
+            }
+          }
+        }
+      },
+      nameClaimFees: {
+        constraints: {
+          MinItems: 31,
+          MaxItems: 31
+        },
+        serializedName: "name_claim_fees",
+        required: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              // @ts-expect-error we are extending autorest with BigInt support
+              name: "BigInt"
+            }
+          }
+        }
+      },
+      nameAuctionTimeouts: {
+        serializedName: "name_auction_timeouts",
+        required: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "NameAuctionTimeout"
+            }
+          }
+        }
+      },
+      nameClaimBidIncrement: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "name_claim_bid_increment",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      nameMaxLengthStartingAuction: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "name_max_length_starting_auction",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      nameClaimMaxExpiration: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "name_claim_max_expiration",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      nameRegistrars: {
+        serializedName: "name_registrars",
+        required: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "String"
+            }
+          }
+        }
+      },
+      namePointersMaxCount: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "name_pointers_max_count",
+        type: {
+          name: "Number"
+        }
+      },
+      namePointerMaxKeySize: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "name_pointer_max_key_size",
+        type: {
+          name: "Number"
+        }
+      },
+      namePreclaimExpiration: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "name_preclaim_expiration",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      nameClaimPreclaimDelta: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "name_claim_preclaim_delta",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      nameProtectionPeriod: {
+        constraints: {
+          InclusiveMaximum: 18446744073709552000,
+          InclusiveMinimum: 0
+        },
+        serializedName: "name_protection_period",
+        required: true,
+        type: {
+          name: "Number"
+        }
+      },
+      nameClaimLockedFee: {
+        serializedName: "name_claim_locked_fee",
+        required: true,
+        type: {
+          // @ts-expect-error we are extending autorest with BigInt support
+          name: "BigInt"
+        }
+      },
+      allowedContractVersions: {
+        serializedName: "allowed_contract_versions",
+        required: true,
+        type: {
+          name: "Sequence",
+          element: {
+            type: {
+              name: "Composite",
+              className: "ContractVersion"
+            }
+          }
+        }
+      },
+      allowedOracleAbiVersions: {
+        serializedName: "allowed_oracle_abi_versions",
+        required: true,
+        type: {
+          name: "Sequence",
+          element: {
+            constraints: {
+              InclusiveMaximum: 65535,
+              InclusiveMinimum: 0
+            },
+            type: {
+              name: "Number"
+            }
+          }
+        }
+      }
+    }
+  }
+};
+const CreateContractUnsignedTx = {
+  type: {
+    name: "Composite",
+    className: "CreateContractUnsignedTx",
+    modelProperties: {
+      ...EncodedTx.type.modelProperties,
+      contractId: {
+        serializedName: "contract_id",
+        required: true,
+        type: {
+          name: "String"
+        }
+      }
+    }
+  }
+};
+const SpendTx = {
+  type: {
+    name: "Composite",
+    className: "SpendTx",
+    modelProperties: {
+      ...SpendTxInput.type.modelProperties
+    }
+  }
+};
+const NodeGetAccountByPubkeyExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetAccountByPubkeyExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetAccountByPubkeyAndHashExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetAccountByPubkeyAndHashExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetAccountByPubkeyAndHeightExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetAccountByPubkeyAndHeightExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetAccountNextNonceExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetAccountNextNonceExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetPendingAccountTransactionsByPubkeyExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetPendingAccountTransactionsByPubkeyExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetAuctionEntryByNameExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetAuctionEntryByNameExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetChannelByPubkeyExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetChannelByPubkeyExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetContractExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetContractExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetContractCodeExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetContractCodeExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetContractPoIExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetContractPoIExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetCurrencyExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetCurrencyExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeProtectedDryRunTxsExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeProtectedDryRunTxsExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetCurrentGenerationExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetCurrentGenerationExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetGenerationByHashExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetGenerationByHashExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetGenerationByHeightExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetGenerationByHeightExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetTopHeaderExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetTopHeaderExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetPinningTxExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetPinningTxExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetHyperchainContractPubkeysExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetHyperchainContractPubkeysExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetCurrentKeyBlockExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetCurrentKeyBlockExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetCurrentKeyBlockHashExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetCurrentKeyBlockHashExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetCurrentKeyBlockHeightExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetCurrentKeyBlockHeightExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetKeyBlockByHashExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetKeyBlockByHashExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
+        type: {
+          name: "Number"
+        }
+      }
+    }
+  }
+};
+const NodeGetKeyBlockByHeightExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetKeyBlockByHeightExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
+        constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "ttl",
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      senderId: {
-        serializedName: "sender_id",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      nonce: {
+      }
+    }
+  }
+};
+const NodeGetPendingKeyBlockExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetPendingKeyBlockExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
-          InclusiveMaximum: 18446744073709552000,
           InclusiveMinimum: 0
         },
-        serializedName: "nonce",
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      payload: {
-        serializedName: "payload",
-        required: true,
-        type: {
-          name: "String"
-        }
       }
     }
   }
 };
-const TokenSupply = {
+const NodeGetMicroBlockHeaderByHashExceptionHeaders = {
   type: {
     name: "Composite",
-    className: "TokenSupply",
+    className: "NodeGetMicroBlockHeaderByHashExceptionHeaders",
     modelProperties: {
-      accounts: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "accounts",
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      contracts: {
+      }
+    }
+  }
+};
+const NodeGetMicroBlockTransactionsByHashExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetMicroBlockTransactionsByHashExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "contracts",
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      contractOracles: {
+      }
+    }
+  }
+};
+const NodeGetMicroBlockTransactionsCountByHashExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetMicroBlockTransactionsCountByHashExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "contract_oracles",
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      locked: {
+      }
+    }
+  }
+};
+const NodeGetMicroBlockTransactionByHashAndIndexExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetMicroBlockTransactionByHashAndIndexExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "locked",
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      oracles: {
+      }
+    }
+  }
+};
+const NodeGetNameEntryByNameExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetNameEntryByNameExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "oracles",
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      oracleQueries: {
+      }
+    }
+  }
+};
+const NodeGetNameEntryByNameHashExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetNameEntryByNameHashExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "oracle_queries",
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      pendingRewards: {
+      }
+    }
+  }
+};
+const NodeGetOracleByPubkeyExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetOracleByPubkeyExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "pending_rewards",
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      total: {
+      }
+    }
+  }
+};
+const NodeGetOracleQueriesByPubkeyExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetOracleQueriesByPubkeyExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "total",
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
@@ -17257,257 +19576,188 @@ const TokenSupply = {
     }
   }
 };
-const OffChainCallContract = {
-  serializedName: "OffChainCallContract",
+const NodeGetOracleQueryByPubkeyAndQueryIdExceptionHeaders = {
   type: {
     name: "Composite",
-    className: "OffChainCallContract",
-    uberParent: "OffChainUpdate",
-    polymorphicDiscriminator: OffChainUpdate.type.polymorphicDiscriminator,
+    className: "NodeGetOracleQueryByPubkeyAndQueryIdExceptionHeaders",
     modelProperties: {
-      ...OffChainUpdate.type.modelProperties,
-      caller: {
-        serializedName: "caller",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      contract: {
-        serializedName: "contract",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      abiVersion: {
+      retryAfter: {
         constraints: {
-          InclusiveMaximum: 65535,
           InclusiveMinimum: 0
         },
-        serializedName: "abi_version",
-        required: true,
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      amount: {
+      }
+    }
+  }
+};
+const NodeGetPeerPubkeyExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetPeerPubkeyExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "amount",
-        required: true,
+        serializedName: "retry-after",
         type: {
-          // @ts-expect-error we are extending autorest with BigInt support
-          name: "BigInt"
+          name: "Number"
         }
-      },
-      gas: {
+      }
+    }
+  }
+};
+const NodeGetRecentGasPricesExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetRecentGasPricesExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
-          InclusiveMaximum: 18446744073709552000,
           InclusiveMinimum: 0
         },
-        serializedName: "gas",
-        required: true,
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      gasPrice: {
+      }
+    }
+  }
+};
+const NodeGetNodeSettingsExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetNodeSettingsExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "gas_price",
-        required: true,
-        type: {
-          // @ts-expect-error we are extending autorest with BigInt support
-          name: "BigInt"
-        }
-      },
-      callData: {
-        serializedName: "call_data",
-        required: true,
+        serializedName: "retry-after",
         type: {
-          name: "String"
+          name: "Number"
         }
       }
     }
   }
 };
-const OffChainDeposit = {
-  serializedName: "OffChainDeposit",
+const NodeGetProtocolParametersExceptionHeaders = {
   type: {
     name: "Composite",
-    className: "OffChainDeposit",
-    uberParent: "OffChainUpdate",
-    polymorphicDiscriminator: OffChainUpdate.type.polymorphicDiscriminator,
+    className: "NodeGetProtocolParametersExceptionHeaders",
     modelProperties: {
-      ...OffChainUpdate.type.modelProperties,
-      from: {
-        serializedName: "from",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      amount: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "amount",
-        required: true,
+        serializedName: "retry-after",
         type: {
-          // @ts-expect-error we are extending autorest with BigInt support
-          name: "BigInt"
+          name: "Number"
         }
       }
     }
   }
 };
-const OffChainNewContract = {
-  serializedName: "OffChainNewContract",
+const NodeGetStatusExceptionHeaders = {
   type: {
     name: "Composite",
-    className: "OffChainNewContract",
-    uberParent: "OffChainUpdate",
-    polymorphicDiscriminator: OffChainUpdate.type.polymorphicDiscriminator,
+    className: "NodeGetStatusExceptionHeaders",
     modelProperties: {
-      ...OffChainUpdate.type.modelProperties,
-      owner: {
-        serializedName: "owner",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      vmVersion: {
+      retryAfter: {
         constraints: {
-          InclusiveMaximum: 65535,
           InclusiveMinimum: 0
         },
-        serializedName: "vm_version",
-        required: true,
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      abiVersion: {
+      }
+    }
+  }
+};
+const NodeGetChainEndsExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetChainEndsExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
-          InclusiveMaximum: 65535,
           InclusiveMinimum: 0
         },
-        serializedName: "abi_version",
-        required: true,
+        serializedName: "retry-after",
         type: {
           name: "Number"
         }
-      },
-      code: {
-        serializedName: "code",
-        type: {
-          name: "Composite",
-          className: "ByteCode"
-        }
-      },
-      deposit: {
+      }
+    }
+  }
+};
+const NodeGetSyncStatusExceptionHeaders = {
+  type: {
+    name: "Composite",
+    className: "NodeGetSyncStatusExceptionHeaders",
+    modelProperties: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "deposit",
-        required: true,
-        type: {
-          // @ts-expect-error we are extending autorest with BigInt support
-          name: "BigInt"
-        }
-      },
-      callData: {
-        serializedName: "call_data",
-        required: true,
+        serializedName: "retry-after",
         type: {
-          name: "String"
+          name: "Number"
         }
       }
     }
   }
 };
-const OffChainTransfer = {
-  serializedName: "OffChainTransfer",
+const NodePostTransactionExceptionHeaders = {
   type: {
     name: "Composite",
-    className: "OffChainTransfer",
-    uberParent: "OffChainUpdate",
-    polymorphicDiscriminator: OffChainUpdate.type.polymorphicDiscriminator,
+    className: "NodePostTransactionExceptionHeaders",
     modelProperties: {
-      ...OffChainUpdate.type.modelProperties,
-      from: {
-        serializedName: "from",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      to: {
-        serializedName: "to",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      amount: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "amount",
-        required: true,
+        serializedName: "retry-after",
         type: {
-          // @ts-expect-error we are extending autorest with BigInt support
-          name: "BigInt"
+          name: "Number"
         }
       }
     }
   }
 };
-const OffChainWithdrawal = {
-  serializedName: "OffChainWithdrawal",
+const NodeGetTransactionByHashExceptionHeaders = {
   type: {
     name: "Composite",
-    className: "OffChainWithdrawal",
-    uberParent: "OffChainUpdate",
-    polymorphicDiscriminator: OffChainUpdate.type.polymorphicDiscriminator,
+    className: "NodeGetTransactionByHashExceptionHeaders",
     modelProperties: {
-      ...OffChainUpdate.type.modelProperties,
-      to: {
-        serializedName: "to",
-        required: true,
-        type: {
-          name: "String"
-        }
-      },
-      amount: {
+      retryAfter: {
         constraints: {
           InclusiveMinimum: 0
         },
-        serializedName: "amount",
-        required: true,
+        serializedName: "retry-after",
         type: {
-          // @ts-expect-error we are extending autorest with BigInt support
-          name: "BigInt"
+          name: "Number"
         }
       }
     }
   }
 };
-const CreateContractUnsignedTx = {
+const NodeGetTransactionInfoByHashExceptionHeaders = {
   type: {
     name: "Composite",
-    className: "CreateContractUnsignedTx",
+    className: "NodeGetTransactionInfoByHashExceptionHeaders",
     modelProperties: {
-      ...UnsignedTx.type.modelProperties,
-      contractId: {
-        serializedName: "contract_id",
-        required: true,
+      retryAfter: {
+        constraints: {
+          InclusiveMinimum: 0
+        },
+        serializedName: "retry-after",
         type: {
-          name: "String"
+          name: "Number"
         }
       }
     }
@@ -17863,9 +20113,11 @@ class node_Node extends core_client_.ServiceClient {
 
   /**
    * Dry-run unsigned transactions on top of a given block. Supports all TXs except GAMetaTx, PayingForTx
-   * and OffchainTx. The maximum gas limit of all calls is capped. The maximum gas limit per request is a
-   * global node setting. Since DryRunCallReq object do not have a mandatory gas field, if not set a
-   * default value of 1000000 is being used instead.
+   * and OffchainTx. Gas defaults to 1000000 when not set on a call request; total gas per request is
+   * capped by a node-configured limit. FATE contract-storage reads are metered at a size-proportional
+   * gas cost, so reported gas is an estimate of the on-chain cost, not an exact figure. Reported gas is
+   * never below what the same call costs on chain at the currently activated protocol, because each
+   * repriced storage register read is floored at that charge.
    * @param body transactions
    * @param options The options parameters.
    */
@@ -17974,7 +20226,7 @@ class node_Node extends core_client_.ServiceClient {
 
   /**
    * Get a key block by hash
-   * @param hash The hash of the block - either a keyblock or a microblock
+   * @param hash The hash of the key block
    * @param options The options parameters.
    */
   getKeyBlockByHash(hash, options) {
@@ -18008,7 +20260,7 @@ class node_Node extends core_client_.ServiceClient {
 
   /**
    * Get a micro block header by hash
-   * @param hash The hash of the block - either a keyblock or a microblock
+   * @param hash The hash of the micro block
    * @param options The options parameters.
    */
   getMicroBlockHeaderByHash(hash, options) {
@@ -18138,6 +20390,36 @@ class node_Node extends core_client_.ServiceClient {
     }, getRecentGasPricesOperationSpec);
   }
 
+  /**
+   * Get this node's local policy settings. These are not consensus rules: they are operator
+   * configuration, they may differ between nodes, and an operator can change them at runtime.
+   * min_miner_gas_price is a decimal string; the other values are JSON numbers, or strings when
+   * int-as-string=true.
+   * @param options The options parameters.
+   */
+  getNodeSettings(options) {
+    return this.sendOperationRequest({
+      options
+    }, getNodeSettingsOperationSpec);
+  }
+
+  /**
+   * Get the consensus protocol parameters needed to build valid transactions. Covers the protocol
+   * effective at the current top block and any later protocol whose fork height has not been reached
+   * yet; a community fork under signalling is reported only once it has activated, since until then it
+   * may still fail to. See /node-settings for this node's local policy. Aettos amounts
+   * (minimum_gas_price, name_claim_fees, name_claim_locked_fee) are always decimal strings, never JSON
+   * numbers: the largest name fee is about 2^69 and would lose precision in an IEEE-754 client. Gas, key
+   * block heights, counts and version numbers are JSON numbers; pass int-as-string=true to receive those
+   * as strings too.
+   * @param options The options parameters.
+   */
+  getProtocolParameters(options) {
+    return this.sendOperationRequest({
+      options
+    }, getProtocolParametersOperationSpec);
+  }
+
   /**
    * Get the status of a node
    * @param options The options parameters.
@@ -18219,6 +20501,11 @@ const getAccountByPubkeyOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetAccountByPubkeyExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, pubkey],
@@ -18239,6 +20526,11 @@ const getAccountByPubkeyAndHashOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetAccountByPubkeyAndHashExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, pubkey, parameters_hash],
@@ -18263,6 +20555,11 @@ const getAccountByPubkeyAndHeightOperationSpec = {
     410: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetAccountByPubkeyAndHeightExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, pubkey, height],
@@ -18283,6 +20580,11 @@ const getAccountNextNonceOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetAccountNextNonceExceptionHeaders,
+      isError: true
     }
   },
   queryParameters: [strategy],
@@ -18304,6 +20606,11 @@ const getPendingAccountTransactionsByPubkeyOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetPendingAccountTransactionsByPubkeyExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, pubkey],
@@ -18324,6 +20631,11 @@ const getAuctionEntryByNameOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetAuctionEntryByNameExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, parameters_name],
@@ -18344,6 +20656,11 @@ const getChannelByPubkeyOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetChannelByPubkeyExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, pubkey],
@@ -18364,6 +20681,11 @@ const getContractOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetContractExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, pubkey],
@@ -18384,6 +20706,11 @@ const getContractCodeOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetContractCodeExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, pubkey],
@@ -18404,6 +20731,11 @@ const getContractPoIOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetContractPoIExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, pubkey],
@@ -18416,6 +20748,11 @@ const getCurrencyOperationSpec = {
   responses: {
     200: {
       bodyMapper: Currency
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetCurrencyExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18436,6 +20773,11 @@ const protectedDryRunTxsOperationSpec = {
     403: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeProtectedDryRunTxsExceptionHeaders,
+      isError: true
     }
   },
   requestBody: body,
@@ -18454,6 +20796,11 @@ const getCurrentGenerationOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetCurrentGenerationExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18474,6 +20821,11 @@ const getGenerationByHashOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetGenerationByHashExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, parameters_hash],
@@ -18490,6 +20842,11 @@ const getGenerationByHeightOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetGenerationByHeightExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, height],
@@ -18506,6 +20863,11 @@ const getTopHeaderOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetTopHeaderExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18522,6 +20884,11 @@ const getPinningTxOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetPinningTxExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18538,6 +20905,11 @@ const getHyperchainContractPubkeysOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetHyperchainContractPubkeysExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18554,6 +20926,11 @@ const getCurrentKeyBlockOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetCurrentKeyBlockExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18570,6 +20947,11 @@ const getCurrentKeyBlockHashOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetCurrentKeyBlockHashExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18586,6 +20968,11 @@ const getCurrentKeyBlockHeightOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetCurrentKeyBlockHeightExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18606,6 +20993,11 @@ const getKeyBlockByHashOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetKeyBlockByHashExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, parameters_hash],
@@ -18622,6 +21014,11 @@ const getKeyBlockByHeightOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetKeyBlockByHeightExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, height],
@@ -18642,6 +21039,11 @@ const getPendingKeyBlockOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetPendingKeyBlockExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18662,6 +21064,11 @@ const getMicroBlockHeaderByHashOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetMicroBlockHeaderByHashExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, parameters_hash],
@@ -18682,6 +21089,11 @@ const getMicroBlockTransactionsByHashOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetMicroBlockTransactionsByHashExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, parameters_hash],
@@ -18702,6 +21114,11 @@ const getMicroBlockTransactionsCountByHashOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetMicroBlockTransactionsCountByHashExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, parameters_hash],
@@ -18722,6 +21139,11 @@ const getMicroBlockTransactionByHashAndIndexOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetMicroBlockTransactionByHashAndIndexExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, parameters_hash, index],
@@ -18742,6 +21164,11 @@ const getNameEntryByNameOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetNameEntryByNameExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, parameters_name],
@@ -18762,6 +21189,11 @@ const getNameEntryByNameHashOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetNameEntryByNameHashExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, nameHash],
@@ -18782,6 +21214,11 @@ const getOracleByPubkeyOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetOracleByPubkeyExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, pubkey],
@@ -18802,6 +21239,11 @@ const getOracleQueriesByPubkeyOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetOracleQueriesByPubkeyExceptionHeaders,
+      isError: true
     }
   },
   queryParameters: [fromParam, limit, typeParam],
@@ -18823,6 +21265,11 @@ const getOracleQueryByPubkeyAndQueryIdOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetOracleQueryByPubkeyAndQueryIdExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, pubkey, queryId],
@@ -18835,6 +21282,11 @@ const getPeerPubkeyOperationSpec = {
   responses: {
     200: {
       bodyMapper: PeerPubKey
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetPeerPubkeyExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18861,6 +21313,45 @@ const getRecentGasPricesOperationSpec = {
     400: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetRecentGasPricesExceptionHeaders,
+      isError: true
+    }
+  },
+  urlParameters: [$host],
+  headerParameters: [accept],
+  serializer
+};
+const getNodeSettingsOperationSpec = {
+  path: "/v3/node-settings",
+  httpMethod: "GET",
+  responses: {
+    200: {
+      bodyMapper: NodeSettings
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetNodeSettingsExceptionHeaders,
+      isError: true
+    }
+  },
+  urlParameters: [$host],
+  headerParameters: [accept],
+  serializer
+};
+const getProtocolParametersOperationSpec = {
+  path: "/v3/protocol-parameters",
+  httpMethod: "GET",
+  responses: {
+    200: {
+      bodyMapper: ProtocolParameters
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetProtocolParametersExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18873,6 +21364,11 @@ const getStatusOperationSpec = {
   responses: {
     200: {
       bodyMapper: Status
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetStatusExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18894,6 +21390,11 @@ const getChainEndsOperationSpec = {
           }
         }
       }
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetChainEndsExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18910,6 +21411,11 @@ const getSyncStatusOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetSyncStatusExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host],
@@ -18926,6 +21432,11 @@ const postTransactionOperationSpec = {
     400: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodePostTransactionExceptionHeaders,
+      isError: true
     }
   },
   requestBody: body1,
@@ -18948,6 +21459,11 @@ const getTransactionByHashOperationSpec = {
     404: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetTransactionByHashExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, parameters_hash],
@@ -18972,6 +21488,11 @@ const getTransactionInfoByHashOperationSpec = {
     410: {
       bodyMapper: ErrorModel,
       isError: true
+    },
+    503: {
+      bodyMapper: ErrorModel,
+      headersMapper: NodeGetTransactionInfoByHashExceptionHeaders,
+      isError: true
     }
   },
   urlParameters: [$host, parameters_hash],
@@ -19113,7 +21634,7 @@ function getTransactionSignerAddress(transaction) {
   const params = unpackTx(transaction);
   switch (params.tag) {
     case Tag.SignedTx:
-      return getTransactionSignerAddress(buildTx(params.encodedTx));
+      return getTransactionSignerAddress(rebuildUnpackedTx(params.encodedTx));
     case Tag.GaMetaTx:
       return params.gaId;
     default:
@@ -19371,7 +21892,7 @@ function getExecutionCost(transaction, {
     res += BigInt(params.gasPrice) * BigInt(gasUsed !== null && gasUsed !== void 0 ? gasUsed : params.gasLimit);
   }
   if (params.tag === Tag.GaMetaTx || params.tag === Tag.PayingForTx) {
-    res += getExecutionCost(buildTx(params.tx.encodedTx), params.tag === Tag.PayingForTx ? {
+    res += getExecutionCost(rebuildUnpackedTx(params.tx.encodedTx), params.tag === Tag.PayingForTx ? {
       innerTx: 'fee-payer'
     } : {});
   }
@@ -19388,13 +21909,13 @@ function getExecutionCost(transaction, {
 function getExecutionCostBySignedTx(transaction, networkId, options) {
   const params = unpackTx(transaction, Tag.SignedTx);
   if (params.encodedTx.tag === Tag.GaMetaTx) {
-    return getExecutionCost(buildTx(params.encodedTx), options);
+    return getExecutionCost(rebuildUnpackedTx(params.encodedTx), options);
   }
-  const tx = buildTx(params.encodedTx);
+  const tx = rebuildUnpackedTx(params.encodedTx);
   const address = getTransactionSignerAddress(tx);
   const [isInnerTx, isNotInnerTx] = [true, false].map(f => verifySignature(getBufferToSign(tx, networkId, f), params.signatures[0], address));
   if (!isInnerTx && !isNotInnerTx) throw new TransactionError("Can't verify signature");
-  return getExecutionCost(buildTx(params.encodedTx), {
+  return getExecutionCost(rebuildUnpackedTx(params.encodedTx), {
     ...(isInnerTx && {
       innerTx: 'freeloader'
     }),
@@ -19457,7 +21978,7 @@ async function getExecutionCostUsingNode(transaction, node, {
 
 const validators = [];
 async function verifyTransactionInternal(tx, node, parentTxTypes) {
-  const address = getTransactionSignerAddress(buildTx(tx));
+  const address = getTransactionSignerAddress(rebuildUnpackedTx(tx));
   const [account, {
     height
   }, {
@@ -19524,7 +22045,7 @@ validators.push((tx, {
   if ((encodedTx !== null && encodedTx !== void 0 ? encodedTx : signatures) == null) return [];
   if (signatures.length !== 1) return []; // TODO: Support multisignature like in state channels
   const prefix = Buffer.from([nodeNetworkId, ...(parentTxTypes.includes(Tag.PayingForTx) ? ['inner_tx'] : [])].join('-'));
-  const txBinary = decode(buildTx(encodedTx));
+  const txBinary = decode(rebuildUnpackedTx(encodedTx));
   const txWithNetworkId = concatBuffers([prefix, txBinary]);
   const txHashWithNetworkId = concatBuffers([prefix, hash(txBinary)]);
   if (verifySignature(txWithNetworkId, signatures[0], account.id) || verifySignature(txHashWithNetworkId, signatures[0], account.id)) return [];
@@ -19558,7 +22079,7 @@ validators.push((tx, {
   node
 }) => {
   if (parentTxTypes.length !== 0) return [];
-  const cost = await getExecutionCostUsingNode(buildTx(tx), node).catch(() => 0n);
+  const cost = await getExecutionCostUsingNode(rebuildUnpackedTx(tx), node).catch(() => 0n);
   if (cost <= account.balance) return [];
   return [{
     message: `Account balance ${account.balance} is not enough to execute the transaction that costs ${cost}`,
@@ -21283,6 +23804,8 @@ async function payForTransaction(transaction, options) {
 
 
 
+
+
 /**
  * Convert current account to GA
  * @category account generalized
@@ -21347,6 +23870,40 @@ async function createGeneralizedAccount(authFnName, args, {
     gaContractId: contractId
   });
 }
+// the symbol isn't exported, so only `buildAuthTxHashByGaMetaTx` can set it — kept off the public
+// `buildAuthTxHash` signature rather than advertising an option its callers can't provide
+async function buildAuthTxHashInternal(transaction, {
+  fee,
+  gasPrice,
+  onNode,
+  protocolParameters,
+  ...options
+}) {
+  const {
+    nodeNetworkId
+  } = await onNode.getNodeInfo();
+  let payload = hash(concatBuffers([Buffer.from(nodeNetworkId), decode(transaction)]));
+  if (fee == null) throw new ArgumentError('fee', 'provided (in Ceres)', fee);
+  if (gasPrice == null) throw new ArgumentError('gasPrice', 'provided (in Ceres)', gasPrice);
+  // the entry checks `gasPrice` against the consensus minimum the same way a transaction does,
+  // so it needs the same parameters — without them a `gasPrice` correct for the network this
+  // node runs is rejected whenever that network runs a lower minimum than the SDK release.
+  // Not requested at all when there is nothing to check, so that re-deriving the hash of an
+  // existing transaction needs no round trip and works on a transaction of another network
+  payload = hash(decode(packEntry({
+    tag: EntryTag.GaMetaTxAuthData,
+    fee,
+    gasPrice,
+    txHash: encode(payload, Encoding.TxHash),
+    ...(options[serializeAsIsParam] === true ? {
+      [serializeAsIsParam]: true
+    } : {
+      protocolParameters: protocolParameters !== null && protocolParameters !== void 0 ? protocolParameters : await getCachedProtocolParameters(onNode)
+    })
+  })));
+  return payload;
+}
+
 /**
  * Build a transaction hash the same as `Auth.tx_hash` by GaMetaTx payload
  * @category account generalized
@@ -21355,29 +23912,22 @@ async function createGeneralizedAccount(authFnName, args, {
  * @param options.fee - GaMetaTx fee, required in Ceres
  * @param options.gasPrice - GaMetaTx gasPrice, required in Ceres
  * @param options.onNode - Node to use
+ * @param options.protocolParameters - Consensus parameters the `gasPrice` belongs to, requested
+ * from node if not provided
  * @returns Transaction hash
  */
 async function buildAuthTxHash(transaction, {
   fee,
   gasPrice,
-  onNode
+  onNode,
+  protocolParameters
 }) {
-  const {
-    nodeNetworkId,
-    consensusProtocolVersion
-  } = await onNode.getNodeInfo();
-  let payload = hash(concatBuffers([Buffer.from(nodeNetworkId), decode(transaction)]));
-  if (consensusProtocolVersion === ConsensusProtocolVersion.Ceres) {
-    if (fee == null) throw new ArgumentError('fee', 'provided (in Ceres)', fee);
-    if (gasPrice == null) throw new ArgumentError('gasPrice', 'provided (in Ceres)', gasPrice);
-    payload = hash(decode(packEntry({
-      tag: EntryTag.GaMetaTxAuthData,
-      fee,
-      gasPrice,
-      txHash: encode(payload, Encoding.TxHash)
-    })));
-  }
-  return payload;
+  return buildAuthTxHashInternal(transaction, {
+    fee,
+    gasPrice,
+    onNode,
+    protocolParameters
+  });
 }
 
 /**
@@ -21395,10 +23945,13 @@ async function buildAuthTxHashByGaMetaTx(transaction, {
   if (txParams.encodedTx.tag !== Tag.GaMetaTx) {
     throw new ArgumentError('transaction', 'to include GaMetaTx', Tag[txParams.encodedTx.tag]);
   }
-  return buildAuthTxHash(buildTx(txParams.encodedTx.tx.encodedTx), {
+  return buildAuthTxHashInternal(rebuildUnpackedTx(txParams.encodedTx.tx.encodedTx), {
     fee: txParams.encodedTx.fee,
     gasPrice: txParams.encodedTx.gasPrice,
-    onNode
+    onNode,
+    // the `gasPrice` of a transaction that already exists, never checked and no parameters
+    // requested for it — see `serializeAsIsParam`
+    [serializeAsIsParam]: true
   });
 }
 // EXTERNAL MODULE: ./node_modules/@babel/runtime-corejs3/helpers/defineProperty.js
@@ -23139,7 +25692,8 @@ class AccountGeneralized extends AccountBase {
   async signTransaction(tx, {
     authData,
     onCompiler,
-    onNode
+    onNode,
+    protocolParameters
   }) {
     if (authData == null || onCompiler == null || onNode == null) {
       throw new ArgumentError('authData, onCompiler, onNode', 'provided', null);
@@ -23187,6 +25741,11 @@ class AccountGeneralized extends AccountBase {
       fee,
       gasLimit,
       gasPrice,
+      // the wrapping transaction is priced by the same parameters the caller asked the inner one
+      // to be built against, `buildTxAsync` requests them from node if not provided
+      ...(protocolParameters != null && {
+        protocolParameters
+      }),
       onNode
     });
     return buildTx({
@@ -25173,7 +27732,7 @@ async function appendSignature(tx, signFn) {
     signatures,
     encodedTx
   } = unpackTx(tx, Tag.SignedTx);
-  const payloadTx = buildTx(encodedTx);
+  const payloadTx = rebuildUnpackedTx(encodedTx);
   const result = await signFn(payloadTx);
   if (typeof result === 'string') {
     const {
@@ -25300,7 +27859,7 @@ async function awaitingReconnection(channel, message, state) {
     const {
       signedTx
     } = await channel.state();
-    changeState(channel, signedTx == null ? '' : buildTx(signedTx));
+    changeState(channel, signedTx == null ? '' : rebuildUnpackedTx(signedTx));
     return {
       handler: channelOpen
     };
@@ -26168,6 +28727,7 @@ class ChannelSpend extends Base_Channel {
 
 
 
+
 function Contract_snakeToPascalObjKeys(obj) {
   return Object.entries(obj).reduce((result, [key, val]) => ({
     ...result,
@@ -26347,6 +28907,11 @@ class ChannelContract extends ChannelSpend {
    * Trigger a force progress contract call
    * This call is going on-chain
    * @param options - Options
+   * @param options.gasPrice - Gas price of the call, defaults to the consensus minimum gas price
+   * of the SDK release (`defaultProtocolParameters.minGasPrice`). A channel talks to node over a
+   * websocket and builds no transaction itself, so it can't request the parameters this node runs
+   * — pass this option explicitly on a network running a higher minimum gas price, otherwise the
+   * call is rejected as underpriced.
    * @param sign - Function which verifies and signs contract force progress transaction
    * @param callbacks - Callbacks
    * @example
@@ -26372,7 +28937,7 @@ class ChannelContract extends ChannelSpend {
     contract,
     abiVersion,
     gasLimit = 1000000,
-    gasPrice = MIN_GAS_PRICE
+    gasPrice = Number(defaultProtocolParameters.minGasPrice)
   }, sign, {
     onOnChainTx
   } = {}) {
@@ -39791,6 +42356,7 @@ class BrowserRuntimeConnection extends BrowserConnection {
  */
 
 
+
 // TODO: move to constants