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 Account from "./account";
import * as Error from "./error";
import * as Event from "./event";
import * as Option from "./option";
import * as Optional_aggregator from "./optional_aggregator";
import * as Signer from "./signer";
import * as String from "./string";
import * as System_addresses from "./system_addresses";
import * as Type_info from "./type_info";
export const packageName = "AptosFramework";
export const moduleAddress = new HexString("0x1");
export const moduleName = "coin";

export const ECOIN_INFO_ADDRESS_MISMATCH : U64 = u64("1");
export const ECOIN_INFO_ALREADY_PUBLISHED : U64 = u64("2");
export const ECOIN_INFO_NOT_PUBLISHED : U64 = u64("3");
export const ECOIN_NAME_TOO_LONG : U64 = u64("12");
export const ECOIN_STORE_ALREADY_PUBLISHED : U64 = u64("4");
export const ECOIN_STORE_NOT_PUBLISHED : U64 = u64("5");
export const ECOIN_SUPPLY_UPGRADE_NOT_SUPPORTED : U64 = u64("11");
export const ECOIN_SYMBOL_TOO_LONG : U64 = u64("13");
export const EDESTRUCTION_OF_NONZERO_TOKEN : U64 = u64("7");
export const EFROZEN : U64 = u64("10");
export const EINSUFFICIENT_BALANCE : U64 = u64("6");
export const EZERO_COIN_AMOUNT : U64 = u64("9");
export const MAX_COIN_NAME_LENGTH : U64 = u64("32");
export const MAX_COIN_SYMBOL_LENGTH : U64 = u64("10");
export const MAX_U128 : U128 = u128("340282366920938463463374607431768211455");


export class BurnCapability 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "BurnCapability";
  static typeParameters: TypeParamDeclType[] = [
    { name: "CoinType", isPhantom: true }
  ];
  static fields: FieldDeclType[] = [
  ];

  constructor(proto: any, public typeTag: TypeTag) {

  }

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

  static makeTag($p: TypeTag[]): StructTag {
    return new StructTag(moduleAddress, moduleName, "BurnCapability", $p);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }

}

export class Coin 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "Coin";
  static typeParameters: TypeParamDeclType[] = [
    { name: "CoinType", isPhantom: true }
  ];
  static fields: FieldDeclType[] = [
  { name: "value", typeTag: AtomicTypeTag.U64 }];

  value: U64;

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

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

  static makeTag($p: TypeTag[]): StructTag {
    return new StructTag(moduleAddress, moduleName, "Coin", $p);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }

}

export class CoinInfo 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "CoinInfo";
  static typeParameters: TypeParamDeclType[] = [
    { name: "CoinType", isPhantom: true }
  ];
  static fields: FieldDeclType[] = [
  { name: "name", typeTag: new StructTag(new HexString("0x1"), "string", "String", []) },
  { name: "symbol", typeTag: new StructTag(new HexString("0x1"), "string", "String", []) },
  { name: "decimals", typeTag: AtomicTypeTag.U8 },
  { name: "supply", typeTag: new StructTag(new HexString("0x1"), "option", "Option", [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])]) }];

  name: String.String;
  symbol: String.String;
  decimals: U8;
  supply: Option.Option;

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

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

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

}

export class CoinStore 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "CoinStore";
  static typeParameters: TypeParamDeclType[] = [
    { name: "CoinType", isPhantom: true }
  ];
  static fields: FieldDeclType[] = [
  { name: "coin", typeTag: new StructTag(new HexString("0x1"), "coin", "Coin", [new $.TypeParamIdx(0)]) },
  { name: "frozen", typeTag: AtomicTypeTag.Bool },
  { name: "deposit_events", typeTag: new StructTag(new HexString("0x1"), "event", "EventHandle", [new StructTag(new HexString("0x1"), "coin", "DepositEvent", [])]) },
  { name: "withdraw_events", typeTag: new StructTag(new HexString("0x1"), "event", "EventHandle", [new StructTag(new HexString("0x1"), "coin", "WithdrawEvent", [])]) }];

  coin: Coin;
  frozen: boolean;
  deposit_events: Event.EventHandle;
  withdraw_events: Event.EventHandle;

  constructor(proto: any, public typeTag: TypeTag) {
    this.coin = proto['coin'] as Coin;
    this.frozen = proto['frozen'] as boolean;
    this.deposit_events = proto['deposit_events'] as Event.EventHandle;
    this.withdraw_events = proto['withdraw_events'] as Event.EventHandle;
  }

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

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

}

export class DepositEvent 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "DepositEvent";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "amount", typeTag: AtomicTypeTag.U64 }];

  amount: U64;

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

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

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

}

export class FreezeCapability 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "FreezeCapability";
  static typeParameters: TypeParamDeclType[] = [
    { name: "CoinType", isPhantom: true }
  ];
  static fields: FieldDeclType[] = [
  ];

  constructor(proto: any, public typeTag: TypeTag) {

  }

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

  static makeTag($p: TypeTag[]): StructTag {
    return new StructTag(moduleAddress, moduleName, "FreezeCapability", $p);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }

}

export class MintCapability 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "MintCapability";
  static typeParameters: TypeParamDeclType[] = [
    { name: "CoinType", isPhantom: true }
  ];
  static fields: FieldDeclType[] = [
  ];

  constructor(proto: any, public typeTag: TypeTag) {

  }

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

  static makeTag($p: TypeTag[]): StructTag {
    return new StructTag(moduleAddress, moduleName, "MintCapability", $p);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }

}

export class SupplyConfig 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "SupplyConfig";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "allow_upgrades", typeTag: AtomicTypeTag.Bool }];

  allow_upgrades: boolean;

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

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

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

}

export class WithdrawEvent 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "WithdrawEvent";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "amount", typeTag: AtomicTypeTag.U64 }];

  amount: U64;

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

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

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

}
export function allow_supply_upgrades_ (
  aptos_framework: HexString,
  allowed: boolean,
  $c: AptosDataCache,
): void {
  let allow_upgrades;
  System_addresses.assert_aptos_framework_(aptos_framework, $c);
  allow_upgrades = $c.borrow_global_mut<SupplyConfig>(new SimpleStructTag(SupplyConfig), new HexString("0x1")).allow_upgrades;
  $.set(allow_upgrades, allowed);
  return;
}

export function balance_ (
  owner: HexString,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): U64 {
  if (!is_account_registered_($.copy(owner), $c, [$p[0]])) {
    throw $.abortCode(Error.not_found_($.copy(ECOIN_STORE_NOT_PUBLISHED), $c));
  }
  return $.copy($c.borrow_global<CoinStore>(new SimpleStructTag(CoinStore, [$p[0]]), $.copy(owner)).coin.value);
}

export function burn_ (
  coin: Coin,
  _cap: BurnCapability,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  let maybe_supply, supply;
  let { value: amount } = coin;
  if (!($.copy(amount)).gt(u64("0"))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EZERO_COIN_AMOUNT), $c));
  }
  maybe_supply = $c.borrow_global_mut<CoinInfo>(new SimpleStructTag(CoinInfo, [$p[0]]), coin_address_($c, [$p[0]])).supply;
  if (Option.is_some_(maybe_supply, $c, [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])])) {
    supply = Option.borrow_mut_(maybe_supply, $c, [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])]);
    Optional_aggregator.sub_(supply, u128($.copy(amount)), $c);
  }
  else{
  }
  return;
}

export function burn_from_ (
  account_addr: HexString,
  amount: U64,
  burn_cap: BurnCapability,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  let coin_store, coin_to_burn;
  if (($.copy(amount)).eq((u64("0")))) {
    return;
  }
  else{
  }
  coin_store = $c.borrow_global_mut<CoinStore>(new SimpleStructTag(CoinStore, [$p[0]]), $.copy(account_addr));
  coin_to_burn = extract_(coin_store.coin, $.copy(amount), $c, [$p[0]]);
  burn_(coin_to_burn, burn_cap, $c, [$p[0]]);
  return;
}

export function coin_address_ (
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): HexString {
  let type_info;
  type_info = Type_info.type_of_($c, [$p[0]]);
  return Type_info.account_address_(type_info, $c);
}

export function decimals_ (
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): U8 {
  return $.copy($c.borrow_global<CoinInfo>(new SimpleStructTag(CoinInfo, [$p[0]]), coin_address_($c, [$p[0]])).decimals);
}

export function deposit_ (
  account_addr: HexString,
  coin: Coin,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  let coin_store;
  if (!is_account_registered_($.copy(account_addr), $c, [$p[0]])) {
    throw $.abortCode(Error.not_found_($.copy(ECOIN_STORE_NOT_PUBLISHED), $c));
  }
  coin_store = $c.borrow_global_mut<CoinStore>(new SimpleStructTag(CoinStore, [$p[0]]), $.copy(account_addr));
  if (!!$.copy(coin_store.frozen)) {
    throw $.abortCode(Error.permission_denied_($.copy(EFROZEN), $c));
  }
  Event.emit_event_(coin_store.deposit_events, new DepositEvent({ amount: $.copy(coin.value) }, new SimpleStructTag(DepositEvent)), $c, [new SimpleStructTag(DepositEvent)]);
  merge_(coin_store.coin, coin, $c, [$p[0]]);
  return;
}

export function destroy_burn_cap_ (
  burn_cap: BurnCapability,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  $.copy(burn_cap);
  return;
}

export function destroy_freeze_cap_ (
  freeze_cap: FreezeCapability,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  $.copy(freeze_cap);
  return;
}

export function destroy_mint_cap_ (
  mint_cap: MintCapability,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  $.copy(mint_cap);
  return;
}

export function destroy_zero_ (
  zero_coin: Coin,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  let { value: value } = zero_coin;
  if (!($.copy(value)).eq((u64("0")))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EDESTRUCTION_OF_NONZERO_TOKEN), $c));
  }
  return;
}

export function extract_ (
  coin: Coin,
  amount: U64,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): Coin {
  if (!($.copy(coin.value)).ge($.copy(amount))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINSUFFICIENT_BALANCE), $c));
  }
  coin.value = ($.copy(coin.value)).sub($.copy(amount));
  return new Coin({ value: $.copy(amount) }, new SimpleStructTag(Coin, [$p[0]]));
}

export function extract_all_ (
  coin: Coin,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): Coin {
  let total_value;
  total_value = $.copy(coin.value);
  coin.value = u64("0");
  return new Coin({ value: $.copy(total_value) }, new SimpleStructTag(Coin, [$p[0]]));
}

export function freeze_coin_store_ (
  account_addr: HexString,
  _freeze_cap: FreezeCapability,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  let coin_store;
  coin_store = $c.borrow_global_mut<CoinStore>(new SimpleStructTag(CoinStore, [$p[0]]), $.copy(account_addr));
  coin_store.frozen = true;
  return;
}

export function initialize_ (
  account: HexString,
  name: String.String,
  symbol: String.String,
  decimals: U8,
  monitor_supply: boolean,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): [BurnCapability, FreezeCapability, MintCapability] {
  return initialize_internal_(account, $.copy(name), $.copy(symbol), $.copy(decimals), monitor_supply, false, $c, [$p[0]]);
}

export function initialize_internal_ (
  account: HexString,
  name: String.String,
  symbol: String.String,
  decimals: U8,
  monitor_supply: boolean,
  parallelizable: boolean,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): [BurnCapability, FreezeCapability, MintCapability] {
  let temp$1, temp$2, temp$3, temp$4, account_addr, coin_info;
  account_addr = Signer.address_of_(account, $c);
  if (!((coin_address_($c, [$p[0]])).hex() === ($.copy(account_addr)).hex())) {
    throw $.abortCode(Error.invalid_argument_($.copy(ECOIN_INFO_ADDRESS_MISMATCH), $c));
  }
  if (!!$c.exists(new SimpleStructTag(CoinInfo, [$p[0]]), $.copy(account_addr))) {
    throw $.abortCode(Error.already_exists_($.copy(ECOIN_INFO_ALREADY_PUBLISHED), $c));
  }
  if (!(String.length_(name, $c)).le($.copy(MAX_COIN_NAME_LENGTH))) {
    throw $.abortCode(Error.invalid_argument_($.copy(ECOIN_NAME_TOO_LONG), $c));
  }
  if (!(String.length_(symbol, $c)).le($.copy(MAX_COIN_SYMBOL_LENGTH))) {
    throw $.abortCode(Error.invalid_argument_($.copy(ECOIN_SYMBOL_TOO_LONG), $c));
  }
  temp$4 = $.copy(name);
  temp$3 = $.copy(symbol);
  temp$2 = $.copy(decimals);
  if (monitor_supply) {
    temp$1 = Option.some_(Optional_aggregator.new___($.copy(MAX_U128), parallelizable, $c), $c, [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])]);
  }
  else{
    temp$1 = Option.none_($c, [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])]);
  }
  coin_info = new CoinInfo({ name: temp$4, symbol: temp$3, decimals: temp$2, supply: temp$1 }, new SimpleStructTag(CoinInfo, [$p[0]]));
  $c.move_to(new SimpleStructTag(CoinInfo, [$p[0]]), account, coin_info);
  return [new BurnCapability({  }, new SimpleStructTag(BurnCapability, [$p[0]])), new FreezeCapability({  }, new SimpleStructTag(FreezeCapability, [$p[0]])), new MintCapability({  }, new SimpleStructTag(MintCapability, [$p[0]]))];
}

export function initialize_supply_config_ (
  aptos_framework: HexString,
  $c: AptosDataCache,
): void {
  System_addresses.assert_aptos_framework_(aptos_framework, $c);
  $c.move_to(new SimpleStructTag(SupplyConfig), aptos_framework, new SupplyConfig({ allow_upgrades: false }, new SimpleStructTag(SupplyConfig)));
  return;
}

export function initialize_with_parallelizable_supply_ (
  account: HexString,
  name: String.String,
  symbol: String.String,
  decimals: U8,
  monitor_supply: boolean,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): [BurnCapability, FreezeCapability, MintCapability] {
  System_addresses.assert_aptos_framework_(account, $c);
  return initialize_internal_(account, $.copy(name), $.copy(symbol), $.copy(decimals), monitor_supply, true, $c, [$p[0]]);
}

export function is_account_registered_ (
  account_addr: HexString,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): boolean {
  return $c.exists(new SimpleStructTag(CoinStore, [$p[0]]), $.copy(account_addr));
}

export function is_coin_initialized_ (
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): boolean {
  return $c.exists(new SimpleStructTag(CoinInfo, [$p[0]]), coin_address_($c, [$p[0]]));
}

export function merge_ (
  dst_coin: Coin,
  source_coin: Coin,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  ;
  dst_coin.value = ($.copy(dst_coin.value)).add($.copy(source_coin.value));
  source_coin;
  return;
}

export function mint_ (
  amount: U64,
  _cap: MintCapability,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): Coin {
  let maybe_supply, supply;
  if (($.copy(amount)).eq((u64("0")))) {
    return zero_($c, [$p[0]]);
  }
  else{
  }
  maybe_supply = $c.borrow_global_mut<CoinInfo>(new SimpleStructTag(CoinInfo, [$p[0]]), coin_address_($c, [$p[0]])).supply;
  if (Option.is_some_(maybe_supply, $c, [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])])) {
    supply = Option.borrow_mut_(maybe_supply, $c, [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])]);
    Optional_aggregator.add_(supply, u128($.copy(amount)), $c);
  }
  else{
  }
  return new Coin({ value: $.copy(amount) }, new SimpleStructTag(Coin, [$p[0]]));
}

export function name_ (
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): String.String {
  return $.copy($c.borrow_global<CoinInfo>(new SimpleStructTag(CoinInfo, [$p[0]]), coin_address_($c, [$p[0]])).name);
}

export function register_ (
  account: HexString,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  let account_addr, coin_store;
  account_addr = Signer.address_of_(account, $c);
  if (!!is_account_registered_($.copy(account_addr), $c, [$p[0]])) {
    throw $.abortCode(Error.already_exists_($.copy(ECOIN_STORE_ALREADY_PUBLISHED), $c));
  }
  Account.register_coin_($.copy(account_addr), $c, [$p[0]]);
  coin_store = new CoinStore({ coin: new Coin({ value: u64("0") }, new SimpleStructTag(Coin, [$p[0]])), frozen: false, deposit_events: Account.new_event_handle_(account, $c, [new SimpleStructTag(DepositEvent)]), withdraw_events: Account.new_event_handle_(account, $c, [new SimpleStructTag(WithdrawEvent)]) }, new SimpleStructTag(CoinStore, [$p[0]]));
  $c.move_to(new SimpleStructTag(CoinStore, [$p[0]]), account, coin_store);
  return;
}

export function supply_ (
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): Option.Option {
  let temp$1, maybe_supply, supply, value;
  maybe_supply = $c.borrow_global<CoinInfo>(new SimpleStructTag(CoinInfo, [$p[0]]), coin_address_($c, [$p[0]])).supply;
  if (Option.is_some_(maybe_supply, $c, [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])])) {
    supply = Option.borrow_(maybe_supply, $c, [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])]);
    value = Optional_aggregator.read_(supply, $c);
    temp$1 = Option.some_($.copy(value), $c, [AtomicTypeTag.U128]);
  }
  else{
    temp$1 = Option.none_($c, [AtomicTypeTag.U128]);
  }
  return temp$1;
}

export function symbol_ (
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): String.String {
  return $.copy($c.borrow_global<CoinInfo>(new SimpleStructTag(CoinInfo, [$p[0]]), coin_address_($c, [$p[0]])).symbol);
}

export function transfer_ (
  from: HexString,
  to: HexString,
  amount: U64,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  let coin;
  coin = withdraw_(from, $.copy(amount), $c, [$p[0]]);
  deposit_($.copy(to), coin, $c, [$p[0]]);
  return;
}


export function buildPayload_transfer (
  to: HexString,
  amount: U64,
  $p: TypeTag[], /* <CoinType>*/
  isJSON = false,
): TxnBuilderTypes.TransactionPayloadEntryFunction
   | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = $p.map(t=>$.getTypeTagFullname(t));
  return $.buildPayload(
    new HexString("0x1"),
    "coin",
    "transfer",
    typeParamStrings,
    [
      to,
      amount,
    ],
    isJSON,
  );

}
export function unfreeze_coin_store_ (
  account_addr: HexString,
  _freeze_cap: FreezeCapability,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  let coin_store;
  coin_store = $c.borrow_global_mut<CoinStore>(new SimpleStructTag(CoinStore, [$p[0]]), $.copy(account_addr));
  coin_store.frozen = false;
  return;
}

export function upgrade_supply_ (
  account: HexString,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): void {
  let account_addr, maybe_supply, supply;
  account_addr = Signer.address_of_(account, $c);
  if (!((coin_address_($c, [$p[0]])).hex() === ($.copy(account_addr)).hex())) {
    throw $.abortCode(Error.invalid_argument_($.copy(ECOIN_INFO_ADDRESS_MISMATCH), $c));
  }
  if (!$.copy($c.borrow_global_mut<SupplyConfig>(new SimpleStructTag(SupplyConfig), new HexString("0x1")).allow_upgrades)) {
    throw $.abortCode(Error.permission_denied_($.copy(ECOIN_SUPPLY_UPGRADE_NOT_SUPPORTED), $c));
  }
  maybe_supply = $c.borrow_global_mut<CoinInfo>(new SimpleStructTag(CoinInfo, [$p[0]]), $.copy(account_addr)).supply;
  if (Option.is_some_(maybe_supply, $c, [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])])) {
    supply = Option.borrow_mut_(maybe_supply, $c, [new StructTag(new HexString("0x1"), "optional_aggregator", "OptionalAggregator", [])]);
    if (!Optional_aggregator.is_parallelizable_(supply, $c)) {
      Optional_aggregator.switch_(supply, $c);
    }
    else{
    }
  }
  else{
  }
  return;
}


export function buildPayload_upgrade_supply (
  $p: TypeTag[], /* <CoinType>*/
  isJSON = false,
): TxnBuilderTypes.TransactionPayloadEntryFunction
   | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = $p.map(t=>$.getTypeTagFullname(t));
  return $.buildPayload(
    new HexString("0x1"),
    "coin",
    "upgrade_supply",
    typeParamStrings,
    [],
    isJSON,
  );

}
export function value_ (
  coin: Coin,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): U64 {
  return $.copy(coin.value);
}

export function withdraw_ (
  account: HexString,
  amount: U64,
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): Coin {
  let account_addr, coin_store;
  account_addr = Signer.address_of_(account, $c);
  if (!is_account_registered_($.copy(account_addr), $c, [$p[0]])) {
    throw $.abortCode(Error.not_found_($.copy(ECOIN_STORE_NOT_PUBLISHED), $c));
  }
  coin_store = $c.borrow_global_mut<CoinStore>(new SimpleStructTag(CoinStore, [$p[0]]), $.copy(account_addr));
  if (!!$.copy(coin_store.frozen)) {
    throw $.abortCode(Error.permission_denied_($.copy(EFROZEN), $c));
  }
  Event.emit_event_(coin_store.withdraw_events, new WithdrawEvent({ amount: $.copy(amount) }, new SimpleStructTag(WithdrawEvent)), $c, [new SimpleStructTag(WithdrawEvent)]);
  return extract_(coin_store.coin, $.copy(amount), $c, [$p[0]]);
}

export function zero_ (
  $c: AptosDataCache,
  $p: TypeTag[], /* <CoinType>*/
): Coin {
  return new Coin({ value: u64("0") }, new SimpleStructTag(Coin, [$p[0]]));
}

export function loadParsers(repo: AptosParserRepo) {
  repo.addParser("0x1::coin::BurnCapability", BurnCapability.BurnCapabilityParser);
  repo.addParser("0x1::coin::Coin", Coin.CoinParser);
  repo.addParser("0x1::coin::CoinInfo", CoinInfo.CoinInfoParser);
  repo.addParser("0x1::coin::CoinStore", CoinStore.CoinStoreParser);
  repo.addParser("0x1::coin::DepositEvent", DepositEvent.DepositEventParser);
  repo.addParser("0x1::coin::FreezeCapability", FreezeCapability.FreezeCapabilityParser);
  repo.addParser("0x1::coin::MintCapability", MintCapability.MintCapabilityParser);
  repo.addParser("0x1::coin::SupplyConfig", SupplyConfig.SupplyConfigParser);
  repo.addParser("0x1::coin::WithdrawEvent", WithdrawEvent.WithdrawEventParser);
}
export class App {
  constructor(
    public client: AptosClient,
    public repo: AptosParserRepo,
    public cache: AptosLocalCache,
  ) {
  }
  get moduleAddress() {{ return moduleAddress; }}
  get moduleName() {{ return moduleName; }}
  get BurnCapability() { return BurnCapability; }
  get Coin() { return Coin; }
  get CoinInfo() { return CoinInfo; }
  async loadCoinInfo(
    owner: HexString,
    $p: TypeTag[], /* <CoinType> */
    loadFull=true,
    fillCache=true,
  ) {
    const val = await CoinInfo.load(this.repo, this.client, owner, $p);
    if (loadFull) {
      await val.loadFullState(this);
    }
    if (fillCache) {
      this.cache.set(val.typeTag, owner, val);
    }
    return val;
  }
  get CoinStore() { return CoinStore; }
  async loadCoinStore(
    owner: HexString,
    $p: TypeTag[], /* <CoinType> */
    loadFull=true,
    fillCache=true,
  ) {
    const val = await CoinStore.load(this.repo, this.client, owner, $p);
    if (loadFull) {
      await val.loadFullState(this);
    }
    if (fillCache) {
      this.cache.set(val.typeTag, owner, val);
    }
    return val;
  }
  get DepositEvent() { return DepositEvent; }
  get FreezeCapability() { return FreezeCapability; }
  get MintCapability() { return MintCapability; }
  get SupplyConfig() { return SupplyConfig; }
  async loadSupplyConfig(
    owner: HexString,
    loadFull=true,
    fillCache=true,
  ) {
    const val = await SupplyConfig.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 WithdrawEvent() { return WithdrawEvent; }
  payload_transfer(
    to: HexString,
    amount: U64,
    $p: TypeTag[], /* <CoinType>*/
    isJSON = false,
  ): TxnBuilderTypes.TransactionPayloadEntryFunction
        | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_transfer(to, amount, $p, isJSON);
  }
  async transfer(
    _account: AptosAccount,
    to: HexString,
    amount: U64,
    $p: TypeTag[], /* <CoinType>*/
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_transfer(to, amount, $p, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_upgrade_supply(
    $p: TypeTag[], /* <CoinType>*/
    isJSON = false,
  ): TxnBuilderTypes.TransactionPayloadEntryFunction
        | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_upgrade_supply($p, isJSON);
  }
  async upgrade_supply(
    _account: AptosAccount,
    $p: TypeTag[], /* <CoinType>*/
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_upgrade_supply($p, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
}