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 Features from './features';
import * as Option from './option';
import * as Signer from './signer';
import * as String from './string';
import * as System_addresses from './system_addresses';
import * as Util from './util';
import * as Vector from './vector';
export const packageName = 'AptosFramework';
export const moduleAddress = new HexString('0x1');
export const moduleName = 'code';

export const EDEP_ARBITRARY_NOT_SAME_ADDRESS: U64 = u64('7');
export const EDEP_WEAKER_POLICY: U64 = u64('6');
export const EINCOMPATIBLE_POLICY_DISABLED: U64 = u64('8');
export const EMODULE_MISSING: U64 = u64('4');
export const EMODULE_NAME_CLASH: U64 = u64('1');
export const EPACKAGE_DEP_MISSING: U64 = u64('5');
export const EUPGRADE_IMMUTABLE: U64 = u64('2');
export const EUPGRADE_WEAKER_POLICY: U64 = u64('3');

export class AllowedDep {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'AllowedDep';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'account', typeTag: AtomicTypeTag.Address },
    { name: 'module_name', typeTag: new StructTag(new HexString('0x1'), 'string', 'String', []) }
  ];

  account: HexString;
  module_name: String.String;

  constructor(proto: any, public typeTag: TypeTag) {
    this.account = proto['account'] as HexString;
    this.module_name = proto['module_name'] as String.String;
  }

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

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

export class ModuleMetadata {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'ModuleMetadata';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'name', typeTag: new StructTag(new HexString('0x1'), 'string', 'String', []) },
    { name: 'source', typeTag: new VectorTag(AtomicTypeTag.U8) },
    { name: 'source_map', typeTag: new VectorTag(AtomicTypeTag.U8) },
    {
      name: 'extension',
      typeTag: new StructTag(new HexString('0x1'), 'option', 'Option', [
        new StructTag(new HexString('0x1'), 'copyable_any', 'Any', [])
      ])
    }
  ];

  name: String.String;
  source: U8[];
  source_map: U8[];
  extension: Option.Option;

  constructor(proto: any, public typeTag: TypeTag) {
    this.name = proto['name'] as String.String;
    this.source = proto['source'] as U8[];
    this.source_map = proto['source_map'] as U8[];
    this.extension = proto['extension'] as Option.Option;
  }

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

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

export class PackageDep {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'PackageDep';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'account', typeTag: AtomicTypeTag.Address },
    { name: 'package_name', typeTag: new StructTag(new HexString('0x1'), 'string', 'String', []) }
  ];

  account: HexString;
  package_name: String.String;

  constructor(proto: any, public typeTag: TypeTag) {
    this.account = proto['account'] as HexString;
    this.package_name = proto['package_name'] as String.String;
  }

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

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

export class PackageMetadata {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'PackageMetadata';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'name', typeTag: new StructTag(new HexString('0x1'), 'string', 'String', []) },
    { name: 'upgrade_policy', typeTag: new StructTag(new HexString('0x1'), 'code', 'UpgradePolicy', []) },
    { name: 'upgrade_number', typeTag: AtomicTypeTag.U64 },
    { name: 'source_digest', typeTag: new StructTag(new HexString('0x1'), 'string', 'String', []) },
    { name: 'manifest', typeTag: new VectorTag(AtomicTypeTag.U8) },
    { name: 'modules', typeTag: new VectorTag(new StructTag(new HexString('0x1'), 'code', 'ModuleMetadata', [])) },
    { name: 'deps', typeTag: new VectorTag(new StructTag(new HexString('0x1'), 'code', 'PackageDep', [])) },
    {
      name: 'extension',
      typeTag: new StructTag(new HexString('0x1'), 'option', 'Option', [
        new StructTag(new HexString('0x1'), 'copyable_any', 'Any', [])
      ])
    }
  ];

  name: String.String;
  upgrade_policy: UpgradePolicy;
  upgrade_number: U64;
  source_digest: String.String;
  manifest: U8[];
  modules: ModuleMetadata[];
  deps: PackageDep[];
  extension: Option.Option;

  constructor(proto: any, public typeTag: TypeTag) {
    this.name = proto['name'] as String.String;
    this.upgrade_policy = proto['upgrade_policy'] as UpgradePolicy;
    this.upgrade_number = proto['upgrade_number'] as U64;
    this.source_digest = proto['source_digest'] as String.String;
    this.manifest = proto['manifest'] as U8[];
    this.modules = proto['modules'] as ModuleMetadata[];
    this.deps = proto['deps'] as PackageDep[];
    this.extension = proto['extension'] as Option.Option;
  }

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

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'PackageMetadata', []);
  }
  async loadFullState(app: $.AppType) {
    await this.name.loadFullState(app);
    await this.upgrade_policy.loadFullState(app);
    await this.source_digest.loadFullState(app);
    await this.extension.loadFullState(app);
    this.__app = app;
  }
}

export class PackageRegistry {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'PackageRegistry';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'packages', typeTag: new VectorTag(new StructTag(new HexString('0x1'), 'code', 'PackageMetadata', [])) }
  ];

  packages: PackageMetadata[];

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

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

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

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

  policy: U8;

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

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

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'UpgradePolicy', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}
export function can_change_upgrade_policy_to_(from: UpgradePolicy, to: UpgradePolicy, $c: AptosDataCache): boolean {
  return $.copy(from.policy).le($.copy(to.policy));
}

export function check_coexistence_(old_pack: PackageMetadata, new_modules: String.String[], $c: AptosDataCache): void {
  let i, j, name, old_mod;
  i = u64('0');
  while ($.copy(i).lt(Vector.length_(old_pack.modules, $c, [new SimpleStructTag(ModuleMetadata)]))) {
    {
      old_mod = Vector.borrow_(old_pack.modules, $.copy(i), $c, [new SimpleStructTag(ModuleMetadata)]);
      j = u64('0');
      while (
        $.copy(j).lt(Vector.length_(new_modules, $c, [new StructTag(new HexString('0x1'), 'string', 'String', [])]))
      ) {
        {
          name = Vector.borrow_(new_modules, $.copy(j), $c, [
            new StructTag(new HexString('0x1'), 'string', 'String', [])
          ]);
          if (!!$.deep_eq(old_mod.name, name)) {
            throw $.abortCode(Error.already_exists_($.copy(EMODULE_NAME_CLASH), $c));
          }
          j = $.copy(j).add(u64('1'));
        }
      }
      i = $.copy(i).add(u64('1'));
    }
  }
  return;
}

export function check_dependencies_(
  publish_address: HexString,
  pack: PackageMetadata,
  $c: AptosDataCache
): AllowedDep[] {
  let account,
    account__1,
    allowed_module_deps,
    dep,
    dep_pack,
    deps,
    found,
    i,
    j,
    k,
    m,
    module_name,
    module_name__2,
    n,
    r,
    registry;
  allowed_module_deps = Vector.empty_($c, [new SimpleStructTag(AllowedDep)]);
  deps = pack.deps;
  i = u64('0');
  n = Vector.length_(deps, $c, [new SimpleStructTag(PackageDep)]);
  while ($.copy(i).lt($.copy(n))) {
    {
      dep = Vector.borrow_(deps, $.copy(i), $c, [new SimpleStructTag(PackageDep)]);
      if (!$c.exists(new SimpleStructTag(PackageRegistry), $.copy(dep.account))) {
        throw $.abortCode(Error.not_found_($.copy(EPACKAGE_DEP_MISSING), $c));
      }
      if (is_policy_exempted_address_($.copy(dep.account), $c)) {
        account = $.copy(dep.account);
        module_name = String.utf8_([], $c);
        Vector.push_back_(
          allowed_module_deps,
          new AllowedDep(
            { account: $.copy(account), module_name: $.copy(module_name) },
            new SimpleStructTag(AllowedDep)
          ),
          $c,
          [new SimpleStructTag(AllowedDep)]
        );
        i = $.copy(i).add(u64('1'));
        continue;
      } else {
      }
      registry = $c.borrow_global<PackageRegistry>(new SimpleStructTag(PackageRegistry), $.copy(dep.account));
      j = u64('0');
      m = Vector.length_(registry.packages, $c, [new SimpleStructTag(PackageMetadata)]);
      found = false;
      while ($.copy(j).lt($.copy(m))) {
        {
          dep_pack = Vector.borrow_(registry.packages, $.copy(j), $c, [new SimpleStructTag(PackageMetadata)]);
          if ($.deep_eq($.copy(dep_pack.name), $.copy(dep.package_name))) {
            found = true;
            if (!$.copy(dep_pack.upgrade_policy.policy).ge($.copy(pack.upgrade_policy.policy))) {
              throw $.abortCode(Error.invalid_argument_($.copy(EDEP_WEAKER_POLICY), $c));
            }
            if ($.deep_eq($.copy(dep_pack.upgrade_policy), upgrade_policy_arbitrary_($c))) {
              if (!($.copy(dep.account).hex() === $.copy(publish_address).hex())) {
                throw $.abortCode(Error.invalid_argument_($.copy(EDEP_ARBITRARY_NOT_SAME_ADDRESS), $c));
              }
            } else {
            }
            k = u64('0');
            r = Vector.length_(dep_pack.modules, $c, [new SimpleStructTag(ModuleMetadata)]);
            while ($.copy(k).lt($.copy(r))) {
              {
                account__1 = $.copy(dep.account);
                module_name__2 = $.copy(
                  Vector.borrow_(dep_pack.modules, $.copy(k), $c, [new SimpleStructTag(ModuleMetadata)]).name
                );
                Vector.push_back_(
                  allowed_module_deps,
                  new AllowedDep(
                    { account: $.copy(account__1), module_name: $.copy(module_name__2) },
                    new SimpleStructTag(AllowedDep)
                  ),
                  $c,
                  [new SimpleStructTag(AllowedDep)]
                );
                k = $.copy(k).add(u64('1'));
              }
            }
            break;
          } else {
          }
          j = $.copy(j).add(u64('1'));
        }
      }
      if (!found) {
        throw $.abortCode(Error.not_found_($.copy(EPACKAGE_DEP_MISSING), $c));
      }
      i = $.copy(i).add(u64('1'));
    }
  }
  return allowed_module_deps;
}

export function check_upgradability_(
  old_pack: PackageMetadata,
  new_pack: PackageMetadata,
  new_modules: String.String[],
  $c: AptosDataCache
): void {
  let temp$1, i, old_modules;
  temp$1 = upgrade_policy_immutable_($c);
  if (!$.copy(old_pack.upgrade_policy.policy).lt($.copy(temp$1.policy))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EUPGRADE_IMMUTABLE), $c));
  }
  if (!can_change_upgrade_policy_to_($.copy(old_pack.upgrade_policy), $.copy(new_pack.upgrade_policy), $c)) {
    throw $.abortCode(Error.invalid_argument_($.copy(EUPGRADE_WEAKER_POLICY), $c));
  }
  old_modules = get_module_names_(old_pack, $c);
  i = u64('0');
  while ($.copy(i).lt(Vector.length_(old_modules, $c, [new StructTag(new HexString('0x1'), 'string', 'String', [])]))) {
    {
      if (
        !Vector.contains_(
          new_modules,
          Vector.borrow_(old_modules, $.copy(i), $c, [new StructTag(new HexString('0x1'), 'string', 'String', [])]),
          $c,
          [new StructTag(new HexString('0x1'), 'string', 'String', [])]
        )
      ) {
        throw $.abortCode($.copy(EMODULE_MISSING));
      }
      i = $.copy(i).add(u64('1'));
    }
  }
  return;
}

export function get_module_names_(pack: PackageMetadata, $c: AptosDataCache): String.String[] {
  let i, module_names;
  module_names = Vector.empty_($c, [new StructTag(new HexString('0x1'), 'string', 'String', [])]);
  i = u64('0');
  while ($.copy(i).lt(Vector.length_(pack.modules, $c, [new SimpleStructTag(ModuleMetadata)]))) {
    {
      Vector.push_back_(
        module_names,
        $.copy(Vector.borrow_(pack.modules, $.copy(i), $c, [new SimpleStructTag(ModuleMetadata)]).name),
        $c,
        [new StructTag(new HexString('0x1'), 'string', 'String', [])]
      );
      i = $.copy(i).add(u64('1'));
    }
  }
  return $.copy(module_names);
}

export function initialize_(
  aptos_framework: HexString,
  package_owner: HexString,
  metadata: PackageMetadata,
  $c: AptosDataCache
): void {
  let addr;
  System_addresses.assert_aptos_framework_(aptos_framework, $c);
  addr = Signer.address_of_(package_owner, $c);
  if (!$c.exists(new SimpleStructTag(PackageRegistry), $.copy(addr))) {
    $c.move_to(
      new SimpleStructTag(PackageRegistry),
      package_owner,
      new PackageRegistry({ packages: [metadata] }, new SimpleStructTag(PackageRegistry))
    );
  } else {
    Vector.push_back_(
      $c.borrow_global_mut<PackageRegistry>(new SimpleStructTag(PackageRegistry), $.copy(addr)).packages,
      metadata,
      $c,
      [new SimpleStructTag(PackageMetadata)]
    );
  }
  return;
}

export function is_policy_exempted_address_(addr: HexString, $c: AptosDataCache): boolean {
  let temp$1, temp$2, temp$3, temp$4, temp$5, temp$6, temp$7, temp$8, temp$9;
  if ($.copy(addr).hex() === new HexString('0x1').hex()) {
    temp$1 = true;
  } else {
    temp$1 = $.copy(addr).hex() === new HexString('0x2').hex();
  }
  if (temp$1) {
    temp$2 = true;
  } else {
    temp$2 = $.copy(addr).hex() === new HexString('0x3').hex();
  }
  if (temp$2) {
    temp$3 = true;
  } else {
    temp$3 = $.copy(addr).hex() === new HexString('0x4').hex();
  }
  if (temp$3) {
    temp$4 = true;
  } else {
    temp$4 = $.copy(addr).hex() === new HexString('0x5').hex();
  }
  if (temp$4) {
    temp$5 = true;
  } else {
    temp$5 = $.copy(addr).hex() === new HexString('0x6').hex();
  }
  if (temp$5) {
    temp$6 = true;
  } else {
    temp$6 = $.copy(addr).hex() === new HexString('0x7').hex();
  }
  if (temp$6) {
    temp$7 = true;
  } else {
    temp$7 = $.copy(addr).hex() === new HexString('0x8').hex();
  }
  if (temp$7) {
    temp$8 = true;
  } else {
    temp$8 = $.copy(addr).hex() === new HexString('0x9').hex();
  }
  if (temp$8) {
    temp$9 = true;
  } else {
    temp$9 = $.copy(addr).hex() === new HexString('0xa').hex();
  }
  return temp$9;
}

export function publish_package_(owner: HexString, pack: PackageMetadata, code: U8[][], $c: AptosDataCache): void {
  let temp$1, temp$2, temp$3, addr, allowed_deps, i, index, len, module_names, old, packages, policy, upgrade_number;
  temp$1 = upgrade_policy_arbitrary_($c);
  if (!$.copy(pack.upgrade_policy.policy).gt($.copy(temp$1.policy))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINCOMPATIBLE_POLICY_DISABLED), $c));
  }
  addr = Signer.address_of_(owner, $c);
  if (!$c.exists(new SimpleStructTag(PackageRegistry), $.copy(addr))) {
    $c.move_to(
      new SimpleStructTag(PackageRegistry),
      owner,
      new PackageRegistry(
        { packages: Vector.empty_($c, [new SimpleStructTag(PackageMetadata)]) },
        new SimpleStructTag(PackageRegistry)
      )
    );
  } else {
  }
  allowed_deps = check_dependencies_($.copy(addr), pack, $c);
  module_names = get_module_names_(pack, $c);
  packages = $c.borrow_global_mut<PackageRegistry>(new SimpleStructTag(PackageRegistry), $.copy(addr)).packages;
  len = Vector.length_(packages, $c, [new SimpleStructTag(PackageMetadata)]);
  index = $.copy(len);
  i = u64('0');
  upgrade_number = u64('0');
  while ($.copy(i).lt($.copy(len))) {
    {
      [temp$2, temp$3] = [packages, $.copy(i)];
      old = Vector.borrow_(temp$2, temp$3, $c, [new SimpleStructTag(PackageMetadata)]);
      if ($.deep_eq($.copy(old.name), $.copy(pack.name))) {
        upgrade_number = $.copy(old.upgrade_number).add(u64('1'));
        check_upgradability_(old, pack, module_names, $c);
        index = $.copy(i);
      } else {
        check_coexistence_(old, module_names, $c);
      }
      i = $.copy(i).add(u64('1'));
    }
  }
  pack.upgrade_number = $.copy(upgrade_number);
  policy = $.copy(pack.upgrade_policy);
  if ($.copy(index).lt($.copy(len))) {
    $.set(Vector.borrow_mut_(packages, $.copy(index), $c, [new SimpleStructTag(PackageMetadata)]), pack);
  } else {
    Vector.push_back_(packages, pack, $c, [new SimpleStructTag(PackageMetadata)]);
  }
  if (Features.code_dependency_check_enabled_($c)) {
    request_publish_with_allowed_deps_(
      $.copy(addr),
      $.copy(module_names),
      allowed_deps,
      $.copy(code),
      $.copy(policy.policy),
      $c
    );
  } else {
    request_publish_($.copy(addr), $.copy(module_names), $.copy(code), $.copy(policy.policy), $c);
  }
  return;
}

export function publish_package_txn_(
  owner: HexString,
  metadata_serialized: U8[],
  code: U8[][],
  $c: AptosDataCache
): void {
  return publish_package_(
    owner,
    Util.from_bytes_($.copy(metadata_serialized), $c, [new SimpleStructTag(PackageMetadata)]),
    $.copy(code),
    $c
  );
}

export function buildPayload_publish_package_txn(
  metadata_serialized: U8[],
  code: U8[][],
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'code',
    'publish_package_txn',
    typeParamStrings,
    [metadata_serialized, code],
    isJSON
  );
}
export function request_publish_(
  owner: HexString,
  expected_modules: String.String[],
  bundle: U8[][],
  policy: U8,
  $c: AptosDataCache
): void {
  return $.aptos_framework_code_request_publish(owner, expected_modules, bundle, policy, $c);
}
export function request_publish_with_allowed_deps_(
  owner: HexString,
  expected_modules: String.String[],
  allowed_deps: AllowedDep[],
  bundle: U8[][],
  policy: U8,
  $c: AptosDataCache
): void {
  return $.aptos_framework_code_request_publish_with_allowed_deps(
    owner,
    expected_modules,
    allowed_deps,
    bundle,
    policy,
    $c
  );
}
export function upgrade_policy_arbitrary_($c: AptosDataCache): UpgradePolicy {
  return new UpgradePolicy({ policy: u8('0') }, new SimpleStructTag(UpgradePolicy));
}

export function upgrade_policy_compat_($c: AptosDataCache): UpgradePolicy {
  return new UpgradePolicy({ policy: u8('1') }, new SimpleStructTag(UpgradePolicy));
}

export function upgrade_policy_immutable_($c: AptosDataCache): UpgradePolicy {
  return new UpgradePolicy({ policy: u8('2') }, new SimpleStructTag(UpgradePolicy));
}

export function loadParsers(repo: AptosParserRepo) {
  repo.addParser('0x1::code::AllowedDep', AllowedDep.AllowedDepParser);
  repo.addParser('0x1::code::ModuleMetadata', ModuleMetadata.ModuleMetadataParser);
  repo.addParser('0x1::code::PackageDep', PackageDep.PackageDepParser);
  repo.addParser('0x1::code::PackageMetadata', PackageMetadata.PackageMetadataParser);
  repo.addParser('0x1::code::PackageRegistry', PackageRegistry.PackageRegistryParser);
  repo.addParser('0x1::code::UpgradePolicy', UpgradePolicy.UpgradePolicyParser);
}
export class App {
  constructor(public client: AptosClient, public repo: AptosParserRepo, public cache: AptosLocalCache) {}
  get moduleAddress() {
    {
      return moduleAddress;
    }
  }
  get moduleName() {
    {
      return moduleName;
    }
  }
  get AllowedDep() {
    return AllowedDep;
  }
  get ModuleMetadata() {
    return ModuleMetadata;
  }
  get PackageDep() {
    return PackageDep;
  }
  get PackageMetadata() {
    return PackageMetadata;
  }
  get PackageRegistry() {
    return PackageRegistry;
  }
  async loadPackageRegistry(owner: HexString, loadFull = true, fillCache = true) {
    const val = await PackageRegistry.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 UpgradePolicy() {
    return UpgradePolicy;
  }
  payload_publish_package_txn(
    metadata_serialized: U8[],
    code: U8[][],
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_publish_package_txn(metadata_serialized, code, isJSON);
  }
  async publish_package_txn(
    _account: AptosAccount,
    metadata_serialized: U8[],
    code: U8[][],
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_publish_package_txn(metadata_serialized, code, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
}