algosdk 2.8.0 → 2.10.0

package/src/abi/contract.ts

@@ -1,4 +1,5 @@
 import { ABIMethod, ABIMethodParams, getMethodByName } from './method';
+import { ARC28Event } from './event';
 
 export interface ABIContractNetworkInfo {
   appID: number;
@@ -13,6 +14,7 @@ export interface ABIContractParams {
   desc?: string;
   networks?: ABIContractNetworks;
   methods: ABIMethodParams[];
+  events?: ARC28Event[];
 }
 
 export class ABIContract {
@@ -20,6 +22,8 @@ export class ABIContract {
   public readonly description?: string;
   public readonly networks: ABIContractNetworks;
   public readonly methods: ABIMethod[];
+  /** [ARC-28](https://arc.algorand.foundation/ARCs/arc-0028) events that MAY be emitted by this contract */
+  public readonly events?: ARC28Event[];
 
   constructor(params: ABIContractParams) {
     if (
@@ -34,6 +38,7 @@ export class ABIContract {
     this.description = params.desc;
     this.networks = params.networks ? { ...params.networks } : {};
     this.methods = params.methods.map((method) => new ABIMethod(method));
+    this.events = params.events;
   }
 
   toJSON(): ABIContractParams {
@@ -42,6 +47,7 @@ export class ABIContract {
       desc: this.description,
       networks: this.networks,
       methods: this.methods.map((method) => method.toJSON()),
+      events: this.events,
     };
   }
 

package/src/abi/event.ts

@@ -0,0 +1,16 @@
+/** [ARC-28](https://arc.algorand.foundation/ARCs/arc-0028) event description */
+export interface ARC28Event {
+  /** The name of the event */
+  name: string;
+  /** Optional, user-friendly description for the event */
+  desc?: string;
+  /** The arguments of the event, in order */
+  args: Array<{
+    /** The type of the argument */
+    type: string;
+    /** Optional, user-friendly name for the argument */
+    name?: string;
+    /** Optional, user-friendly description for the argument */
+    desc?: string;
+  }>;
+}

package/src/abi/method.ts

@@ -2,6 +2,7 @@ import { genericHash } from '../nacl/naclWrappers';
 import { ABIType, ABITupleType } from './abi_type';
 import { ABITransactionType, abiTypeIsTransaction } from './transaction';
 import { ABIReferenceType, abiTypeIsReference } from './reference';
+import { ARC28Event } from './event';
 
 function parseMethodSignature(
   signature: string
@@ -61,6 +62,10 @@ export interface ABIMethodParams {
   desc?: string;
   args: ABIMethodArgParams[];
   returns: ABIMethodReturnParams;
+  /** Optional, is it a read-only method (according to [ARC-22](https://arc.algorand.foundation/ARCs/arc-0022)) */
+  readonly?: boolean;
+  /** [ARC-28](https://arc.algorand.foundation/ARCs/arc-0028) events that MAY be emitted by this method */
+  events?: ARC28Event[];
 }
 
 export type ABIArgumentType = ABIType | ABITransactionType | ABIReferenceType;
@@ -77,6 +82,8 @@ export class ABIMethod {
   }>;
 
   public readonly returns: { type: ABIReturnType; description?: string };
+  public readonly events?: ARC28Event[];
+  public readonly readonly?: boolean;
 
   constructor(params: ABIMethodParams) {
     if (
@@ -111,6 +118,9 @@ export class ABIMethod {
           : ABIType.from(params.returns.type),
       description: params.returns.desc,
     };
+
+    this.events = params.events;
+    this.readonly = params.readonly;
   }
 
   getSignature(): string {
@@ -147,6 +157,8 @@ export class ABIMethod {
         type: this.returns.type.toString(),
         desc: this.returns.description,
       },
+      events: this.events,
+      readonly: this.readonly,
     };
   }
 

package/src/client/v2/algod/models/types.ts

@@ -2098,6 +2098,38 @@ export class BlockHashResponse extends BaseModel {
   }
 }
 
+/**
+ * Block header.
+ */
+export class BlockHeaderResponse extends BaseModel {
+  /**
+   * Block header data.
+   */
+  public blockheader?: BlockHeader;
+
+  /**
+   * Creates a new `BlockHeaderResponse` object.
+   * @param blockheader - Block header data.
+   */
+  constructor({ blockheader }: { blockheader?: BlockHeader }) {
+    super();
+    this.blockheader = blockheader;
+
+    this.attribute_map = {
+      blockheader: 'blockHeader',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(data: Record<string, any>): BlockHeaderResponse {
+    /* eslint-disable dot-notation */
+    return new BlockHeaderResponse({
+      blockheader: data['blockHeader'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
 /**
  * All logs emitted in the given round. Each app call, whether top-level or inner,
  * that contains logs results in a separate AppCallLogs object. Therefore there may
@@ -4284,6 +4316,12 @@ export class SimulateRequest extends BaseModel {
    */
   public extraOpcodeBudget?: number | bigint;
 
+  /**
+   * If true, signers for transactions that are missing signatures will be fixed
+   * during evaluation.
+   */
+  public fixSigners?: boolean;
+
   /**
    * If provided, specifies the round preceding the simulation. State changes through
    * this round will be used to run this simulation. Usually only the 4 most recent
@@ -4301,6 +4339,8 @@ export class SimulateRequest extends BaseModel {
    * @param allowUnnamedResources - Allows access to unnamed resources during simulation.
    * @param execTraceConfig - An object that configures simulation execution trace.
    * @param extraOpcodeBudget - Applies extra opcode budget during simulation for each transaction group.
+   * @param fixSigners - If true, signers for transactions that are missing signatures will be fixed
+   * during evaluation.
    * @param round - If provided, specifies the round preceding the simulation. State changes through
    * this round will be used to run this simulation. Usually only the 4 most recent
    * rounds will be available (controlled by the node config value MaxAcctLookback).
@@ -4313,6 +4353,7 @@ export class SimulateRequest extends BaseModel {
     allowUnnamedResources,
     execTraceConfig,
     extraOpcodeBudget,
+    fixSigners,
     round,
   }: {
     txnGroups: SimulateRequestTransactionGroup[];
@@ -4321,6 +4362,7 @@ export class SimulateRequest extends BaseModel {
     allowUnnamedResources?: boolean;
     execTraceConfig?: SimulateTraceConfig;
     extraOpcodeBudget?: number | bigint;
+    fixSigners?: boolean;
     round?: number | bigint;
   }) {
     super();
@@ -4330,6 +4372,7 @@ export class SimulateRequest extends BaseModel {
     this.allowUnnamedResources = allowUnnamedResources;
     this.execTraceConfig = execTraceConfig;
     this.extraOpcodeBudget = extraOpcodeBudget;
+    this.fixSigners = fixSigners;
     this.round = round;
 
     this.attribute_map = {
@@ -4339,6 +4382,7 @@ export class SimulateRequest extends BaseModel {
       allowUnnamedResources: 'allow-unnamed-resources',
       execTraceConfig: 'exec-trace-config',
       extraOpcodeBudget: 'extra-opcode-budget',
+      fixSigners: 'fix-signers',
       round: 'round',
     };
   }
@@ -4362,6 +4406,7 @@ export class SimulateRequest extends BaseModel {
           ? SimulateTraceConfig.from_obj_for_encoding(data['exec-trace-config'])
           : undefined,
       extraOpcodeBudget: data['extra-opcode-budget'],
+      fixSigners: data['fix-signers'],
       round: data['round'],
     });
     /* eslint-enable dot-notation */
@@ -4751,6 +4796,12 @@ export class SimulateTransactionResult extends BaseModel {
    */
   public execTrace?: SimulationTransactionExecTrace;
 
+  /**
+   * The account that needed to sign this transaction when no signature was provided
+   * and the provided signer was incorrect.
+   */
+  public fixedSigner?: string;
+
   /**
    * Budget used during execution of a logic sig transaction.
    */
@@ -4777,6 +4828,8 @@ export class SimulateTransactionResult extends BaseModel {
    * budged used by inner app calls spawned by this transaction.
    * @param execTrace - The execution trace of calling an app or a logic sig, containing the inner app
    * call trace in a recursive way.
+   * @param fixedSigner - The account that needed to sign this transaction when no signature was provided
+   * and the provided signer was incorrect.
    * @param logicSigBudgetConsumed - Budget used during execution of a logic sig transaction.
    * @param unnamedResourcesAccessed - These are resources that were accessed by this group that would normally have
    * caused failure, but were allowed in simulation. Depending on where this object
@@ -4792,12 +4845,14 @@ export class SimulateTransactionResult extends BaseModel {
     txnResult,
     appBudgetConsumed,
     execTrace,
+    fixedSigner,
     logicSigBudgetConsumed,
     unnamedResourcesAccessed,
   }: {
     txnResult: PendingTransactionResponse;
     appBudgetConsumed?: number | bigint;
     execTrace?: SimulationTransactionExecTrace;
+    fixedSigner?: string;
     logicSigBudgetConsumed?: number | bigint;
     unnamedResourcesAccessed?: SimulateUnnamedResourcesAccessed;
   }) {
@@ -4805,6 +4860,7 @@ export class SimulateTransactionResult extends BaseModel {
     this.txnResult = txnResult;
     this.appBudgetConsumed = appBudgetConsumed;
     this.execTrace = execTrace;
+    this.fixedSigner = fixedSigner;
     this.logicSigBudgetConsumed = logicSigBudgetConsumed;
     this.unnamedResourcesAccessed = unnamedResourcesAccessed;
 
@@ -4812,6 +4868,7 @@ export class SimulateTransactionResult extends BaseModel {
       txnResult: 'txn-result',
       appBudgetConsumed: 'app-budget-consumed',
       execTrace: 'exec-trace',
+      fixedSigner: 'fixed-signer',
       logicSigBudgetConsumed: 'logic-sig-budget-consumed',
       unnamedResourcesAccessed: 'unnamed-resources-accessed',
     };
@@ -4837,6 +4894,7 @@ export class SimulateTransactionResult extends BaseModel {
               data['exec-trace']
             )
           : undefined,
+      fixedSigner: data['fixed-signer'],
       logicSigBudgetConsumed: data['logic-sig-budget-consumed'],
       unnamedResourcesAccessed:
         typeof data['unnamed-resources-accessed'] !== 'undefined'
@@ -5006,6 +5064,12 @@ export class SimulationEvalOverrides extends BaseModel {
    */
   public extraOpcodeBudget?: number | bigint;
 
+  /**
+   * If true, signers for transactions that are missing signatures will be fixed
+   * during evaluation.
+   */
+  public fixSigners?: boolean;
+
   /**
    * The maximum log calls one can make during simulation
    */
@@ -5022,6 +5086,8 @@ export class SimulationEvalOverrides extends BaseModel {
    * were properly signed.
    * @param allowUnnamedResources - If true, allows access to unnamed resources during simulation.
    * @param extraOpcodeBudget - The extra opcode budget added to each transaction group during simulation
+   * @param fixSigners - If true, signers for transactions that are missing signatures will be fixed
+   * during evaluation.
    * @param maxLogCalls - The maximum log calls one can make during simulation
    * @param maxLogSize - The maximum byte number to log during simulation
    */
@@ -5029,12 +5095,14 @@ export class SimulationEvalOverrides extends BaseModel {
     allowEmptySignatures,
     allowUnnamedResources,
     extraOpcodeBudget,
+    fixSigners,
     maxLogCalls,
     maxLogSize,
   }: {
     allowEmptySignatures?: boolean;
     allowUnnamedResources?: boolean;
     extraOpcodeBudget?: number | bigint;
+    fixSigners?: boolean;
     maxLogCalls?: number | bigint;
     maxLogSize?: number | bigint;
   }) {
@@ -5042,6 +5110,7 @@ export class SimulationEvalOverrides extends BaseModel {
     this.allowEmptySignatures = allowEmptySignatures;
     this.allowUnnamedResources = allowUnnamedResources;
     this.extraOpcodeBudget = extraOpcodeBudget;
+    this.fixSigners = fixSigners;
     this.maxLogCalls = maxLogCalls;
     this.maxLogSize = maxLogSize;
 
@@ -5049,6 +5118,7 @@ export class SimulationEvalOverrides extends BaseModel {
       allowEmptySignatures: 'allow-empty-signatures',
       allowUnnamedResources: 'allow-unnamed-resources',
       extraOpcodeBudget: 'extra-opcode-budget',
+      fixSigners: 'fix-signers',
       maxLogCalls: 'max-log-calls',
       maxLogSize: 'max-log-size',
     };
@@ -5063,6 +5133,7 @@ export class SimulationEvalOverrides extends BaseModel {
       allowEmptySignatures: data['allow-empty-signatures'],
       allowUnnamedResources: data['allow-unnamed-resources'],
       extraOpcodeBudget: data['extra-opcode-budget'],
+      fixSigners: data['fix-signers'],
       maxLogCalls: data['max-log-calls'],
       maxLogSize: data['max-log-size'],
     });

package/src/client/v2/indexer/models/types.ts

@@ -2467,6 +2467,68 @@ export class Block extends BaseModel {
   }
 }
 
+/**
+ *
+ */
+export class BlockHeadersResponse extends BaseModel {
+  public blocks?: Block[];
+
+  /**
+   * Round at which the results were computed.
+   */
+  public currentRound?: number | bigint;
+
+  /**
+   * Used for pagination, when making another request provide this token with the
+   * next parameter.
+   */
+  public nextToken?: string;
+
+  /**
+   * Creates a new `BlockHeadersResponse` object.
+   * @param blocks -
+   * @param currentRound - Round at which the results were computed.
+   * @param nextToken - Used for pagination, when making another request provide this token with the
+   * next parameter.
+   */
+  constructor({
+    blocks,
+    currentRound,
+    nextToken,
+  }: {
+    blocks?: Block[];
+    currentRound?: number | bigint;
+    nextToken?: string;
+  }) {
+    super();
+    this.blocks = blocks;
+    this.currentRound = currentRound;
+    this.nextToken = nextToken;
+
+    this.attribute_map = {
+      blocks: 'blocks',
+      currentRound: 'current-round',
+      nextToken: 'next-token',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(
+    data: Record<string, any>
+  ): BlockHeadersResponse {
+    /* eslint-disable dot-notation */
+    return new BlockHeadersResponse({
+      blocks:
+        typeof data['blocks'] !== 'undefined'
+          ? data['blocks'].map(Block.from_obj_for_encoding)
+          : undefined,
+      currentRound: data['current-round'],
+      nextToken: data['next-token'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
 /**
  * Fields relating to rewards,
  */
@@ -3080,6 +3142,106 @@ export class HashFactory extends BaseModel {
   }
 }
 
+/**
+ * (hbprf) HbProof is a signature using HeartbeatAddress's partkey, thereby showing
+ * it is online.
+ */
+export class HbProofFields extends BaseModel {
+  /**
+   * (p) Public key of the heartbeat message.
+   */
+  public hbPk?: Uint8Array;
+
+  /**
+   * (p1s) Signature of OneTimeSignatureSubkeyOffsetID(PK, Batch, Offset) under the
+   * key PK2.
+   */
+  public hbPk1sig?: Uint8Array;
+
+  /**
+   * (p2) Key for new-style two-level ephemeral signature.
+   */
+  public hbPk2?: Uint8Array;
+
+  /**
+   * (p2s) Signature of OneTimeSignatureSubkeyBatchID(PK2, Batch) under the master
+   * key (OneTimeSignatureVerifier).
+   */
+  public hbPk2sig?: Uint8Array;
+
+  /**
+   * (s) Signature of the heartbeat message.
+   */
+  public hbSig?: Uint8Array;
+
+  /**
+   * Creates a new `HbProofFields` object.
+   * @param hbPk - (p) Public key of the heartbeat message.
+   * @param hbPk1sig - (p1s) Signature of OneTimeSignatureSubkeyOffsetID(PK, Batch, Offset) under the
+   * key PK2.
+   * @param hbPk2 - (p2) Key for new-style two-level ephemeral signature.
+   * @param hbPk2sig - (p2s) Signature of OneTimeSignatureSubkeyBatchID(PK2, Batch) under the master
+   * key (OneTimeSignatureVerifier).
+   * @param hbSig - (s) Signature of the heartbeat message.
+   */
+  constructor({
+    hbPk,
+    hbPk1sig,
+    hbPk2,
+    hbPk2sig,
+    hbSig,
+  }: {
+    hbPk?: string | Uint8Array;
+    hbPk1sig?: string | Uint8Array;
+    hbPk2?: string | Uint8Array;
+    hbPk2sig?: string | Uint8Array;
+    hbSig?: string | Uint8Array;
+  }) {
+    super();
+    this.hbPk =
+      typeof hbPk === 'string'
+        ? new Uint8Array(Buffer.from(hbPk, 'base64'))
+        : hbPk;
+    this.hbPk1sig =
+      typeof hbPk1sig === 'string'
+        ? new Uint8Array(Buffer.from(hbPk1sig, 'base64'))
+        : hbPk1sig;
+    this.hbPk2 =
+      typeof hbPk2 === 'string'
+        ? new Uint8Array(Buffer.from(hbPk2, 'base64'))
+        : hbPk2;
+    this.hbPk2sig =
+      typeof hbPk2sig === 'string'
+        ? new Uint8Array(Buffer.from(hbPk2sig, 'base64'))
+        : hbPk2sig;
+    this.hbSig =
+      typeof hbSig === 'string'
+        ? new Uint8Array(Buffer.from(hbSig, 'base64'))
+        : hbSig;
+
+    this.attribute_map = {
+      hbPk: 'hb-pk',
+      hbPk1sig: 'hb-pk1sig',
+      hbPk2: 'hb-pk2',
+      hbPk2sig: 'hb-pk2sig',
+      hbSig: 'hb-sig',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(data: Record<string, any>): HbProofFields {
+    /* eslint-disable dot-notation */
+    return new HbProofFields({
+      hbPk: data['hb-pk'],
+      hbPk1sig: data['hb-pk1sig'],
+      hbPk2: data['hb-pk2'],
+      hbPk2sig: data['hb-pk2sig'],
+      hbSig: data['hb-sig'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
 /**
  * A health check response.
  */
@@ -4195,6 +4357,13 @@ export class Transaction extends BaseModel {
    */
   public group?: Uint8Array;
 
+  /**
+   * Fields for a heartbeat transaction.
+   * Definition:
+   * data/transactions/heartbeat.go : HeartbeatTxnFields
+   */
+  public heartbeatTransaction?: TransactionHeartbeat;
+
   /**
    * Transaction ID
    */
@@ -4295,6 +4464,7 @@ export class Transaction extends BaseModel {
    * * (afrz) asset-freeze-transaction
    * * (appl) application-transaction
    * * (stpf) state-proof-transaction
+   * * (hb) heartbeat-transaction
    */
   public txType?: string;
 
@@ -4334,6 +4504,9 @@ export class Transaction extends BaseModel {
    * @param group - (grp) Base64 encoded byte array of a sha512/256 digest. When present indicates
    * that this transaction is part of a transaction group and the value is the
    * sha512/256 hash of the transactions in that group.
+   * @param heartbeatTransaction - Fields for a heartbeat transaction.
+   * Definition:
+   * data/transactions/heartbeat.go : HeartbeatTxnFields
    * @param id - Transaction ID
    * @param innerTxns - Inner transactions produced by application execution.
    * @param intraRoundOffset - Offset into the round where this transaction was confirmed.
@@ -4373,6 +4546,7 @@ export class Transaction extends BaseModel {
    * * (afrz) asset-freeze-transaction
    * * (appl) application-transaction
    * * (stpf) state-proof-transaction
+   * * (hb) heartbeat-transaction
    */
   constructor({
     fee,
@@ -4393,6 +4567,7 @@ export class Transaction extends BaseModel {
     genesisId,
     globalStateDelta,
     group,
+    heartbeatTransaction,
     id,
     innerTxns,
     intraRoundOffset,
@@ -4428,6 +4603,7 @@ export class Transaction extends BaseModel {
     genesisId?: string;
     globalStateDelta?: EvalDeltaKeyValue[];
     group?: string | Uint8Array;
+    heartbeatTransaction?: TransactionHeartbeat;
     id?: string;
     innerTxns?: Transaction[];
     intraRoundOffset?: number | bigint;
@@ -4470,6 +4646,7 @@ export class Transaction extends BaseModel {
       typeof group === 'string'
         ? new Uint8Array(Buffer.from(group, 'base64'))
         : group;
+    this.heartbeatTransaction = heartbeatTransaction;
     this.id = id;
     this.innerTxns = innerTxns;
     this.intraRoundOffset = intraRoundOffset;
@@ -4512,6 +4689,7 @@ export class Transaction extends BaseModel {
       genesisId: 'genesis-id',
       globalStateDelta: 'global-state-delta',
       group: 'group',
+      heartbeatTransaction: 'heartbeat-transaction',
       id: 'id',
       innerTxns: 'inner-txns',
       intraRoundOffset: 'intra-round-offset',
@@ -4590,6 +4768,12 @@ export class Transaction extends BaseModel {
             )
           : undefined,
       group: data['group'],
+      heartbeatTransaction:
+        typeof data['heartbeat-transaction'] !== 'undefined'
+          ? TransactionHeartbeat.from_obj_for_encoding(
+              data['heartbeat-transaction']
+            )
+          : undefined,
       id: data['id'],
       innerTxns:
         typeof data['inner-txns'] !== 'undefined'
@@ -5094,6 +5278,116 @@ export class TransactionAssetTransfer extends BaseModel {
   }
 }
 
+/**
+ * Fields for a heartbeat transaction.
+ * Definition:
+ * data/transactions/heartbeat.go : HeartbeatTxnFields
+ */
+export class TransactionHeartbeat extends BaseModel {
+  /**
+   * (hbad) HbAddress is the account this txn is proving onlineness for.
+   */
+  public hbAddress: string;
+
+  /**
+   * (hbkd) HbKeyDilution must match HbAddress account's current KeyDilution.
+   */
+  public hbKeyDilution: number | bigint;
+
+  /**
+   * (hbprf) HbProof is a signature using HeartbeatAddress's partkey, thereby showing
+   * it is online.
+   */
+  public hbProof: HbProofFields;
+
+  /**
+   * (hbsd) HbSeed must be the block seed for the this transaction's firstValid
+   * block.
+   */
+  public hbSeed: Uint8Array;
+
+  /**
+   * (hbvid) HbVoteID must match the HbAddress account's current VoteID.
+   */
+  public hbVoteId: Uint8Array;
+
+  /**
+   * Creates a new `TransactionHeartbeat` object.
+   * @param hbAddress - (hbad) HbAddress is the account this txn is proving onlineness for.
+   * @param hbKeyDilution - (hbkd) HbKeyDilution must match HbAddress account's current KeyDilution.
+   * @param hbProof - (hbprf) HbProof is a signature using HeartbeatAddress's partkey, thereby showing
+   * it is online.
+   * @param hbSeed - (hbsd) HbSeed must be the block seed for the this transaction's firstValid
+   * block.
+   * @param hbVoteId - (hbvid) HbVoteID must match the HbAddress account's current VoteID.
+   */
+  constructor({
+    hbAddress,
+    hbKeyDilution,
+    hbProof,
+    hbSeed,
+    hbVoteId,
+  }: {
+    hbAddress: string;
+    hbKeyDilution: number | bigint;
+    hbProof: HbProofFields;
+    hbSeed: string | Uint8Array;
+    hbVoteId: string | Uint8Array;
+  }) {
+    super();
+    this.hbAddress = hbAddress;
+    this.hbKeyDilution = hbKeyDilution;
+    this.hbProof = hbProof;
+    this.hbSeed =
+      typeof hbSeed === 'string'
+        ? new Uint8Array(Buffer.from(hbSeed, 'base64'))
+        : hbSeed;
+    this.hbVoteId =
+      typeof hbVoteId === 'string'
+        ? new Uint8Array(Buffer.from(hbVoteId, 'base64'))
+        : hbVoteId;
+
+    this.attribute_map = {
+      hbAddress: 'hb-address',
+      hbKeyDilution: 'hb-key-dilution',
+      hbProof: 'hb-proof',
+      hbSeed: 'hb-seed',
+      hbVoteId: 'hb-vote-id',
+    };
+  }
+
+  // eslint-disable-next-line camelcase
+  static from_obj_for_encoding(
+    data: Record<string, any>
+  ): TransactionHeartbeat {
+    /* eslint-disable dot-notation */
+    if (typeof data['hb-address'] === 'undefined')
+      throw new Error(
+        `Response is missing required field 'hb-address': ${data}`
+      );
+    if (typeof data['hb-key-dilution'] === 'undefined')
+      throw new Error(
+        `Response is missing required field 'hb-key-dilution': ${data}`
+      );
+    if (typeof data['hb-proof'] === 'undefined')
+      throw new Error(`Response is missing required field 'hb-proof': ${data}`);
+    if (typeof data['hb-seed'] === 'undefined')
+      throw new Error(`Response is missing required field 'hb-seed': ${data}`);
+    if (typeof data['hb-vote-id'] === 'undefined')
+      throw new Error(
+        `Response is missing required field 'hb-vote-id': ${data}`
+      );
+    return new TransactionHeartbeat({
+      hbAddress: data['hb-address'],
+      hbKeyDilution: data['hb-key-dilution'],
+      hbProof: HbProofFields.from_obj_for_encoding(data['hb-proof']),
+      hbSeed: data['hb-seed'],
+      hbVoteId: data['hb-vote-id'],
+    });
+    /* eslint-enable dot-notation */
+  }
+}
+
 /**
  * Fields for a keyreg transaction.
  * Definition: