algosdk 3.5.2 → 3.7.0-beta.1

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

@@ -621,6 +621,152 @@ export class Account implements Encodable {
   }
 }
 
+/**
+ * AccountApplicationResource describes the account's application resource (local
+ * state and params if the account is the creator) for a specific application ID.
+ */
+export class AccountApplicationResource implements Encodable {
+  private static encodingSchemaValue: Schema | undefined;
+
+  static get encodingSchema(): Schema {
+    if (!this.encodingSchemaValue) {
+      this.encodingSchemaValue = new NamedMapSchema([]);
+      (this.encodingSchemaValue as NamedMapSchema).pushEntries(
+        { key: 'id', valueSchema: new Uint64Schema(), omitEmpty: true },
+        {
+          key: 'app-local-state',
+          valueSchema: new OptionalSchema(ApplicationLocalState.encodingSchema),
+          omitEmpty: true,
+        },
+        {
+          key: 'created-at-round',
+          valueSchema: new OptionalSchema(new Uint64Schema()),
+          omitEmpty: true,
+        },
+        {
+          key: 'deleted',
+          valueSchema: new OptionalSchema(new BooleanSchema()),
+          omitEmpty: true,
+        },
+        {
+          key: 'params',
+          valueSchema: new OptionalSchema(ApplicationParams.encodingSchema),
+          omitEmpty: true,
+        }
+      );
+    }
+    return this.encodingSchemaValue;
+  }
+
+  /**
+   * The application ID.
+   */
+  public id: number;
+
+  /**
+   * (appl) the application local data stored in this account.
+   * The raw account uses `AppLocalState` for this type.
+   */
+  public appLocalState?: ApplicationLocalState;
+
+  /**
+   * Round when the account opted into or created the application.
+   */
+  public createdAtRound?: number;
+
+  /**
+   * Whether the application has been deleted.
+   */
+  public deleted?: boolean;
+
+  /**
+   * (appp) parameters of the application created by this account including app
+   * global data.
+   * The raw account uses `AppParams` for this type.
+   * Only present if the account is the creator and `include=params` is specified.
+   */
+  public params?: ApplicationParams;
+
+  /**
+   * Creates a new `AccountApplicationResource` object.
+   * @param id - The application ID.
+   * @param appLocalState - (appl) the application local data stored in this account.
+   * The raw account uses `AppLocalState` for this type.
+   * @param createdAtRound - Round when the account opted into or created the application.
+   * @param deleted - Whether the application has been deleted.
+   * @param params - (appp) parameters of the application created by this account including app
+   * global data.
+   * The raw account uses `AppParams` for this type.
+   * Only present if the account is the creator and `include=params` is specified.
+   */
+  constructor({
+    id,
+    appLocalState,
+    createdAtRound,
+    deleted,
+    params,
+  }: {
+    id: number | bigint;
+    appLocalState?: ApplicationLocalState;
+    createdAtRound?: number | bigint;
+    deleted?: boolean;
+    params?: ApplicationParams;
+  }) {
+    this.id = ensureSafeInteger(id);
+    this.appLocalState = appLocalState;
+    this.createdAtRound =
+      typeof createdAtRound === 'undefined'
+        ? undefined
+        : ensureSafeInteger(createdAtRound);
+    this.deleted = deleted;
+    this.params = params;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  getEncodingSchema(): Schema {
+    return AccountApplicationResource.encodingSchema;
+  }
+
+  toEncodingData(): Map<string, unknown> {
+    return new Map<string, unknown>([
+      ['id', this.id],
+      [
+        'app-local-state',
+        typeof this.appLocalState !== 'undefined'
+          ? this.appLocalState.toEncodingData()
+          : undefined,
+      ],
+      ['created-at-round', this.createdAtRound],
+      ['deleted', this.deleted],
+      [
+        'params',
+        typeof this.params !== 'undefined'
+          ? this.params.toEncodingData()
+          : undefined,
+      ],
+    ]);
+  }
+
+  static fromEncodingData(data: unknown): AccountApplicationResource {
+    if (!(data instanceof Map)) {
+      throw new Error(`Invalid decoded AccountApplicationResource: ${data}`);
+    }
+    return new AccountApplicationResource({
+      id: data.get('id'),
+      appLocalState:
+        typeof data.get('app-local-state') !== 'undefined'
+          ? ApplicationLocalState.fromEncodingData(data.get('app-local-state'))
+          : undefined,
+      createdAtRound: data.get('created-at-round'),
+      deleted: data.get('deleted'),
+      params:
+        typeof data.get('params') !== 'undefined'
+          ? ApplicationParams.fromEncodingData(data.get('params'))
+          : undefined,
+    });
+  }
+}
+
 /**
  * AccountApplicationResponse describes the account's application local state and
  * global state (AppLocalState and AppParams, if either exists) for a specific
@@ -732,6 +878,112 @@ export class AccountApplicationResponse implements Encodable {
   }
 }
 
+/**
+ * AccountApplicationsInformationResponse contains a list of application resources
+ * for an account.
+ */
+export class AccountApplicationsInformationResponse implements Encodable {
+  private static encodingSchemaValue: Schema | undefined;
+
+  static get encodingSchema(): Schema {
+    if (!this.encodingSchemaValue) {
+      this.encodingSchemaValue = new NamedMapSchema([]);
+      (this.encodingSchemaValue as NamedMapSchema).pushEntries(
+        { key: 'round', valueSchema: new Uint64Schema(), omitEmpty: true },
+        {
+          key: 'application-resources',
+          valueSchema: new OptionalSchema(
+            new ArraySchema(AccountApplicationResource.encodingSchema)
+          ),
+          omitEmpty: true,
+        },
+        {
+          key: 'next-token',
+          valueSchema: new OptionalSchema(new StringSchema()),
+          omitEmpty: true,
+        }
+      );
+    }
+    return this.encodingSchemaValue;
+  }
+
+  /**
+   * The round for which this information is relevant.
+   */
+  public round: number;
+
+  public applicationResources?: AccountApplicationResource[];
+
+  /**
+   * Used for pagination, when making another request provide this token with the
+   * next parameter. The next token is the next application ID to use as the
+   * pagination cursor.
+   */
+  public nextToken?: string;
+
+  /**
+   * Creates a new `AccountApplicationsInformationResponse` object.
+   * @param round - The round for which this information is relevant.
+   * @param applicationResources -
+   * @param nextToken - Used for pagination, when making another request provide this token with the
+   * next parameter. The next token is the next application ID to use as the
+   * pagination cursor.
+   */
+  constructor({
+    round,
+    applicationResources,
+    nextToken,
+  }: {
+    round: number | bigint;
+    applicationResources?: AccountApplicationResource[];
+    nextToken?: string;
+  }) {
+    this.round = ensureSafeInteger(round);
+    this.applicationResources = applicationResources;
+    this.nextToken = nextToken;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  getEncodingSchema(): Schema {
+    return AccountApplicationsInformationResponse.encodingSchema;
+  }
+
+  toEncodingData(): Map<string, unknown> {
+    return new Map<string, unknown>([
+      ['round', this.round],
+      [
+        'application-resources',
+        typeof this.applicationResources !== 'undefined'
+          ? this.applicationResources.map((v) => v.toEncodingData())
+          : undefined,
+      ],
+      ['next-token', this.nextToken],
+    ]);
+  }
+
+  static fromEncodingData(
+    data: unknown
+  ): AccountApplicationsInformationResponse {
+    if (!(data instanceof Map)) {
+      throw new Error(
+        `Invalid decoded AccountApplicationsInformationResponse: ${data}`
+      );
+    }
+    return new AccountApplicationsInformationResponse({
+      round: data.get('round'),
+      applicationResources:
+        typeof data.get('application-resources') !== 'undefined'
+          ? data
+              .get('application-resources')
+              .map((v: unknown) =>
+                AccountApplicationResource.fromEncodingData(v)
+              )
+          : undefined,
+      nextToken: data.get('next-token'),
+    });
+  }
+}
+
 /**
  * AccountAssetHolding describes the account's asset holding and asset parameters
  * (if either exist) for a specific asset ID.
@@ -1347,7 +1599,7 @@ export class Application implements Encodable {
         { key: 'id', valueSchema: new Uint64Schema(), omitEmpty: true },
         {
           key: 'params',
-          valueSchema: ApplicationParams.encodingSchema,
+          valueSchema: new OptionalSchema(ApplicationParams.encodingSchema),
           omitEmpty: true,
         }
       );
@@ -1363,7 +1615,7 @@ export class Application implements Encodable {
   /**
    * (appparams) application parameters.
    */
-  public params: ApplicationParams;
+  public params?: ApplicationParams;
 
   /**
    * Creates a new `Application` object.
@@ -1375,7 +1627,7 @@ export class Application implements Encodable {
     params,
   }: {
     id: number | bigint;
-    params: ApplicationParams;
+    params?: ApplicationParams;
   }) {
     this.id = ensureBigInt(id);
     this.params = params;
@@ -1389,7 +1641,12 @@ export class Application implements Encodable {
   toEncodingData(): Map<string, unknown> {
     return new Map<string, unknown>([
       ['id', this.id],
-      ['params', this.params.toEncodingData()],
+      [
+        'params',
+        typeof this.params !== 'undefined'
+          ? this.params.toEncodingData()
+          : undefined,
+      ],
     ]);
   }
 
@@ -1399,9 +1656,10 @@ export class Application implements Encodable {
     }
     return new Application({
       id: data.get('id'),
-      params: ApplicationParams.fromEncodingData(
-        data.get('params') ?? new Map()
-      ),
+      params:
+        typeof data.get('params') !== 'undefined'
+          ? ApplicationParams.fromEncodingData(data.get('params'))
+          : undefined,
     });
   }
 }
@@ -1833,6 +2091,11 @@ export class ApplicationParams implements Encodable {
           ),
           omitEmpty: true,
         },
+        {
+          key: 'size-sponsor',
+          valueSchema: new OptionalSchema(new StringSchema()),
+          omitEmpty: true,
+        },
         {
           key: 'version',
           valueSchema: new OptionalSchema(new Uint64Schema()),
@@ -1879,6 +2142,11 @@ export class ApplicationParams implements Encodable {
    */
   public localStateSchema?: ApplicationStateSchema;
 
+  /**
+   * (ss) the account responsible for extra pages and global state MBR
+   */
+  public sizeSponsor?: Address;
+
   /**
    * (v) the number of updates to the application programs
    */
@@ -1894,6 +2162,7 @@ export class ApplicationParams implements Encodable {
    * @param globalState - (gs) global state
    * @param globalStateSchema - (gsch) global schema
    * @param localStateSchema - (lsch) local schema
+   * @param sizeSponsor - (ss) the account responsible for extra pages and global state MBR
    * @param version - (v) the number of updates to the application programs
    */
   constructor({
@@ -1904,6 +2173,7 @@ export class ApplicationParams implements Encodable {
     globalState,
     globalStateSchema,
     localStateSchema,
+    sizeSponsor,
     version,
   }: {
     approvalProgram: string | Uint8Array;
@@ -1913,6 +2183,7 @@ export class ApplicationParams implements Encodable {
     globalState?: TealKeyValue[];
     globalStateSchema?: ApplicationStateSchema;
     localStateSchema?: ApplicationStateSchema;
+    sizeSponsor?: Address | string;
     version?: number | bigint;
   }) {
     this.approvalProgram =
@@ -1932,6 +2203,10 @@ export class ApplicationParams implements Encodable {
     this.globalState = globalState;
     this.globalStateSchema = globalStateSchema;
     this.localStateSchema = localStateSchema;
+    this.sizeSponsor =
+      typeof sizeSponsor === 'string'
+        ? Address.fromString(sizeSponsor)
+        : sizeSponsor;
     this.version =
       typeof version === 'undefined' ? undefined : ensureSafeInteger(version);
   }
@@ -1965,6 +2240,12 @@ export class ApplicationParams implements Encodable {
           ? this.localStateSchema.toEncodingData()
           : undefined,
       ],
+      [
+        'size-sponsor',
+        typeof this.sizeSponsor !== 'undefined'
+          ? this.sizeSponsor.toString()
+          : undefined,
+      ],
       ['version', this.version],
     ]);
   }
@@ -1996,6 +2277,7 @@ export class ApplicationParams implements Encodable {
               data.get('local-state-schema')
             )
           : undefined,
+      sizeSponsor: data.get('size-sponsor'),
       version: data.get('version'),
     });
   }
@@ -2216,7 +2498,7 @@ export class Asset implements Encodable {
         { key: 'index', valueSchema: new Uint64Schema(), omitEmpty: true },
         {
           key: 'params',
-          valueSchema: AssetParams.encodingSchema,
+          valueSchema: new OptionalSchema(AssetParams.encodingSchema),
           omitEmpty: true,
         }
       );
@@ -2235,7 +2517,7 @@ export class Asset implements Encodable {
    * Definition:
    * data/transactions/asset.go : AssetParams
    */
-  public params: AssetParams;
+  public params?: AssetParams;
 
   /**
    * Creates a new `Asset` object.
@@ -2250,7 +2532,7 @@ export class Asset implements Encodable {
     params,
   }: {
     index: number | bigint;
-    params: AssetParams;
+    params?: AssetParams;
   }) {
     this.index = ensureBigInt(index);
     this.params = params;
@@ -2264,7 +2546,12 @@ export class Asset implements Encodable {
   toEncodingData(): Map<string, unknown> {
     return new Map<string, unknown>([
       ['index', this.index],
-      ['params', this.params.toEncodingData()],
+      [
+        'params',
+        typeof this.params !== 'undefined'
+          ? this.params.toEncodingData()
+          : undefined,
+      ],
     ]);
   }
 
@@ -2274,7 +2561,10 @@ export class Asset implements Encodable {
     }
     return new Asset({
       index: data.get('index'),
-      params: AssetParams.fromEncodingData(data.get('params') ?? new Map()),
+      params:
+        typeof data.get('params') !== 'undefined'
+          ? AssetParams.fromEncodingData(data.get('params'))
+          : undefined,
     });
   }
 }
@@ -3189,11 +3479,14 @@ export class BoxDescriptor implements Encodable {
   static get encodingSchema(): Schema {
     if (!this.encodingSchemaValue) {
       this.encodingSchemaValue = new NamedMapSchema([]);
-      (this.encodingSchemaValue as NamedMapSchema).pushEntries({
-        key: 'name',
-        valueSchema: new ByteArraySchema(),
-        omitEmpty: true,
-      });
+      (this.encodingSchemaValue as NamedMapSchema).pushEntries(
+        { key: 'name', valueSchema: new ByteArraySchema(), omitEmpty: true },
+        {
+          key: 'value',
+          valueSchema: new OptionalSchema(new ByteArraySchema()),
+          omitEmpty: true,
+        }
+      );
     }
     return this.encodingSchemaValue;
   }
@@ -3203,12 +3496,27 @@ export class BoxDescriptor implements Encodable {
    */
   public name: Uint8Array;
 
+  /**
+   * Base64 encoded box value. Present only when the `values` query parameter is set
+   * to true.
+   */
+  public value?: Uint8Array;
+
   /**
    * Creates a new `BoxDescriptor` object.
    * @param name - Base64 encoded box name
+   * @param value - Base64 encoded box value. Present only when the `values` query parameter is set
+   * to true.
    */
-  constructor({ name }: { name: string | Uint8Array }) {
+  constructor({
+    name,
+    value,
+  }: {
+    name: string | Uint8Array;
+    value?: string | Uint8Array;
+  }) {
     this.name = typeof name === 'string' ? base64ToBytes(name) : name;
+    this.value = typeof value === 'string' ? base64ToBytes(value) : value;
   }
 
   // eslint-disable-next-line class-methods-use-this
@@ -3217,7 +3525,10 @@ export class BoxDescriptor implements Encodable {
   }
 
   toEncodingData(): Map<string, unknown> {
-    return new Map<string, unknown>([['name', this.name]]);
+    return new Map<string, unknown>([
+      ['name', this.name],
+      ['value', this.value],
+    ]);
   }
 
   static fromEncodingData(data: unknown): BoxDescriptor {
@@ -3226,6 +3537,7 @@ export class BoxDescriptor implements Encodable {
     }
     return new BoxDescriptor({
       name: data.get('name'),
+      value: data.get('value'),
     });
   }
 }
@@ -3297,7 +3609,7 @@ export class BoxReference implements Encodable {
 }
 
 /**
- * Box names of an application
+ * Boxes of an application
  */
 export class BoxesResponse implements Encodable {
   private static encodingSchemaValue: Schema | undefined;
@@ -3305,11 +3617,23 @@ export class BoxesResponse implements Encodable {
   static get encodingSchema(): Schema {
     if (!this.encodingSchemaValue) {
       this.encodingSchemaValue = new NamedMapSchema([]);
-      (this.encodingSchemaValue as NamedMapSchema).pushEntries({
-        key: 'boxes',
-        valueSchema: new ArraySchema(BoxDescriptor.encodingSchema),
-        omitEmpty: true,
-      });
+      (this.encodingSchemaValue as NamedMapSchema).pushEntries(
+        {
+          key: 'boxes',
+          valueSchema: new ArraySchema(BoxDescriptor.encodingSchema),
+          omitEmpty: true,
+        },
+        {
+          key: 'next-token',
+          valueSchema: new OptionalSchema(new StringSchema()),
+          omitEmpty: true,
+        },
+        {
+          key: 'round',
+          valueSchema: new OptionalSchema(new Uint64Schema()),
+          omitEmpty: true,
+        }
+      );
     }
     return this.encodingSchemaValue;
   }
@@ -3317,21 +3641,50 @@ export class BoxesResponse implements Encodable {
   public boxes: BoxDescriptor[];
 
   /**
-   * Creates a new `BoxesResponse` object.
-   * @param boxes -
+   * Used for pagination, when making another request provide this token with the
+   * next parameter. The next token is the box name to use as the pagination cursor,
+   * encoded in the goal app call arg form.
    */
-  constructor({ boxes }: { boxes: BoxDescriptor[] }) {
-    this.boxes = boxes;
-  }
+  public nextToken?: string;
 
-  // eslint-disable-next-line class-methods-use-this
-  getEncodingSchema(): Schema {
+  /**
+   * The round for which this information is relevant.
+   */
+  public round?: number;
+
+  /**
+   * Creates a new `BoxesResponse` object.
+   * @param boxes -
+   * @param nextToken - Used for pagination, when making another request provide this token with the
+   * next parameter. The next token is the box name to use as the pagination cursor,
+   * encoded in the goal app call arg form.
+   * @param round - The round for which this information is relevant.
+   */
+  constructor({
+    boxes,
+    nextToken,
+    round,
+  }: {
+    boxes: BoxDescriptor[];
+    nextToken?: string;
+    round?: number | bigint;
+  }) {
+    this.boxes = boxes;
+    this.nextToken = nextToken;
+    this.round =
+      typeof round === 'undefined' ? undefined : ensureSafeInteger(round);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  getEncodingSchema(): Schema {
     return BoxesResponse.encodingSchema;
   }
 
   toEncodingData(): Map<string, unknown> {
     return new Map<string, unknown>([
       ['boxes', this.boxes.map((v) => v.toEncodingData())],
+      ['next-token', this.nextToken],
+      ['round', this.round],
     ]);
   }
 
@@ -3343,6 +3696,8 @@ export class BoxesResponse implements Encodable {
       boxes: (data.get('boxes') ?? []).map((v: unknown) =>
         BoxDescriptor.fromEncodingData(v)
       ),
+      nextToken: data.get('next-token'),
+      round: data.get('round'),
     });
   }
 }
@@ -3367,575 +3722,102 @@ export class BuildVersion implements Encodable {
           omitEmpty: true,
         },
         { key: 'major', valueSchema: new Uint64Schema(), omitEmpty: true },
-        { key: 'minor', valueSchema: new Uint64Schema(), omitEmpty: true }
-      );
-    }
-    return this.encodingSchemaValue;
-  }
-
-  public branch: string;
-
-  public buildNumber: number;
-
-  public channel: string;
-
-  public commitHash: string;
-
-  public major: number;
-
-  public minor: number;
-
-  /**
-   * Creates a new `BuildVersion` object.
-   * @param branch -
-   * @param buildNumber -
-   * @param channel -
-   * @param commitHash -
-   * @param major -
-   * @param minor -
-   */
-  constructor({
-    branch,
-    buildNumber,
-    channel,
-    commitHash,
-    major,
-    minor,
-  }: {
-    branch: string;
-    buildNumber: number | bigint;
-    channel: string;
-    commitHash: string;
-    major: number | bigint;
-    minor: number | bigint;
-  }) {
-    this.branch = branch;
-    this.buildNumber = ensureSafeInteger(buildNumber);
-    this.channel = channel;
-    this.commitHash = commitHash;
-    this.major = ensureSafeInteger(major);
-    this.minor = ensureSafeInteger(minor);
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  getEncodingSchema(): Schema {
-    return BuildVersion.encodingSchema;
-  }
-
-  toEncodingData(): Map<string, unknown> {
-    return new Map<string, unknown>([
-      ['branch', this.branch],
-      ['build_number', this.buildNumber],
-      ['channel', this.channel],
-      ['commit_hash', this.commitHash],
-      ['major', this.major],
-      ['minor', this.minor],
-    ]);
-  }
-
-  static fromEncodingData(data: unknown): BuildVersion {
-    if (!(data instanceof Map)) {
-      throw new Error(`Invalid decoded BuildVersion: ${data}`);
-    }
-    return new BuildVersion({
-      branch: data.get('branch'),
-      buildNumber: data.get('build_number'),
-      channel: data.get('channel'),
-      commitHash: data.get('commit_hash'),
-      major: data.get('major'),
-      minor: data.get('minor'),
-    });
-  }
-}
-
-/**
- * Teal compile Result
- */
-export class CompileResponse implements Encodable {
-  private static encodingSchemaValue: Schema | undefined;
-
-  static get encodingSchema(): Schema {
-    if (!this.encodingSchemaValue) {
-      this.encodingSchemaValue = new NamedMapSchema([]);
-      (this.encodingSchemaValue as NamedMapSchema).pushEntries(
-        { key: 'hash', valueSchema: new StringSchema(), omitEmpty: true },
-        { key: 'result', valueSchema: new StringSchema(), omitEmpty: true },
-        {
-          key: 'sourcemap',
-          valueSchema: new OptionalSchema(UntypedValue.encodingSchema),
-          omitEmpty: true,
-        }
-      );
-    }
-    return this.encodingSchemaValue;
-  }
-
-  /**
-   * base32 SHA512_256 of program bytes (Address style)
-   */
-  public hash: string;
-
-  /**
-   * base64 encoded program bytes
-   */
-  public result: string;
-
-  /**
-   * JSON of the source map
-   */
-  public sourcemap?: UntypedValue;
-
-  /**
-   * Creates a new `CompileResponse` object.
-   * @param hash - base32 SHA512_256 of program bytes (Address style)
-   * @param result - base64 encoded program bytes
-   * @param sourcemap - JSON of the source map
-   */
-  constructor({
-    hash,
-    result,
-    sourcemap,
-  }: {
-    hash: string;
-    result: string;
-    sourcemap?: UntypedValue;
-  }) {
-    this.hash = hash;
-    this.result = result;
-    this.sourcemap = sourcemap;
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  getEncodingSchema(): Schema {
-    return CompileResponse.encodingSchema;
-  }
-
-  toEncodingData(): Map<string, unknown> {
-    return new Map<string, unknown>([
-      ['hash', this.hash],
-      ['result', this.result],
-      [
-        'sourcemap',
-        typeof this.sourcemap !== 'undefined'
-          ? this.sourcemap.toEncodingData()
-          : undefined,
-      ],
-    ]);
-  }
-
-  static fromEncodingData(data: unknown): CompileResponse {
-    if (!(data instanceof Map)) {
-      throw new Error(`Invalid decoded CompileResponse: ${data}`);
-    }
-    return new CompileResponse({
-      hash: data.get('hash'),
-      result: data.get('result'),
-      sourcemap:
-        typeof data.get('sourcemap') !== 'undefined'
-          ? UntypedValue.fromEncodingData(data.get('sourcemap'))
-          : undefined,
-    });
-  }
-}
-
-/**
- * Teal disassembly Result
- */
-export class DisassembleResponse implements Encodable {
-  private static encodingSchemaValue: Schema | undefined;
-
-  static get encodingSchema(): Schema {
-    if (!this.encodingSchemaValue) {
-      this.encodingSchemaValue = new NamedMapSchema([]);
-      (this.encodingSchemaValue as NamedMapSchema).pushEntries({
-        key: 'result',
-        valueSchema: new StringSchema(),
-        omitEmpty: true,
-      });
-    }
-    return this.encodingSchemaValue;
-  }
-
-  /**
-   * disassembled Teal code
-   */
-  public result: string;
-
-  /**
-   * Creates a new `DisassembleResponse` object.
-   * @param result - disassembled Teal code
-   */
-  constructor({ result }: { result: string }) {
-    this.result = result;
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  getEncodingSchema(): Schema {
-    return DisassembleResponse.encodingSchema;
-  }
-
-  toEncodingData(): Map<string, unknown> {
-    return new Map<string, unknown>([['result', this.result]]);
-  }
-
-  static fromEncodingData(data: unknown): DisassembleResponse {
-    if (!(data instanceof Map)) {
-      throw new Error(`Invalid decoded DisassembleResponse: ${data}`);
-    }
-    return new DisassembleResponse({
-      result: data.get('result'),
-    });
-  }
-}
-
-/**
- * Request data type for dryrun endpoint. Given the Transactions and simulated
- * ledger state upload, run TEAL scripts and return debugging information.
- */
-export class DryrunRequest implements Encodable {
-  private static encodingSchemaValue: Schema | undefined;
-
-  static get encodingSchema(): Schema {
-    if (!this.encodingSchemaValue) {
-      this.encodingSchemaValue = new NamedMapSchema([]);
-      (this.encodingSchemaValue as NamedMapSchema).pushEntries(
-        {
-          key: 'accounts',
-          valueSchema: new ArraySchema(Account.encodingSchema),
-          omitEmpty: true,
-        },
-        {
-          key: 'apps',
-          valueSchema: new ArraySchema(Application.encodingSchema),
-          omitEmpty: true,
-        },
-        {
-          key: 'latest-timestamp',
-          valueSchema: new Uint64Schema(),
-          omitEmpty: true,
-        },
-        {
-          key: 'protocol-version',
-          valueSchema: new StringSchema(),
-          omitEmpty: true,
-        },
-        { key: 'round', valueSchema: new Uint64Schema(), omitEmpty: true },
-        {
-          key: 'sources',
-          valueSchema: new ArraySchema(DryrunSource.encodingSchema),
-          omitEmpty: true,
-        },
-        {
-          key: 'txns',
-          valueSchema: new ArraySchema(SignedTransaction.encodingSchema),
-          omitEmpty: true,
-        }
-      );
-    }
-    return this.encodingSchemaValue;
-  }
-
-  public accounts: Account[];
-
-  public apps: Application[];
-
-  /**
-   * LatestTimestamp is available to some TEAL scripts. Defaults to the latest
-   * confirmed timestamp this algod is attached to.
-   */
-  public latestTimestamp: number;
-
-  /**
-   * ProtocolVersion specifies a specific version string to operate under, otherwise
-   * whatever the current protocol of the network this algod is running in.
-   */
-  public protocolVersion: string;
-
-  /**
-   * Round is available to some TEAL scripts. Defaults to the current round on the
-   * network this algod is attached to.
-   */
-  public round: bigint;
-
-  public sources: DryrunSource[];
-
-  public txns: SignedTransaction[];
-
-  /**
-   * Creates a new `DryrunRequest` object.
-   * @param accounts -
-   * @param apps -
-   * @param latestTimestamp - LatestTimestamp is available to some TEAL scripts. Defaults to the latest
-   * confirmed timestamp this algod is attached to.
-   * @param protocolVersion - ProtocolVersion specifies a specific version string to operate under, otherwise
-   * whatever the current protocol of the network this algod is running in.
-   * @param round - Round is available to some TEAL scripts. Defaults to the current round on the
-   * network this algod is attached to.
-   * @param sources -
-   * @param txns -
-   */
-  constructor({
-    accounts,
-    apps,
-    latestTimestamp,
-    protocolVersion,
-    round,
-    sources,
-    txns,
-  }: {
-    accounts: Account[];
-    apps: Application[];
-    latestTimestamp: number | bigint;
-    protocolVersion: string;
-    round: number | bigint;
-    sources: DryrunSource[];
-    txns: SignedTransaction[];
-  }) {
-    this.accounts = accounts;
-    this.apps = apps;
-    this.latestTimestamp = ensureSafeInteger(latestTimestamp);
-    this.protocolVersion = protocolVersion;
-    this.round = ensureBigInt(round);
-    this.sources = sources;
-    this.txns = txns;
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  getEncodingSchema(): Schema {
-    return DryrunRequest.encodingSchema;
-  }
-
-  toEncodingData(): Map<string, unknown> {
-    return new Map<string, unknown>([
-      ['accounts', this.accounts.map((v) => v.toEncodingData())],
-      ['apps', this.apps.map((v) => v.toEncodingData())],
-      ['latest-timestamp', this.latestTimestamp],
-      ['protocol-version', this.protocolVersion],
-      ['round', this.round],
-      ['sources', this.sources.map((v) => v.toEncodingData())],
-      ['txns', this.txns.map((v) => v.toEncodingData())],
-    ]);
-  }
-
-  static fromEncodingData(data: unknown): DryrunRequest {
-    if (!(data instanceof Map)) {
-      throw new Error(`Invalid decoded DryrunRequest: ${data}`);
-    }
-    return new DryrunRequest({
-      accounts: (data.get('accounts') ?? []).map((v: unknown) =>
-        Account.fromEncodingData(v)
-      ),
-      apps: (data.get('apps') ?? []).map((v: unknown) =>
-        Application.fromEncodingData(v)
-      ),
-      latestTimestamp: data.get('latest-timestamp'),
-      protocolVersion: data.get('protocol-version'),
-      round: data.get('round'),
-      sources: (data.get('sources') ?? []).map((v: unknown) =>
-        DryrunSource.fromEncodingData(v)
-      ),
-      txns: (data.get('txns') ?? []).map((v: unknown) =>
-        SignedTransaction.fromEncodingData(v)
-      ),
-    });
-  }
-}
-
-/**
- * DryrunResponse contains per-txn debug information from a dryrun.
- */
-export class DryrunResponse implements Encodable {
-  private static encodingSchemaValue: Schema | undefined;
-
-  static get encodingSchema(): Schema {
-    if (!this.encodingSchemaValue) {
-      this.encodingSchemaValue = new NamedMapSchema([]);
-      (this.encodingSchemaValue as NamedMapSchema).pushEntries(
-        { key: 'error', valueSchema: new StringSchema(), omitEmpty: true },
-        {
-          key: 'protocol-version',
-          valueSchema: new StringSchema(),
-          omitEmpty: true,
-        },
-        {
-          key: 'txns',
-          valueSchema: new ArraySchema(DryrunTxnResult.encodingSchema),
-          omitEmpty: true,
-        }
-      );
-    }
-    return this.encodingSchemaValue;
-  }
-
-  public error: string;
-
-  /**
-   * Protocol version is the protocol version Dryrun was operated under.
-   */
-  public protocolVersion: string;
-
-  public txns: DryrunTxnResult[];
-
-  /**
-   * Creates a new `DryrunResponse` object.
-   * @param error -
-   * @param protocolVersion - Protocol version is the protocol version Dryrun was operated under.
-   * @param txns -
-   */
-  constructor({
-    error,
-    protocolVersion,
-    txns,
-  }: {
-    error: string;
-    protocolVersion: string;
-    txns: DryrunTxnResult[];
-  }) {
-    this.error = error;
-    this.protocolVersion = protocolVersion;
-    this.txns = txns;
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  getEncodingSchema(): Schema {
-    return DryrunResponse.encodingSchema;
-  }
-
-  toEncodingData(): Map<string, unknown> {
-    return new Map<string, unknown>([
-      ['error', this.error],
-      ['protocol-version', this.protocolVersion],
-      ['txns', this.txns.map((v) => v.toEncodingData())],
-    ]);
-  }
-
-  static fromEncodingData(data: unknown): DryrunResponse {
-    if (!(data instanceof Map)) {
-      throw new Error(`Invalid decoded DryrunResponse: ${data}`);
-    }
-    return new DryrunResponse({
-      error: data.get('error'),
-      protocolVersion: data.get('protocol-version'),
-      txns: (data.get('txns') ?? []).map((v: unknown) =>
-        DryrunTxnResult.fromEncodingData(v)
-      ),
-    });
-  }
-}
-
-/**
- * DryrunSource is TEAL source text that gets uploaded, compiled, and inserted into
- * transactions or application state.
- */
-export class DryrunSource implements Encodable {
-  private static encodingSchemaValue: Schema | undefined;
-
-  static get encodingSchema(): Schema {
-    if (!this.encodingSchemaValue) {
-      this.encodingSchemaValue = new NamedMapSchema([]);
-      (this.encodingSchemaValue as NamedMapSchema).pushEntries(
-        { key: 'app-index', valueSchema: new Uint64Schema(), omitEmpty: true },
-        { key: 'field-name', valueSchema: new StringSchema(), omitEmpty: true },
-        { key: 'source', valueSchema: new StringSchema(), omitEmpty: true },
-        { key: 'txn-index', valueSchema: new Uint64Schema(), omitEmpty: true }
+        { key: 'minor', valueSchema: new Uint64Schema(), omitEmpty: true }
       );
     }
     return this.encodingSchemaValue;
   }
 
-  public appIndex: bigint;
+  public branch: string;
 
-  /**
-   * FieldName is what kind of sources this is. If lsig then it goes into the
-   * transactions[this.TxnIndex].LogicSig. If approv or clearp it goes into the
-   * Approval Program or Clear State Program of application[this.AppIndex].
-   */
-  public fieldName: string;
+  public buildNumber: number;
+
+  public channel: string;
+
+  public commitHash: string;
 
-  public source: string;
+  public major: number;
 
-  public txnIndex: number;
+  public minor: number;
 
   /**
-   * Creates a new `DryrunSource` object.
-   * @param appIndex -
-   * @param fieldName - FieldName is what kind of sources this is. If lsig then it goes into the
-   * transactions[this.TxnIndex].LogicSig. If approv or clearp it goes into the
-   * Approval Program or Clear State Program of application[this.AppIndex].
-   * @param source -
-   * @param txnIndex -
+   * Creates a new `BuildVersion` object.
+   * @param branch -
+   * @param buildNumber -
+   * @param channel -
+   * @param commitHash -
+   * @param major -
+   * @param minor -
    */
   constructor({
-    appIndex,
-    fieldName,
-    source,
-    txnIndex,
+    branch,
+    buildNumber,
+    channel,
+    commitHash,
+    major,
+    minor,
   }: {
-    appIndex: number | bigint;
-    fieldName: string;
-    source: string;
-    txnIndex: number | bigint;
+    branch: string;
+    buildNumber: number | bigint;
+    channel: string;
+    commitHash: string;
+    major: number | bigint;
+    minor: number | bigint;
   }) {
-    this.appIndex = ensureBigInt(appIndex);
-    this.fieldName = fieldName;
-    this.source = source;
-    this.txnIndex = ensureSafeInteger(txnIndex);
+    this.branch = branch;
+    this.buildNumber = ensureSafeInteger(buildNumber);
+    this.channel = channel;
+    this.commitHash = commitHash;
+    this.major = ensureSafeInteger(major);
+    this.minor = ensureSafeInteger(minor);
   }
 
   // eslint-disable-next-line class-methods-use-this
   getEncodingSchema(): Schema {
-    return DryrunSource.encodingSchema;
+    return BuildVersion.encodingSchema;
   }
 
   toEncodingData(): Map<string, unknown> {
     return new Map<string, unknown>([
-      ['app-index', this.appIndex],
-      ['field-name', this.fieldName],
-      ['source', this.source],
-      ['txn-index', this.txnIndex],
+      ['branch', this.branch],
+      ['build_number', this.buildNumber],
+      ['channel', this.channel],
+      ['commit_hash', this.commitHash],
+      ['major', this.major],
+      ['minor', this.minor],
     ]);
   }
 
-  static fromEncodingData(data: unknown): DryrunSource {
+  static fromEncodingData(data: unknown): BuildVersion {
     if (!(data instanceof Map)) {
-      throw new Error(`Invalid decoded DryrunSource: ${data}`);
+      throw new Error(`Invalid decoded BuildVersion: ${data}`);
     }
-    return new DryrunSource({
-      appIndex: data.get('app-index'),
-      fieldName: data.get('field-name'),
-      source: data.get('source'),
-      txnIndex: data.get('txn-index'),
+    return new BuildVersion({
+      branch: data.get('branch'),
+      buildNumber: data.get('build_number'),
+      channel: data.get('channel'),
+      commitHash: data.get('commit_hash'),
+      major: data.get('major'),
+      minor: data.get('minor'),
     });
   }
 }
 
 /**
- * Stores the TEAL eval step data
+ * Teal compile Result
  */
-export class DryrunState implements Encodable {
+export class CompileResponse implements Encodable {
   private static encodingSchemaValue: Schema | undefined;
 
   static get encodingSchema(): Schema {
     if (!this.encodingSchemaValue) {
       this.encodingSchemaValue = new NamedMapSchema([]);
       (this.encodingSchemaValue as NamedMapSchema).pushEntries(
-        { key: 'line', valueSchema: new Uint64Schema(), omitEmpty: true },
-        { key: 'pc', valueSchema: new Uint64Schema(), omitEmpty: true },
-        {
-          key: 'stack',
-          valueSchema: new ArraySchema(TealValue.encodingSchema),
-          omitEmpty: true,
-        },
-        {
-          key: 'error',
-          valueSchema: new OptionalSchema(new StringSchema()),
-          omitEmpty: true,
-        },
+        { key: 'hash', valueSchema: new StringSchema(), omitEmpty: true },
+        { key: 'result', valueSchema: new StringSchema(), omitEmpty: true },
         {
-          key: 'scratch',
-          valueSchema: new OptionalSchema(
-            new ArraySchema(TealValue.encodingSchema)
-          ),
+          key: 'sourcemap',
+          valueSchema: new OptionalSchema(UntypedValue.encodingSchema),
           omitEmpty: true,
         }
       );
@@ -3944,346 +3826,119 @@ export class DryrunState implements Encodable {
   }
 
   /**
-   * Line number
+   * base32 SHA512_256 of program bytes (Address style)
    */
-  public line: number;
+  public hash: string;
 
   /**
-   * Program counter
+   * base64 encoded program bytes
    */
-  public pc: number;
-
-  public stack: TealValue[];
+  public result: string;
 
   /**
-   * Evaluation error if any
+   * JSON of the source map
    */
-  public error?: string;
-
-  public scratch?: TealValue[];
+  public sourcemap?: UntypedValue;
 
   /**
-   * Creates a new `DryrunState` object.
-   * @param line - Line number
-   * @param pc - Program counter
-   * @param stack -
-   * @param error - Evaluation error if any
-   * @param scratch -
+   * Creates a new `CompileResponse` object.
+   * @param hash - base32 SHA512_256 of program bytes (Address style)
+   * @param result - base64 encoded program bytes
+   * @param sourcemap - JSON of the source map
    */
   constructor({
-    line,
-    pc,
-    stack,
-    error,
-    scratch,
+    hash,
+    result,
+    sourcemap,
   }: {
-    line: number | bigint;
-    pc: number | bigint;
-    stack: TealValue[];
-    error?: string;
-    scratch?: TealValue[];
+    hash: string;
+    result: string;
+    sourcemap?: UntypedValue;
   }) {
-    this.line = ensureSafeInteger(line);
-    this.pc = ensureSafeInteger(pc);
-    this.stack = stack;
-    this.error = error;
-    this.scratch = scratch;
+    this.hash = hash;
+    this.result = result;
+    this.sourcemap = sourcemap;
   }
 
   // eslint-disable-next-line class-methods-use-this
   getEncodingSchema(): Schema {
-    return DryrunState.encodingSchema;
+    return CompileResponse.encodingSchema;
   }
 
   toEncodingData(): Map<string, unknown> {
     return new Map<string, unknown>([
-      ['line', this.line],
-      ['pc', this.pc],
-      ['stack', this.stack.map((v) => v.toEncodingData())],
-      ['error', this.error],
+      ['hash', this.hash],
+      ['result', this.result],
       [
-        'scratch',
-        typeof this.scratch !== 'undefined'
-          ? this.scratch.map((v) => v.toEncodingData())
+        'sourcemap',
+        typeof this.sourcemap !== 'undefined'
+          ? this.sourcemap.toEncodingData()
           : undefined,
       ],
     ]);
   }
 
-  static fromEncodingData(data: unknown): DryrunState {
+  static fromEncodingData(data: unknown): CompileResponse {
     if (!(data instanceof Map)) {
-      throw new Error(`Invalid decoded DryrunState: ${data}`);
+      throw new Error(`Invalid decoded CompileResponse: ${data}`);
     }
-    return new DryrunState({
-      line: data.get('line'),
-      pc: data.get('pc'),
-      stack: (data.get('stack') ?? []).map((v: unknown) =>
-        TealValue.fromEncodingData(v)
-      ),
-      error: data.get('error'),
-      scratch:
-        typeof data.get('scratch') !== 'undefined'
-          ? data
-              .get('scratch')
-              .map((v: unknown) => TealValue.fromEncodingData(v))
+    return new CompileResponse({
+      hash: data.get('hash'),
+      result: data.get('result'),
+      sourcemap:
+        typeof data.get('sourcemap') !== 'undefined'
+          ? UntypedValue.fromEncodingData(data.get('sourcemap'))
           : undefined,
     });
   }
 }
 
 /**
- * DryrunTxnResult contains any LogicSig or ApplicationCall program debug
- * information and state updates from a dryrun.
+ * Teal disassembly Result
  */
-export class DryrunTxnResult implements Encodable {
+export class DisassembleResponse implements Encodable {
   private static encodingSchemaValue: Schema | undefined;
 
   static get encodingSchema(): Schema {
     if (!this.encodingSchemaValue) {
       this.encodingSchemaValue = new NamedMapSchema([]);
-      (this.encodingSchemaValue as NamedMapSchema).pushEntries(
-        {
-          key: 'disassembly',
-          valueSchema: new ArraySchema(new StringSchema()),
-          omitEmpty: true,
-        },
-        {
-          key: 'app-call-messages',
-          valueSchema: new OptionalSchema(new ArraySchema(new StringSchema())),
-          omitEmpty: true,
-        },
-        {
-          key: 'app-call-trace',
-          valueSchema: new OptionalSchema(
-            new ArraySchema(DryrunState.encodingSchema)
-          ),
-          omitEmpty: true,
-        },
-        {
-          key: 'budget-added',
-          valueSchema: new OptionalSchema(new Uint64Schema()),
-          omitEmpty: true,
-        },
-        {
-          key: 'budget-consumed',
-          valueSchema: new OptionalSchema(new Uint64Schema()),
-          omitEmpty: true,
-        },
-        {
-          key: 'global-delta',
-          valueSchema: new OptionalSchema(
-            new ArraySchema(EvalDeltaKeyValue.encodingSchema)
-          ),
-          omitEmpty: true,
-        },
-        {
-          key: 'local-deltas',
-          valueSchema: new OptionalSchema(
-            new ArraySchema(AccountStateDelta.encodingSchema)
-          ),
-          omitEmpty: true,
-        },
-        {
-          key: 'logic-sig-disassembly',
-          valueSchema: new OptionalSchema(new ArraySchema(new StringSchema())),
-          omitEmpty: true,
-        },
-        {
-          key: 'logic-sig-messages',
-          valueSchema: new OptionalSchema(new ArraySchema(new StringSchema())),
-          omitEmpty: true,
-        },
-        {
-          key: 'logic-sig-trace',
-          valueSchema: new OptionalSchema(
-            new ArraySchema(DryrunState.encodingSchema)
-          ),
-          omitEmpty: true,
-        },
-        {
-          key: 'logs',
-          valueSchema: new OptionalSchema(
-            new ArraySchema(new ByteArraySchema())
-          ),
-          omitEmpty: true,
-        }
-      );
+      (this.encodingSchemaValue as NamedMapSchema).pushEntries({
+        key: 'result',
+        valueSchema: new StringSchema(),
+        omitEmpty: true,
+      });
     }
     return this.encodingSchemaValue;
   }
 
   /**
-   * Disassembled program line by line.
-   */
-  public disassembly: string[];
-
-  public appCallMessages?: string[];
-
-  public appCallTrace?: DryrunState[];
-
-  /**
-   * Budget added during execution of app call transaction.
-   */
-  public budgetAdded?: number;
-
-  /**
-   * Budget consumed during execution of app call transaction.
-   */
-  public budgetConsumed?: number;
-
-  /**
-   * Application state delta.
-   */
-  public globalDelta?: EvalDeltaKeyValue[];
-
-  public localDeltas?: AccountStateDelta[];
-
-  /**
-   * Disassembled lsig program line by line.
+   * disassembled Teal code
    */
-  public logicSigDisassembly?: string[];
-
-  public logicSigMessages?: string[];
-
-  public logicSigTrace?: DryrunState[];
-
-  public logs?: Uint8Array[];
+  public result: string;
 
   /**
-   * Creates a new `DryrunTxnResult` object.
-   * @param disassembly - Disassembled program line by line.
-   * @param appCallMessages -
-   * @param appCallTrace -
-   * @param budgetAdded - Budget added during execution of app call transaction.
-   * @param budgetConsumed - Budget consumed during execution of app call transaction.
-   * @param globalDelta - Application state delta.
-   * @param localDeltas -
-   * @param logicSigDisassembly - Disassembled lsig program line by line.
-   * @param logicSigMessages -
-   * @param logicSigTrace -
-   * @param logs -
+   * Creates a new `DisassembleResponse` object.
+   * @param result - disassembled Teal code
    */
-  constructor({
-    disassembly,
-    appCallMessages,
-    appCallTrace,
-    budgetAdded,
-    budgetConsumed,
-    globalDelta,
-    localDeltas,
-    logicSigDisassembly,
-    logicSigMessages,
-    logicSigTrace,
-    logs,
-  }: {
-    disassembly: string[];
-    appCallMessages?: string[];
-    appCallTrace?: DryrunState[];
-    budgetAdded?: number | bigint;
-    budgetConsumed?: number | bigint;
-    globalDelta?: EvalDeltaKeyValue[];
-    localDeltas?: AccountStateDelta[];
-    logicSigDisassembly?: string[];
-    logicSigMessages?: string[];
-    logicSigTrace?: DryrunState[];
-    logs?: Uint8Array[];
-  }) {
-    this.disassembly = disassembly;
-    this.appCallMessages = appCallMessages;
-    this.appCallTrace = appCallTrace;
-    this.budgetAdded =
-      typeof budgetAdded === 'undefined'
-        ? undefined
-        : ensureSafeInteger(budgetAdded);
-    this.budgetConsumed =
-      typeof budgetConsumed === 'undefined'
-        ? undefined
-        : ensureSafeInteger(budgetConsumed);
-    this.globalDelta = globalDelta;
-    this.localDeltas = localDeltas;
-    this.logicSigDisassembly = logicSigDisassembly;
-    this.logicSigMessages = logicSigMessages;
-    this.logicSigTrace = logicSigTrace;
-    this.logs = logs;
+  constructor({ result }: { result: string }) {
+    this.result = result;
   }
 
   // eslint-disable-next-line class-methods-use-this
   getEncodingSchema(): Schema {
-    return DryrunTxnResult.encodingSchema;
+    return DisassembleResponse.encodingSchema;
   }
 
   toEncodingData(): Map<string, unknown> {
-    return new Map<string, unknown>([
-      ['disassembly', this.disassembly],
-      ['app-call-messages', this.appCallMessages],
-      [
-        'app-call-trace',
-        typeof this.appCallTrace !== 'undefined'
-          ? this.appCallTrace.map((v) => v.toEncodingData())
-          : undefined,
-      ],
-      ['budget-added', this.budgetAdded],
-      ['budget-consumed', this.budgetConsumed],
-      [
-        'global-delta',
-        typeof this.globalDelta !== 'undefined'
-          ? this.globalDelta.map((v) => v.toEncodingData())
-          : undefined,
-      ],
-      [
-        'local-deltas',
-        typeof this.localDeltas !== 'undefined'
-          ? this.localDeltas.map((v) => v.toEncodingData())
-          : undefined,
-      ],
-      ['logic-sig-disassembly', this.logicSigDisassembly],
-      ['logic-sig-messages', this.logicSigMessages],
-      [
-        'logic-sig-trace',
-        typeof this.logicSigTrace !== 'undefined'
-          ? this.logicSigTrace.map((v) => v.toEncodingData())
-          : undefined,
-      ],
-      ['logs', this.logs],
-    ]);
+    return new Map<string, unknown>([['result', this.result]]);
   }
 
-  static fromEncodingData(data: unknown): DryrunTxnResult {
+  static fromEncodingData(data: unknown): DisassembleResponse {
     if (!(data instanceof Map)) {
-      throw new Error(`Invalid decoded DryrunTxnResult: ${data}`);
+      throw new Error(`Invalid decoded DisassembleResponse: ${data}`);
     }
-    return new DryrunTxnResult({
-      disassembly: data.get('disassembly'),
-      appCallMessages: data.get('app-call-messages'),
-      appCallTrace:
-        typeof data.get('app-call-trace') !== 'undefined'
-          ? data
-              .get('app-call-trace')
-              .map((v: unknown) => DryrunState.fromEncodingData(v))
-          : undefined,
-      budgetAdded: data.get('budget-added'),
-      budgetConsumed: data.get('budget-consumed'),
-      globalDelta:
-        typeof data.get('global-delta') !== 'undefined'
-          ? data
-              .get('global-delta')
-              .map((v: unknown) => EvalDeltaKeyValue.fromEncodingData(v))
-          : undefined,
-      localDeltas:
-        typeof data.get('local-deltas') !== 'undefined'
-          ? data
-              .get('local-deltas')
-              .map((v: unknown) => AccountStateDelta.fromEncodingData(v))
-          : undefined,
-      logicSigDisassembly: data.get('logic-sig-disassembly'),
-      logicSigMessages: data.get('logic-sig-messages'),
-      logicSigTrace:
-        typeof data.get('logic-sig-trace') !== 'undefined'
-          ? data
-              .get('logic-sig-trace')
-              .map((v: unknown) => DryrunState.fromEncodingData(v))
-          : undefined,
-      logs: data.get('logs'),
+    return new DisassembleResponse({
+      result: data.get('result'),
     });
   }
 }
@@ -8039,6 +7694,11 @@ export class SupplyResponse implements Encodable {
           valueSchema: new Uint64Schema(),
           omitEmpty: true,
         },
+        {
+          key: 'online-stake',
+          valueSchema: new Uint64Schema(),
+          omitEmpty: true,
+        },
         { key: 'total-money', valueSchema: new Uint64Schema(), omitEmpty: true }
       );
     }
@@ -8051,10 +7711,18 @@ export class SupplyResponse implements Encodable {
   public currentRound: bigint;
 
   /**
-   * OnlineMoney
+   * Total stake held by accounts with status Online at current_round, including
+   * those whose participation keys have expired but have not yet been marked
+   * offline.
    */
   public onlineMoney: bigint;
 
+  /**
+   * Online stake used by agreement to vote for current_round, excluding accounts
+   * whose participation keys have expired.
+   */
+  public onlineStake: bigint;
+
   /**
    * TotalMoney
    */
@@ -8063,20 +7731,27 @@ export class SupplyResponse implements Encodable {
   /**
    * Creates a new `SupplyResponse` object.
    * @param currentRound - Round
-   * @param onlineMoney - OnlineMoney
+   * @param onlineMoney - Total stake held by accounts with status Online at current_round, including
+   * those whose participation keys have expired but have not yet been marked
+   * offline.
+   * @param onlineStake - Online stake used by agreement to vote for current_round, excluding accounts
+   * whose participation keys have expired.
    * @param totalMoney - TotalMoney
    */
   constructor({
     currentRound,
     onlineMoney,
+    onlineStake,
     totalMoney,
   }: {
     currentRound: number | bigint;
     onlineMoney: number | bigint;
+    onlineStake: number | bigint;
     totalMoney: number | bigint;
   }) {
     this.currentRound = ensureBigInt(currentRound);
     this.onlineMoney = ensureBigInt(onlineMoney);
+    this.onlineStake = ensureBigInt(onlineStake);
     this.totalMoney = ensureBigInt(totalMoney);
   }
 
@@ -8089,6 +7764,7 @@ export class SupplyResponse implements Encodable {
     return new Map<string, unknown>([
       ['current_round', this.currentRound],
       ['online-money', this.onlineMoney],
+      ['online-stake', this.onlineStake],
       ['total-money', this.totalMoney],
     ]);
   }
@@ -8100,6 +7776,7 @@ export class SupplyResponse implements Encodable {
     return new SupplyResponse({
       currentRound: data.get('current_round'),
       onlineMoney: data.get('online-money'),
+      onlineStake: data.get('online-stake'),
       totalMoney: data.get('total-money'),
     });
   }
@@ -8360,8 +8037,8 @@ export class TransactionParametersResponse implements Encodable {
   public lastRound: bigint;
 
   /**
-   * The minimum transaction fee (not per byte) required for the
-   * txn to validate for the current network protocol.
+   * The minimum transaction fee (not per byte) required for the txn to validate for
+   * the current network protocol.
    */
   public minFee: bigint;
 
@@ -8376,8 +8053,8 @@ export class TransactionParametersResponse implements Encodable {
    * @param genesisHash - GenesisHash is the hash of the genesis block.
    * @param genesisId - GenesisID is an ID listed in the genesis block.
    * @param lastRound - LastRound indicates the last round seen
-   * @param minFee - The minimum transaction fee (not per byte) required for the
-   * txn to validate for the current network protocol.
+   * @param minFee - The minimum transaction fee (not per byte) required for the txn to validate for
+   * the current network protocol.
    */
   constructor({
     consensusVersion,