import * as $ from '@manahippo/move-to-ts';
import { AptosDataCache, AptosParserRepo, DummyCache, AptosLocalCache } from '@manahippo/move-to-ts';
import { U8, U64, U128 } from '@manahippo/move-to-ts';
import { u8, u64, u128 } from '@manahippo/move-to-ts';
import { TypeParamDeclType, FieldDeclType } from '@manahippo/move-to-ts';
import { AtomicTypeTag, StructTag, TypeTag, VectorTag, SimpleStructTag } from '@manahippo/move-to-ts';
import { OptionTransaction } from '@manahippo/move-to-ts';
import { HexString, AptosClient, AptosAccount, TxnBuilderTypes, Types } from 'aptos';
import * as Error from './error';
import * as State_storage from './state_storage';
import * as System_addresses from './system_addresses';
import * as Vector from './vector';
export const packageName = 'AptosFramework';
export const moduleAddress = new HexString('0x1');
export const moduleName = 'storage_gas';

export const BASIS_POINT_DENOMINATION: U64 = u64('10000');
export const EINVALID_GAS_RANGE: U64 = u64('2');
export const EINVALID_MONOTONICALLY_NON_DECREASING_CURVE: U64 = u64('5');
export const EINVALID_POINT_RANGE: U64 = u64('6');
export const ESTORAGE_GAS: U64 = u64('1');
export const ESTORAGE_GAS_CONFIG: U64 = u64('0');
export const ETARGET_USAGE_TOO_BIG: U64 = u64('4');
export const EZERO_TARGET_USAGE: U64 = u64('3');
export const MAX_U64: U64 = u64('18446744073709551615');

export class GasCurve {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'GasCurve';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'min_gas', typeTag: AtomicTypeTag.U64 },
    { name: 'max_gas', typeTag: AtomicTypeTag.U64 },
    { name: 'points', typeTag: new VectorTag(new StructTag(new HexString('0x1'), 'storage_gas', 'Point', [])) }
  ];

  min_gas: U64;
  max_gas: U64;
  points: Point[];

  constructor(proto: any, public typeTag: TypeTag) {
    this.min_gas = proto['min_gas'] as U64;
    this.max_gas = proto['max_gas'] as U64;
    this.points = proto['points'] as Point[];
  }

  static GasCurveParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): GasCurve {
    const proto = $.parseStructProto(data, typeTag, repo, GasCurve);
    return new GasCurve(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'GasCurve', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class Point {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'Point';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'x', typeTag: AtomicTypeTag.U64 },
    { name: 'y', typeTag: AtomicTypeTag.U64 }
  ];

  x: U64;
  y: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.x = proto['x'] as U64;
    this.y = proto['y'] as U64;
  }

  static PointParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): Point {
    const proto = $.parseStructProto(data, typeTag, repo, Point);
    return new Point(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'Point', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class StorageGas {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'StorageGas';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'per_item_read', typeTag: AtomicTypeTag.U64 },
    { name: 'per_item_create', typeTag: AtomicTypeTag.U64 },
    { name: 'per_item_write', typeTag: AtomicTypeTag.U64 },
    { name: 'per_byte_read', typeTag: AtomicTypeTag.U64 },
    { name: 'per_byte_create', typeTag: AtomicTypeTag.U64 },
    { name: 'per_byte_write', typeTag: AtomicTypeTag.U64 }
  ];

  per_item_read: U64;
  per_item_create: U64;
  per_item_write: U64;
  per_byte_read: U64;
  per_byte_create: U64;
  per_byte_write: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.per_item_read = proto['per_item_read'] as U64;
    this.per_item_create = proto['per_item_create'] as U64;
    this.per_item_write = proto['per_item_write'] as U64;
    this.per_byte_read = proto['per_byte_read'] as U64;
    this.per_byte_create = proto['per_byte_create'] as U64;
    this.per_byte_write = proto['per_byte_write'] as U64;
  }

  static StorageGasParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): StorageGas {
    const proto = $.parseStructProto(data, typeTag, repo, StorageGas);
    return new StorageGas(proto, typeTag);
  }

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, StorageGas, typeParams);
    return result as unknown as StorageGas;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, StorageGas, typeParams);
    await result.loadFullState(app);
    return result as unknown as StorageGas;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'StorageGas', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class StorageGasConfig {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'StorageGasConfig';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'item_config', typeTag: new StructTag(new HexString('0x1'), 'storage_gas', 'UsageGasConfig', []) },
    { name: 'byte_config', typeTag: new StructTag(new HexString('0x1'), 'storage_gas', 'UsageGasConfig', []) }
  ];

  item_config: UsageGasConfig;
  byte_config: UsageGasConfig;

  constructor(proto: any, public typeTag: TypeTag) {
    this.item_config = proto['item_config'] as UsageGasConfig;
    this.byte_config = proto['byte_config'] as UsageGasConfig;
  }

  static StorageGasConfigParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): StorageGasConfig {
    const proto = $.parseStructProto(data, typeTag, repo, StorageGasConfig);
    return new StorageGasConfig(proto, typeTag);
  }

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, StorageGasConfig, typeParams);
    return result as unknown as StorageGasConfig;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, StorageGasConfig, typeParams);
    await result.loadFullState(app);
    return result as unknown as StorageGasConfig;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'StorageGasConfig', []);
  }
  async loadFullState(app: $.AppType) {
    await this.item_config.loadFullState(app);
    await this.byte_config.loadFullState(app);
    this.__app = app;
  }
}

export class UsageGasConfig {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'UsageGasConfig';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'target_usage', typeTag: AtomicTypeTag.U64 },
    { name: 'read_curve', typeTag: new StructTag(new HexString('0x1'), 'storage_gas', 'GasCurve', []) },
    { name: 'create_curve', typeTag: new StructTag(new HexString('0x1'), 'storage_gas', 'GasCurve', []) },
    { name: 'write_curve', typeTag: new StructTag(new HexString('0x1'), 'storage_gas', 'GasCurve', []) }
  ];

  target_usage: U64;
  read_curve: GasCurve;
  create_curve: GasCurve;
  write_curve: GasCurve;

  constructor(proto: any, public typeTag: TypeTag) {
    this.target_usage = proto['target_usage'] as U64;
    this.read_curve = proto['read_curve'] as GasCurve;
    this.create_curve = proto['create_curve'] as GasCurve;
    this.write_curve = proto['write_curve'] as GasCurve;
  }

  static UsageGasConfigParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): UsageGasConfig {
    const proto = $.parseStructProto(data, typeTag, repo, UsageGasConfig);
    return new UsageGasConfig(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'UsageGasConfig', []);
  }
  async loadFullState(app: $.AppType) {
    await this.read_curve.loadFullState(app);
    await this.create_curve.loadFullState(app);
    await this.write_curve.loadFullState(app);
    this.__app = app;
  }
}
export function base_8192_exponential_curve_(min_gas: U64, max_gas: U64, $c: AptosDataCache): GasCurve {
  return new_gas_curve_(
    $.copy(min_gas),
    $.copy(max_gas),
    [
      new_point_(u64('1000'), u64('2'), $c),
      new_point_(u64('2000'), u64('6'), $c),
      new_point_(u64('3000'), u64('17'), $c),
      new_point_(u64('4000'), u64('44'), $c),
      new_point_(u64('5000'), u64('109'), $c),
      new_point_(u64('6000'), u64('271'), $c),
      new_point_(u64('7000'), u64('669'), $c),
      new_point_(u64('8000'), u64('1648'), $c),
      new_point_(u64('9000'), u64('4061'), $c),
      new_point_(u64('9500'), u64('6372'), $c),
      new_point_(u64('9900'), u64('9138'), $c)
    ],
    $c
  );
}

export function calculate_create_gas_(config: UsageGasConfig, usage: U64, $c: AptosDataCache): U64 {
  return calculate_gas_($.copy(config.target_usage), $.copy(usage), config.create_curve, $c);
}

export function calculate_gas_(max_usage: U64, current_usage: U64, curve: GasCurve, $c: AptosDataCache): U64 {
  let temp$1,
    temp$10,
    temp$11,
    temp$12,
    temp$13,
    temp$2,
    temp$3,
    temp$4,
    temp$5,
    temp$6,
    temp$7,
    temp$8,
    temp$9,
    capped_current_usage,
    current_usage_bps,
    i,
    j,
    left,
    mid,
    num_points,
    points,
    right,
    y_interpolated;
  if ($.copy(current_usage).gt($.copy(max_usage))) {
    temp$1 = $.copy(max_usage);
  } else {
    temp$1 = $.copy(current_usage);
  }
  capped_current_usage = temp$1;
  points = curve.points;
  num_points = Vector.length_(points, $c, [new SimpleStructTag(Point)]);
  current_usage_bps = $.copy(capped_current_usage).mul($.copy(BASIS_POINT_DENOMINATION)).div($.copy(max_usage));
  if ($.copy(num_points).eq(u64('0'))) {
    temp$3 = new Point({ x: u64('0'), y: u64('0') }, new SimpleStructTag(Point));
    temp$4 = temp$3;
    temp$2 = new Point(
      { x: $.copy(BASIS_POINT_DENOMINATION), y: $.copy(BASIS_POINT_DENOMINATION) },
      new SimpleStructTag(Point)
    );
    [temp$12, temp$13] = [temp$4, temp$2];
  } else {
    if ($.copy(current_usage_bps).lt($.copy(Vector.borrow_(points, u64('0'), $c, [new SimpleStructTag(Point)]).x))) {
      temp$5 = new Point({ x: u64('0'), y: u64('0') }, new SimpleStructTag(Point));
      [temp$10, temp$11] = [temp$5, Vector.borrow_(points, u64('0'), $c, [new SimpleStructTag(Point)])];
    } else {
      if (
        $.copy(Vector.borrow_(points, $.copy(num_points).sub(u64('1')), $c, [new SimpleStructTag(Point)]).x).le(
          $.copy(current_usage_bps)
        )
      ) {
        temp$7 = Vector.borrow_(points, $.copy(num_points).sub(u64('1')), $c, [new SimpleStructTag(Point)]);
        temp$6 = new Point(
          { x: $.copy(BASIS_POINT_DENOMINATION), y: $.copy(BASIS_POINT_DENOMINATION) },
          new SimpleStructTag(Point)
        );
        [temp$8, temp$9] = [temp$7, temp$6];
      } else {
        [i, j] = [u64('0'), $.copy(num_points).sub(u64('2'))];
        while (true) {
          {
          }
          if (!$.copy(i).lt($.copy(j))) break;
          {
            mid = $.copy(j).sub($.copy(j).sub($.copy(i)).div(u64('2')));
            if (
              $.copy(current_usage_bps).lt(
                $.copy(Vector.borrow_(points, $.copy(mid), $c, [new SimpleStructTag(Point)]).x)
              )
            ) {
              j = $.copy(mid).sub(u64('1'));
            } else {
              i = $.copy(mid);
            }
          }
        }
        [temp$8, temp$9] = [
          Vector.borrow_(points, $.copy(i), $c, [new SimpleStructTag(Point)]),
          Vector.borrow_(points, $.copy(i).add(u64('1')), $c, [new SimpleStructTag(Point)])
        ];
      }
      [temp$10, temp$11] = [temp$8, temp$9];
    }
    [temp$12, temp$13] = [temp$10, temp$11];
  }
  [left, right] = [temp$12, temp$13];
  y_interpolated = interpolate_(
    $.copy(left.x),
    $.copy(right.x),
    $.copy(left.y),
    $.copy(right.y),
    $.copy(current_usage_bps),
    $c
  );
  return interpolate_(
    u64('0'),
    $.copy(BASIS_POINT_DENOMINATION),
    $.copy(curve.min_gas),
    $.copy(curve.max_gas),
    $.copy(y_interpolated),
    $c
  );
}

export function calculate_read_gas_(config: UsageGasConfig, usage: U64, $c: AptosDataCache): U64 {
  return calculate_gas_($.copy(config.target_usage), $.copy(usage), config.read_curve, $c);
}

export function calculate_write_gas_(config: UsageGasConfig, usage: U64, $c: AptosDataCache): U64 {
  return calculate_gas_($.copy(config.target_usage), $.copy(usage), config.write_curve, $c);
}

export function initialize_(aptos_framework: HexString, $c: AptosDataCache): void {
  let byte_config, item_config, k, m;
  System_addresses.assert_aptos_framework_(aptos_framework, $c);
  if (!!$c.exists(new SimpleStructTag(StorageGasConfig), new HexString('0x1'))) {
    throw $.abortCode(Error.already_exists_($.copy(ESTORAGE_GAS_CONFIG), $c));
  }
  k = u64('1000');
  m = u64('1000').mul(u64('1000'));
  item_config = new UsageGasConfig(
    {
      target_usage: u64('2').mul($.copy(k)).mul($.copy(m)),
      read_curve: base_8192_exponential_curve_(
        u64('300').mul($.copy(k)),
        u64('300').mul($.copy(k)).mul(u64('100')),
        $c
      ),
      create_curve: base_8192_exponential_curve_(u64('5').mul($.copy(m)), u64('5').mul($.copy(m)).mul(u64('100')), $c),
      write_curve: base_8192_exponential_curve_(
        u64('300').mul($.copy(k)),
        u64('300').mul($.copy(k)).mul(u64('100')),
        $c
      )
    },
    new SimpleStructTag(UsageGasConfig)
  );
  byte_config = new UsageGasConfig(
    {
      target_usage: u64('1').mul($.copy(m)).mul($.copy(m)),
      read_curve: base_8192_exponential_curve_(u64('300'), u64('300').mul(u64('100')), $c),
      create_curve: base_8192_exponential_curve_(u64('5').mul($.copy(k)), u64('5').mul($.copy(k)).mul(u64('100')), $c),
      write_curve: base_8192_exponential_curve_(u64('5').mul($.copy(k)), u64('5').mul($.copy(k)).mul(u64('100')), $c)
    },
    new SimpleStructTag(UsageGasConfig)
  );
  $c.move_to(
    new SimpleStructTag(StorageGasConfig),
    aptos_framework,
    new StorageGasConfig(
      { item_config: $.copy(item_config), byte_config: $.copy(byte_config) },
      new SimpleStructTag(StorageGasConfig)
    )
  );
  if (!!$c.exists(new SimpleStructTag(StorageGas), new HexString('0x1'))) {
    throw $.abortCode(Error.already_exists_($.copy(ESTORAGE_GAS), $c));
  }
  $c.move_to(
    new SimpleStructTag(StorageGas),
    aptos_framework,
    new StorageGas(
      {
        per_item_read: u64('300').mul($.copy(k)),
        per_item_create: u64('5').mul($.copy(m)),
        per_item_write: u64('300').mul($.copy(k)),
        per_byte_read: u64('300'),
        per_byte_create: u64('5').mul($.copy(k)),
        per_byte_write: u64('5').mul($.copy(k))
      },
      new SimpleStructTag(StorageGas)
    )
  );
  return;
}

export function interpolate_(x0: U64, x1: U64, y0: U64, y1: U64, x: U64, $c: AptosDataCache): U64 {
  return $.copy(y0).add(
    $.copy(x)
      .sub($.copy(x0))
      .mul($.copy(y1).sub($.copy(y0)))
      .div($.copy(x1).sub($.copy(x0)))
  );
}

export function new_gas_curve_(min_gas: U64, max_gas: U64, points: Point[], $c: AptosDataCache): GasCurve {
  if (!$.copy(max_gas).ge($.copy(min_gas))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINVALID_GAS_RANGE), $c));
  }
  if (!$.copy(max_gas).le($.copy(MAX_U64).div($.copy(BASIS_POINT_DENOMINATION)))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINVALID_GAS_RANGE), $c));
  }
  validate_points_(points, $c);
  return new GasCurve(
    { min_gas: $.copy(min_gas), max_gas: $.copy(max_gas), points: $.copy(points) },
    new SimpleStructTag(GasCurve)
  );
}

export function new_point_(x: U64, y: U64, $c: AptosDataCache): Point {
  let temp$1;
  if ($.copy(x).le($.copy(BASIS_POINT_DENOMINATION))) {
    temp$1 = $.copy(y).le($.copy(BASIS_POINT_DENOMINATION));
  } else {
    temp$1 = false;
  }
  if (!temp$1) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINVALID_POINT_RANGE), $c));
  }
  return new Point({ x: $.copy(x), y: $.copy(y) }, new SimpleStructTag(Point));
}

export function new_storage_gas_config_(
  item_config: UsageGasConfig,
  byte_config: UsageGasConfig,
  $c: AptosDataCache
): StorageGasConfig {
  return new StorageGasConfig(
    { item_config: $.copy(item_config), byte_config: $.copy(byte_config) },
    new SimpleStructTag(StorageGasConfig)
  );
}

export function new_usage_gas_config_(
  target_usage: U64,
  read_curve: GasCurve,
  create_curve: GasCurve,
  write_curve: GasCurve,
  $c: AptosDataCache
): UsageGasConfig {
  if (!$.copy(target_usage).gt(u64('0'))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EZERO_TARGET_USAGE), $c));
  }
  if (!$.copy(target_usage).le($.copy(MAX_U64).div($.copy(BASIS_POINT_DENOMINATION)))) {
    throw $.abortCode(Error.invalid_argument_($.copy(ETARGET_USAGE_TOO_BIG), $c));
  }
  return new UsageGasConfig(
    {
      target_usage: $.copy(target_usage),
      read_curve: $.copy(read_curve),
      create_curve: $.copy(create_curve),
      write_curve: $.copy(write_curve)
    },
    new SimpleStructTag(UsageGasConfig)
  );
}

export function on_reconfig_($c: AptosDataCache): void {
  let bytes, gas, gas_config, items;
  if (!$c.exists(new SimpleStructTag(StorageGasConfig), new HexString('0x1'))) {
    throw $.abortCode(Error.not_found_($.copy(ESTORAGE_GAS_CONFIG), $c));
  }
  if (!$c.exists(new SimpleStructTag(StorageGas), new HexString('0x1'))) {
    throw $.abortCode(Error.not_found_($.copy(ESTORAGE_GAS), $c));
  }
  [items, bytes] = State_storage.current_items_and_bytes_($c);
  gas_config = $c.borrow_global<StorageGasConfig>(new SimpleStructTag(StorageGasConfig), new HexString('0x1'));
  gas = $c.borrow_global_mut<StorageGas>(new SimpleStructTag(StorageGas), new HexString('0x1'));
  gas.per_item_read = calculate_read_gas_(gas_config.item_config, $.copy(items), $c);
  gas.per_item_create = calculate_create_gas_(gas_config.item_config, $.copy(items), $c);
  gas.per_item_write = calculate_write_gas_(gas_config.item_config, $.copy(items), $c);
  gas.per_byte_read = calculate_read_gas_(gas_config.byte_config, $.copy(bytes), $c);
  gas.per_byte_create = calculate_create_gas_(gas_config.byte_config, $.copy(bytes), $c);
  gas.per_byte_write = calculate_write_gas_(gas_config.byte_config, $.copy(bytes), $c);
  return;
}

export function set_config_(aptos_framework: HexString, config: StorageGasConfig, $c: AptosDataCache): void {
  System_addresses.assert_aptos_framework_(aptos_framework, $c);
  $.set(
    $c.borrow_global_mut<StorageGasConfig>(new SimpleStructTag(StorageGasConfig), new HexString('0x1')),
    $.copy(config)
  );
  return;
}

export function validate_points_(points: Point[], $c: AptosDataCache): void {
  let temp$1, temp$2, temp$3, temp$4, temp$5, cur, i, len, next;
  len = Vector.length_(points, $c, [new SimpleStructTag(Point)]);
  i = u64('0');
  while (true) {
    {
    }
    if (!$.copy(i).le($.copy(len))) break;
    {
      if ($.copy(i).eq(u64('0'))) {
        temp$1 = new Point({ x: u64('0'), y: u64('0') }, new SimpleStructTag(Point));
        temp$2 = temp$1;
      } else {
        temp$2 = Vector.borrow_(points, $.copy(i).sub(u64('1')), $c, [new SimpleStructTag(Point)]);
      }
      cur = temp$2;
      if ($.copy(i).eq($.copy(len))) {
        temp$3 = new Point(
          { x: $.copy(BASIS_POINT_DENOMINATION), y: $.copy(BASIS_POINT_DENOMINATION) },
          new SimpleStructTag(Point)
        );
        temp$4 = temp$3;
      } else {
        temp$4 = Vector.borrow_(points, $.copy(i), $c, [new SimpleStructTag(Point)]);
      }
      next = temp$4;
      if ($.copy(cur.x).lt($.copy(next.x))) {
        temp$5 = $.copy(cur.y).le($.copy(next.y));
      } else {
        temp$5 = false;
      }
      if (!temp$5) {
        throw $.abortCode(Error.invalid_argument_($.copy(EINVALID_MONOTONICALLY_NON_DECREASING_CURVE), $c));
      }
      i = $.copy(i).add(u64('1'));
    }
  }
  return;
}

export function loadParsers(repo: AptosParserRepo) {
  repo.addParser('0x1::storage_gas::GasCurve', GasCurve.GasCurveParser);
  repo.addParser('0x1::storage_gas::Point', Point.PointParser);
  repo.addParser('0x1::storage_gas::StorageGas', StorageGas.StorageGasParser);
  repo.addParser('0x1::storage_gas::StorageGasConfig', StorageGasConfig.StorageGasConfigParser);
  repo.addParser('0x1::storage_gas::UsageGasConfig', UsageGasConfig.UsageGasConfigParser);
}
export class App {
  constructor(public client: AptosClient, public repo: AptosParserRepo, public cache: AptosLocalCache) {}
  get moduleAddress() {
    {
      return moduleAddress;
    }
  }
  get moduleName() {
    {
      return moduleName;
    }
  }
  get GasCurve() {
    return GasCurve;
  }
  get Point() {
    return Point;
  }
  get StorageGas() {
    return StorageGas;
  }
  async loadStorageGas(owner: HexString, loadFull = true, fillCache = true) {
    const val = await StorageGas.load(this.repo, this.client, owner, [] as TypeTag[]);
    if (loadFull) {
      await val.loadFullState(this);
    }
    if (fillCache) {
      this.cache.set(val.typeTag, owner, val);
    }
    return val;
  }
  get StorageGasConfig() {
    return StorageGasConfig;
  }
  async loadStorageGasConfig(owner: HexString, loadFull = true, fillCache = true) {
    const val = await StorageGasConfig.load(this.repo, this.client, owner, [] as TypeTag[]);
    if (loadFull) {
      await val.loadFullState(this);
    }
    if (fillCache) {
      this.cache.set(val.typeTag, owner, val);
    }
    return val;
  }
  get UsageGasConfig() {
    return UsageGasConfig;
  }
}