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 Aptos_account from './aptos_account';
import * as Bcs from './bcs';
import * as Coin from './coin';
import * as Error from './error';
import * as Event from './event';
import * as Fixed_point32 from './fixed_point32';
import * as Math64 from './math64';
import * as Pool_u64 from './pool_u64';
import * as Signer from './signer';
import * as Simple_map from './simple_map';
import * as Stake from './stake';
import * as Staking_contract from './staking_contract';
import * as String from './string';
import * as System_addresses from './system_addresses';
import * as Timestamp from './timestamp';
import * as Vector from './vector';
export const packageName = 'AptosFramework';
export const moduleAddress = new HexString('0x1');
export const moduleName = 'vesting';

export const EEMPTY_VESTING_SCHEDULE: U64 = u64('2');
export const EINVALID_WITHDRAWAL_ADDRESS: U64 = u64('1');
export const ENOT_ADMIN: U64 = u64('7');
export const ENO_SHAREHOLDERS: U64 = u64('4');
export const EPENDING_STAKE_FOUND: U64 = u64('11');
export const EPERMISSION_DENIED: U64 = u64('15');
export const EROLE_NOT_FOUND: U64 = u64('14');
export const ESHARES_LENGTH_MISMATCH: U64 = u64('5');
export const EVESTING_ACCOUNT_HAS_NO_ROLES: U64 = u64('13');
export const EVESTING_CONTRACT_NOT_ACTIVE: U64 = u64('8');
export const EVESTING_CONTRACT_NOT_FOUND: U64 = u64('10');
export const EVESTING_CONTRACT_STILL_ACTIVE: U64 = u64('9');
export const EVESTING_START_TOO_SOON: U64 = u64('6');
export const EZERO_GRANT: U64 = u64('12');
export const EZERO_VESTING_SCHEDULE_PERIOD: U64 = u64('3');
export const MAXIMUM_SHAREHOLDERS: U64 = u64('30');
export const ROLE_BENEFICIARY_RESETTER: U8[] = [
  u8('82'),
  u8('79'),
  u8('76'),
  u8('69'),
  u8('95'),
  u8('66'),
  u8('69'),
  u8('78'),
  u8('69'),
  u8('70'),
  u8('73'),
  u8('67'),
  u8('73'),
  u8('65'),
  u8('82'),
  u8('89'),
  u8('95'),
  u8('82'),
  u8('69'),
  u8('83'),
  u8('69'),
  u8('84'),
  u8('84'),
  u8('69'),
  u8('82')
];
export const VESTING_POOL_ACTIVE: U64 = u64('1');
export const VESTING_POOL_SALT: U8[] = [
  u8('97'),
  u8('112'),
  u8('116'),
  u8('111'),
  u8('115'),
  u8('95'),
  u8('102'),
  u8('114'),
  u8('97'),
  u8('109'),
  u8('101'),
  u8('119'),
  u8('111'),
  u8('114'),
  u8('107'),
  u8('58'),
  u8('58'),
  u8('118'),
  u8('101'),
  u8('115'),
  u8('116'),
  u8('105'),
  u8('110'),
  u8('103')
];
export const VESTING_POOL_TERMINATED: U64 = u64('2');

export class AdminStore {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'AdminStore';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'vesting_contracts', typeTag: new VectorTag(AtomicTypeTag.Address) },
    { name: 'nonce', typeTag: AtomicTypeTag.U64 },
    {
      name: 'create_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'vesting', 'CreateVestingContractEvent', [])
      ])
    }
  ];

  vesting_contracts: HexString[];
  nonce: U64;
  create_events: Event.EventHandle;

  constructor(proto: any, public typeTag: TypeTag) {
    this.vesting_contracts = proto['vesting_contracts'] as HexString[];
    this.nonce = proto['nonce'] as U64;
    this.create_events = proto['create_events'] as Event.EventHandle;
  }

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

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

export class AdminWithdrawEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'AdminWithdrawEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'admin', typeTag: AtomicTypeTag.Address },
    { name: 'vesting_contract_address', typeTag: AtomicTypeTag.Address },
    { name: 'amount', typeTag: AtomicTypeTag.U64 }
  ];

  admin: HexString;
  vesting_contract_address: HexString;
  amount: U64;

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

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

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

export class CreateVestingContractEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'CreateVestingContractEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'operator', typeTag: AtomicTypeTag.Address },
    { name: 'voter', typeTag: AtomicTypeTag.Address },
    { name: 'grant_amount', typeTag: AtomicTypeTag.U64 },
    { name: 'withdrawal_address', typeTag: AtomicTypeTag.Address },
    { name: 'vesting_contract_address', typeTag: AtomicTypeTag.Address },
    { name: 'staking_pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'commission_percentage', typeTag: AtomicTypeTag.U64 }
  ];

  operator: HexString;
  voter: HexString;
  grant_amount: U64;
  withdrawal_address: HexString;
  vesting_contract_address: HexString;
  staking_pool_address: HexString;
  commission_percentage: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.operator = proto['operator'] as HexString;
    this.voter = proto['voter'] as HexString;
    this.grant_amount = proto['grant_amount'] as U64;
    this.withdrawal_address = proto['withdrawal_address'] as HexString;
    this.vesting_contract_address = proto['vesting_contract_address'] as HexString;
    this.staking_pool_address = proto['staking_pool_address'] as HexString;
    this.commission_percentage = proto['commission_percentage'] as U64;
  }

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

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

export class DistributeEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'DistributeEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'admin', typeTag: AtomicTypeTag.Address },
    { name: 'vesting_contract_address', typeTag: AtomicTypeTag.Address },
    { name: 'amount', typeTag: AtomicTypeTag.U64 }
  ];

  admin: HexString;
  vesting_contract_address: HexString;
  amount: U64;

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

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

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

export class ResetLockupEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'ResetLockupEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'admin', typeTag: AtomicTypeTag.Address },
    { name: 'vesting_contract_address', typeTag: AtomicTypeTag.Address },
    { name: 'staking_pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'new_lockup_expiration_secs', typeTag: AtomicTypeTag.U64 }
  ];

  admin: HexString;
  vesting_contract_address: HexString;
  staking_pool_address: HexString;
  new_lockup_expiration_secs: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.admin = proto['admin'] as HexString;
    this.vesting_contract_address = proto['vesting_contract_address'] as HexString;
    this.staking_pool_address = proto['staking_pool_address'] as HexString;
    this.new_lockup_expiration_secs = proto['new_lockup_expiration_secs'] as U64;
  }

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

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

export class SetBeneficiaryEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'SetBeneficiaryEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'admin', typeTag: AtomicTypeTag.Address },
    { name: 'vesting_contract_address', typeTag: AtomicTypeTag.Address },
    { name: 'shareholder', typeTag: AtomicTypeTag.Address },
    { name: 'old_beneficiary', typeTag: AtomicTypeTag.Address },
    { name: 'new_beneficiary', typeTag: AtomicTypeTag.Address }
  ];

  admin: HexString;
  vesting_contract_address: HexString;
  shareholder: HexString;
  old_beneficiary: HexString;
  new_beneficiary: HexString;

  constructor(proto: any, public typeTag: TypeTag) {
    this.admin = proto['admin'] as HexString;
    this.vesting_contract_address = proto['vesting_contract_address'] as HexString;
    this.shareholder = proto['shareholder'] as HexString;
    this.old_beneficiary = proto['old_beneficiary'] as HexString;
    this.new_beneficiary = proto['new_beneficiary'] as HexString;
  }

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

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

export class StakingInfo {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'StakingInfo';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'operator', typeTag: AtomicTypeTag.Address },
    { name: 'voter', typeTag: AtomicTypeTag.Address },
    { name: 'commission_percentage', typeTag: AtomicTypeTag.U64 }
  ];

  pool_address: HexString;
  operator: HexString;
  voter: HexString;
  commission_percentage: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.pool_address = proto['pool_address'] as HexString;
    this.operator = proto['operator'] as HexString;
    this.voter = proto['voter'] as HexString;
    this.commission_percentage = proto['commission_percentage'] as U64;
  }

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

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

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

  admin: HexString;
  vesting_contract_address: HexString;

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

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

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

export class UnlockRewardsEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'UnlockRewardsEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'admin', typeTag: AtomicTypeTag.Address },
    { name: 'vesting_contract_address', typeTag: AtomicTypeTag.Address },
    { name: 'staking_pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'amount', typeTag: AtomicTypeTag.U64 }
  ];

  admin: HexString;
  vesting_contract_address: HexString;
  staking_pool_address: HexString;
  amount: U64;

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

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

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

export class UpdateOperatorEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'UpdateOperatorEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'admin', typeTag: AtomicTypeTag.Address },
    { name: 'vesting_contract_address', typeTag: AtomicTypeTag.Address },
    { name: 'staking_pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'old_operator', typeTag: AtomicTypeTag.Address },
    { name: 'new_operator', typeTag: AtomicTypeTag.Address },
    { name: 'commission_percentage', typeTag: AtomicTypeTag.U64 }
  ];

  admin: HexString;
  vesting_contract_address: HexString;
  staking_pool_address: HexString;
  old_operator: HexString;
  new_operator: HexString;
  commission_percentage: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.admin = proto['admin'] as HexString;
    this.vesting_contract_address = proto['vesting_contract_address'] as HexString;
    this.staking_pool_address = proto['staking_pool_address'] as HexString;
    this.old_operator = proto['old_operator'] as HexString;
    this.new_operator = proto['new_operator'] as HexString;
    this.commission_percentage = proto['commission_percentage'] as U64;
  }

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

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

export class UpdateVoterEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'UpdateVoterEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'admin', typeTag: AtomicTypeTag.Address },
    { name: 'vesting_contract_address', typeTag: AtomicTypeTag.Address },
    { name: 'staking_pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'old_voter', typeTag: AtomicTypeTag.Address },
    { name: 'new_voter', typeTag: AtomicTypeTag.Address }
  ];

  admin: HexString;
  vesting_contract_address: HexString;
  staking_pool_address: HexString;
  old_voter: HexString;
  new_voter: HexString;

  constructor(proto: any, public typeTag: TypeTag) {
    this.admin = proto['admin'] as HexString;
    this.vesting_contract_address = proto['vesting_contract_address'] as HexString;
    this.staking_pool_address = proto['staking_pool_address'] as HexString;
    this.old_voter = proto['old_voter'] as HexString;
    this.new_voter = proto['new_voter'] as HexString;
  }

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

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

export class VestEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'VestEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'admin', typeTag: AtomicTypeTag.Address },
    { name: 'vesting_contract_address', typeTag: AtomicTypeTag.Address },
    { name: 'staking_pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'period_vested', typeTag: AtomicTypeTag.U64 },
    { name: 'amount', typeTag: AtomicTypeTag.U64 }
  ];

  admin: HexString;
  vesting_contract_address: HexString;
  staking_pool_address: HexString;
  period_vested: U64;
  amount: U64;

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

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

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

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

  roles: Simple_map.SimpleMap;

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

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

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

export class VestingContract {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'VestingContract';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'state', typeTag: AtomicTypeTag.U64 },
    { name: 'admin', typeTag: AtomicTypeTag.Address },
    { name: 'grant_pool', typeTag: new StructTag(new HexString('0x1'), 'pool_u64', 'Pool', []) },
    {
      name: 'beneficiaries',
      typeTag: new StructTag(new HexString('0x1'), 'simple_map', 'SimpleMap', [
        AtomicTypeTag.Address,
        AtomicTypeTag.Address
      ])
    },
    { name: 'vesting_schedule', typeTag: new StructTag(new HexString('0x1'), 'vesting', 'VestingSchedule', []) },
    { name: 'withdrawal_address', typeTag: AtomicTypeTag.Address },
    { name: 'staking', typeTag: new StructTag(new HexString('0x1'), 'vesting', 'StakingInfo', []) },
    { name: 'remaining_grant', typeTag: AtomicTypeTag.U64 },
    { name: 'signer_cap', typeTag: new StructTag(new HexString('0x1'), 'account', 'SignerCapability', []) },
    {
      name: 'update_operator_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'vesting', 'UpdateOperatorEvent', [])
      ])
    },
    {
      name: 'update_voter_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'vesting', 'UpdateVoterEvent', [])
      ])
    },
    {
      name: 'reset_lockup_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'vesting', 'ResetLockupEvent', [])
      ])
    },
    {
      name: 'set_beneficiary_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'vesting', 'SetBeneficiaryEvent', [])
      ])
    },
    {
      name: 'unlock_rewards_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'vesting', 'UnlockRewardsEvent', [])
      ])
    },
    {
      name: 'vest_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'vesting', 'VestEvent', [])
      ])
    },
    {
      name: 'distribute_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'vesting', 'DistributeEvent', [])
      ])
    },
    {
      name: 'terminate_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'vesting', 'TerminateEvent', [])
      ])
    },
    {
      name: 'admin_withdraw_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'vesting', 'AdminWithdrawEvent', [])
      ])
    }
  ];

  state: U64;
  admin: HexString;
  grant_pool: Pool_u64.Pool;
  beneficiaries: Simple_map.SimpleMap;
  vesting_schedule: VestingSchedule;
  withdrawal_address: HexString;
  staking: StakingInfo;
  remaining_grant: U64;
  signer_cap: Account.SignerCapability;
  update_operator_events: Event.EventHandle;
  update_voter_events: Event.EventHandle;
  reset_lockup_events: Event.EventHandle;
  set_beneficiary_events: Event.EventHandle;
  unlock_rewards_events: Event.EventHandle;
  vest_events: Event.EventHandle;
  distribute_events: Event.EventHandle;
  terminate_events: Event.EventHandle;
  admin_withdraw_events: Event.EventHandle;

  constructor(proto: any, public typeTag: TypeTag) {
    this.state = proto['state'] as U64;
    this.admin = proto['admin'] as HexString;
    this.grant_pool = proto['grant_pool'] as Pool_u64.Pool;
    this.beneficiaries = proto['beneficiaries'] as Simple_map.SimpleMap;
    this.vesting_schedule = proto['vesting_schedule'] as VestingSchedule;
    this.withdrawal_address = proto['withdrawal_address'] as HexString;
    this.staking = proto['staking'] as StakingInfo;
    this.remaining_grant = proto['remaining_grant'] as U64;
    this.signer_cap = proto['signer_cap'] as Account.SignerCapability;
    this.update_operator_events = proto['update_operator_events'] as Event.EventHandle;
    this.update_voter_events = proto['update_voter_events'] as Event.EventHandle;
    this.reset_lockup_events = proto['reset_lockup_events'] as Event.EventHandle;
    this.set_beneficiary_events = proto['set_beneficiary_events'] as Event.EventHandle;
    this.unlock_rewards_events = proto['unlock_rewards_events'] as Event.EventHandle;
    this.vest_events = proto['vest_events'] as Event.EventHandle;
    this.distribute_events = proto['distribute_events'] as Event.EventHandle;
    this.terminate_events = proto['terminate_events'] as Event.EventHandle;
    this.admin_withdraw_events = proto['admin_withdraw_events'] as Event.EventHandle;
  }

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

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, VestingContract, typeParams);
    return result as unknown as VestingContract;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, VestingContract, typeParams);
    await result.loadFullState(app);
    return result as unknown as VestingContract;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'VestingContract', []);
  }
  async loadFullState(app: $.AppType) {
    await this.grant_pool.loadFullState(app);
    await this.beneficiaries.loadFullState(app);
    await this.vesting_schedule.loadFullState(app);
    await this.staking.loadFullState(app);
    await this.signer_cap.loadFullState(app);
    await this.update_operator_events.loadFullState(app);
    await this.update_voter_events.loadFullState(app);
    await this.reset_lockup_events.loadFullState(app);
    await this.set_beneficiary_events.loadFullState(app);
    await this.unlock_rewards_events.loadFullState(app);
    await this.vest_events.loadFullState(app);
    await this.distribute_events.loadFullState(app);
    await this.terminate_events.loadFullState(app);
    await this.admin_withdraw_events.loadFullState(app);
    this.__app = app;
  }
}

export class VestingSchedule {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'VestingSchedule';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    {
      name: 'schedule',
      typeTag: new VectorTag(new StructTag(new HexString('0x1'), 'fixed_point32', 'FixedPoint32', []))
    },
    { name: 'start_timestamp_secs', typeTag: AtomicTypeTag.U64 },
    { name: 'period_duration', typeTag: AtomicTypeTag.U64 },
    { name: 'last_vested_period', typeTag: AtomicTypeTag.U64 }
  ];

  schedule: Fixed_point32.FixedPoint32[];
  start_timestamp_secs: U64;
  period_duration: U64;
  last_vested_period: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.schedule = proto['schedule'] as Fixed_point32.FixedPoint32[];
    this.start_timestamp_secs = proto['start_timestamp_secs'] as U64;
    this.period_duration = proto['period_duration'] as U64;
    this.last_vested_period = proto['last_vested_period'] as U64;
  }

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

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'VestingSchedule', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}
export function admin_withdraw_(admin: HexString, contract_address: HexString, $c: AptosDataCache): void {
  let temp$2, temp$3, temp$4, temp$5, amount, coins, vesting_contract, vesting_contract__1;
  vesting_contract = $c.borrow_global<VestingContract>(new SimpleStructTag(VestingContract), $.copy(contract_address));
  if (!$.copy(vesting_contract.state).eq($.copy(VESTING_POOL_TERMINATED))) {
    throw $.abortCode(Error.invalid_state_($.copy(EVESTING_CONTRACT_STILL_ACTIVE), $c));
  }
  vesting_contract__1 = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  [temp$2, temp$3] = [admin, vesting_contract__1];
  verify_admin_(temp$2, temp$3, $c);
  [temp$4, temp$5] = [vesting_contract__1, $.copy(contract_address)];
  coins = withdraw_stake_(temp$4, temp$5, $c);
  amount = Coin.value_(coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
  if ($.copy(amount).eq(u64('0'))) {
    Coin.destroy_zero_(coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
    return;
  } else {
  }
  Coin.deposit_($.copy(vesting_contract__1.withdrawal_address), coins, $c, [
    new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
  ]);
  Event.emit_event_(
    vesting_contract__1.admin_withdraw_events,
    new AdminWithdrawEvent(
      {
        admin: $.copy(vesting_contract__1.admin),
        vesting_contract_address: $.copy(contract_address),
        amount: $.copy(amount)
      },
      new SimpleStructTag(AdminWithdrawEvent)
    ),
    $c,
    [new SimpleStructTag(AdminWithdrawEvent)]
  );
  return;
}

export function buildPayload_admin_withdraw(
  contract_address: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'vesting',
    'admin_withdraw',
    typeParamStrings,
    [contract_address],
    isJSON
  );
}
export function assert_active_vesting_contract_(contract_address: HexString, $c: AptosDataCache): void {
  let vesting_contract;
  assert_vesting_contract_exists_($.copy(contract_address), $c);
  vesting_contract = $c.borrow_global<VestingContract>(new SimpleStructTag(VestingContract), $.copy(contract_address));
  if (!$.copy(vesting_contract.state).eq($.copy(VESTING_POOL_ACTIVE))) {
    throw $.abortCode(Error.invalid_state_($.copy(EVESTING_CONTRACT_NOT_ACTIVE), $c));
  }
  return;
}

export function assert_vesting_contract_exists_(contract_address: HexString, $c: AptosDataCache): void {
  if (!$c.exists(new SimpleStructTag(VestingContract), $.copy(contract_address))) {
    throw $.abortCode(Error.not_found_($.copy(EVESTING_CONTRACT_NOT_FOUND), $c));
  }
  return;
}

export function beneficiary_(
  vesting_contract_address: HexString,
  shareholder: HexString,
  $c: AptosDataCache
): HexString {
  assert_vesting_contract_exists_($.copy(vesting_contract_address), $c);
  return get_beneficiary_(
    $c.borrow_global<VestingContract>(new SimpleStructTag(VestingContract), $.copy(vesting_contract_address)),
    $.copy(shareholder),
    $c
  );
}

export function create_vesting_contract_(
  admin: HexString,
  shareholders: HexString[],
  buy_ins: Simple_map.SimpleMap,
  vesting_schedule: VestingSchedule,
  withdrawal_address: HexString,
  operator: HexString,
  voter: HexString,
  commission_percentage: U64,
  contract_creation_seed: U8[],
  $c: AptosDataCache
): HexString {
  let temp$1,
    temp$2,
    temp$3,
    temp$4,
    temp$5,
    temp$6,
    temp$7,
    temp$8,
    admin_address,
    admin_store,
    buy_in,
    buy_in_amount,
    contract_address,
    contract_signer,
    contract_signer_cap,
    grant,
    grant_amount,
    grant_pool,
    i,
    len,
    pool_address,
    shareholder;
  if (!!System_addresses.is_reserved_address_($.copy(withdrawal_address), $c)) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINVALID_WITHDRAWAL_ADDRESS), $c));
  }
  Aptos_account.assert_account_is_registered_for_apt_($.copy(withdrawal_address), $c);
  if (!Vector.length_(shareholders, $c, [AtomicTypeTag.Address]).gt(u64('0'))) {
    throw $.abortCode(Error.invalid_argument_($.copy(ENO_SHAREHOLDERS), $c));
  }
  if (
    !Simple_map.length_(buy_ins, $c, [
      AtomicTypeTag.Address,
      new StructTag(new HexString('0x1'), 'coin', 'Coin', [
        new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
      ])
    ]).eq(Vector.length_(shareholders, $c, [AtomicTypeTag.Address]))
  ) {
    throw $.abortCode(Error.invalid_argument_($.copy(ESHARES_LENGTH_MISMATCH), $c));
  }
  grant = Coin.zero_($c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
  grant_amount = u64('0');
  grant_pool = Pool_u64.create_($.copy(MAXIMUM_SHAREHOLDERS), $c);
  len = Vector.length_(shareholders, $c, [AtomicTypeTag.Address]);
  i = u64('0');
  while ($.copy(i).lt($.copy(len))) {
    {
      shareholder = $.copy(Vector.borrow_(shareholders, $.copy(i), $c, [AtomicTypeTag.Address]));
      [, buy_in] = Simple_map.remove_(buy_ins, shareholder, $c, [
        AtomicTypeTag.Address,
        new StructTag(new HexString('0x1'), 'coin', 'Coin', [
          new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
        ])
      ]);
      buy_in_amount = Coin.value_(buy_in, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
      Coin.merge_(grant, buy_in, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
      Pool_u64.buy_in_(
        grant_pool,
        $.copy(Vector.borrow_(shareholders, $.copy(i), $c, [AtomicTypeTag.Address])),
        $.copy(buy_in_amount),
        $c
      );
      grant_amount = $.copy(grant_amount).add($.copy(buy_in_amount));
      i = $.copy(i).add(u64('1'));
    }
  }
  if (!$.copy(grant_amount).gt(u64('0'))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EZERO_GRANT), $c));
  }
  admin_address = Signer.address_of_(admin, $c);
  if (!$c.exists(new SimpleStructTag(AdminStore), $.copy(admin_address))) {
    $c.move_to(
      new SimpleStructTag(AdminStore),
      admin,
      new AdminStore(
        {
          vesting_contracts: Vector.empty_($c, [AtomicTypeTag.Address]),
          nonce: u64('0'),
          create_events: Account.new_event_handle_(admin, $c, [new SimpleStructTag(CreateVestingContractEvent)])
        },
        new SimpleStructTag(AdminStore)
      )
    );
  } else {
  }
  [contract_signer, contract_signer_cap] = create_vesting_contract_account_(admin, $.copy(contract_creation_seed), $c);
  pool_address = Staking_contract.create_staking_contract_with_coins_(
    contract_signer,
    $.copy(operator),
    $.copy(voter),
    grant,
    $.copy(commission_percentage),
    $.copy(contract_creation_seed),
    $c
  );
  contract_address = Signer.address_of_(contract_signer, $c);
  admin_store = $c.borrow_global_mut<AdminStore>(new SimpleStructTag(AdminStore), $.copy(admin_address));
  Vector.push_back_(admin_store.vesting_contracts, $.copy(contract_address), $c, [AtomicTypeTag.Address]);
  temp$8 = admin_store.create_events;
  temp$1 = $.copy(operator);
  temp$2 = $.copy(voter);
  temp$3 = $.copy(withdrawal_address);
  temp$4 = $.copy(grant_amount);
  temp$5 = $.copy(contract_address);
  temp$6 = $.copy(pool_address);
  temp$7 = $.copy(commission_percentage);
  Event.emit_event_(
    temp$8,
    new CreateVestingContractEvent(
      {
        operator: temp$1,
        voter: temp$2,
        grant_amount: temp$4,
        withdrawal_address: temp$3,
        vesting_contract_address: temp$5,
        staking_pool_address: temp$6,
        commission_percentage: temp$7
      },
      new SimpleStructTag(CreateVestingContractEvent)
    ),
    $c,
    [new SimpleStructTag(CreateVestingContractEvent)]
  );
  $c.move_to(
    new SimpleStructTag(VestingContract),
    contract_signer,
    new VestingContract(
      {
        state: $.copy(VESTING_POOL_ACTIVE),
        admin: $.copy(admin_address),
        grant_pool: grant_pool,
        beneficiaries: Simple_map.create_($c, [AtomicTypeTag.Address, AtomicTypeTag.Address]),
        vesting_schedule: $.copy(vesting_schedule),
        withdrawal_address: $.copy(withdrawal_address),
        staking: new StakingInfo(
          {
            pool_address: $.copy(pool_address),
            operator: $.copy(operator),
            voter: $.copy(voter),
            commission_percentage: $.copy(commission_percentage)
          },
          new SimpleStructTag(StakingInfo)
        ),
        remaining_grant: $.copy(grant_amount),
        signer_cap: contract_signer_cap,
        update_operator_events: Account.new_event_handle_(contract_signer, $c, [
          new SimpleStructTag(UpdateOperatorEvent)
        ]),
        update_voter_events: Account.new_event_handle_(contract_signer, $c, [new SimpleStructTag(UpdateVoterEvent)]),
        reset_lockup_events: Account.new_event_handle_(contract_signer, $c, [new SimpleStructTag(ResetLockupEvent)]),
        set_beneficiary_events: Account.new_event_handle_(contract_signer, $c, [
          new SimpleStructTag(SetBeneficiaryEvent)
        ]),
        unlock_rewards_events: Account.new_event_handle_(contract_signer, $c, [
          new SimpleStructTag(UnlockRewardsEvent)
        ]),
        vest_events: Account.new_event_handle_(contract_signer, $c, [new SimpleStructTag(VestEvent)]),
        distribute_events: Account.new_event_handle_(contract_signer, $c, [new SimpleStructTag(DistributeEvent)]),
        terminate_events: Account.new_event_handle_(contract_signer, $c, [new SimpleStructTag(TerminateEvent)]),
        admin_withdraw_events: Account.new_event_handle_(contract_signer, $c, [new SimpleStructTag(AdminWithdrawEvent)])
      },
      new SimpleStructTag(VestingContract)
    )
  );
  Simple_map.destroy_empty_(buy_ins, $c, [
    AtomicTypeTag.Address,
    new StructTag(new HexString('0x1'), 'coin', 'Coin', [
      new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
    ])
  ]);
  return $.copy(contract_address);
}

export function create_vesting_contract_account_(
  admin: HexString,
  contract_creation_seed: U8[],
  $c: AptosDataCache
): [HexString, Account.SignerCapability] {
  let temp$1, account_signer, admin_store, seed, signer_cap;
  admin_store = $c.borrow_global_mut<AdminStore>(new SimpleStructTag(AdminStore), Signer.address_of_(admin, $c));
  temp$1 = Signer.address_of_(admin, $c);
  seed = Bcs.to_bytes_(temp$1, $c, [AtomicTypeTag.Address]);
  Vector.append_(seed, Bcs.to_bytes_(admin_store.nonce, $c, [AtomicTypeTag.U64]), $c, [AtomicTypeTag.U8]);
  admin_store.nonce = $.copy(admin_store.nonce).add(u64('1'));
  Vector.append_(seed, $.copy(VESTING_POOL_SALT), $c, [AtomicTypeTag.U8]);
  Vector.append_(seed, $.copy(contract_creation_seed), $c, [AtomicTypeTag.U8]);
  [account_signer, signer_cap] = Account.create_resource_account_(admin, $.copy(seed), $c);
  Coin.register_(account_signer, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
  return [account_signer, signer_cap];
}

export function create_vesting_schedule_(
  schedule: Fixed_point32.FixedPoint32[],
  start_timestamp_secs: U64,
  period_duration: U64,
  $c: AptosDataCache
): VestingSchedule {
  if (
    !Vector.length_(schedule, $c, [new StructTag(new HexString('0x1'), 'fixed_point32', 'FixedPoint32', [])]).gt(
      u64('0')
    )
  ) {
    throw $.abortCode(Error.invalid_argument_($.copy(EEMPTY_VESTING_SCHEDULE), $c));
  }
  if (!$.copy(period_duration).gt(u64('0'))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EZERO_VESTING_SCHEDULE_PERIOD), $c));
  }
  if (!$.copy(start_timestamp_secs).ge(Timestamp.now_seconds_($c))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EVESTING_START_TOO_SOON), $c));
  }
  return new VestingSchedule(
    {
      schedule: $.copy(schedule),
      start_timestamp_secs: $.copy(start_timestamp_secs),
      period_duration: $.copy(period_duration),
      last_vested_period: u64('0')
    },
    new SimpleStructTag(VestingSchedule)
  );
}

export function distribute_(contract_address: HexString, $c: AptosDataCache): void {
  let temp$1,
    temp$2,
    temp$3,
    temp$4,
    temp$5,
    amount,
    coins,
    grant_pool,
    i,
    len,
    recipient_address,
    share_of_coins,
    shareholder,
    shareholders,
    shares,
    total_distribution_amount,
    vesting_contract;
  assert_active_vesting_contract_($.copy(contract_address), $c);
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  [temp$1, temp$2] = [vesting_contract, $.copy(contract_address)];
  coins = withdraw_stake_(temp$1, temp$2, $c);
  total_distribution_amount = Coin.value_(coins, $c, [
    new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
  ]);
  if ($.copy(total_distribution_amount).eq(u64('0'))) {
    Coin.destroy_zero_(coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
    return;
  } else {
  }
  grant_pool = vesting_contract.grant_pool;
  temp$3 = Pool_u64.shareholders_(grant_pool, $c);
  shareholders = temp$3;
  len = Vector.length_(shareholders, $c, [AtomicTypeTag.Address]);
  i = u64('0');
  while ($.copy(i).lt($.copy(len))) {
    {
      shareholder = $.copy(Vector.borrow_(shareholders, $.copy(i), $c, [AtomicTypeTag.Address]));
      shares = Pool_u64.shares_(grant_pool, $.copy(shareholder), $c);
      amount = Pool_u64.shares_to_amount_with_total_coins_(
        grant_pool,
        $.copy(shares),
        $.copy(total_distribution_amount),
        $c
      );
      share_of_coins = Coin.extract_(coins, $.copy(amount), $c, [
        new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
      ]);
      [temp$4, temp$5] = [vesting_contract, $.copy(shareholder)];
      recipient_address = get_beneficiary_(temp$4, temp$5, $c);
      Coin.deposit_($.copy(recipient_address), share_of_coins, $c, [
        new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
      ]);
      i = $.copy(i).add(u64('1'));
    }
  }
  if (Coin.value_(coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]).gt(u64('0'))) {
    Coin.deposit_($.copy(vesting_contract.withdrawal_address), coins, $c, [
      new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
    ]);
  } else {
    Coin.destroy_zero_(coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
  }
  Event.emit_event_(
    vesting_contract.distribute_events,
    new DistributeEvent(
      {
        admin: $.copy(vesting_contract.admin),
        vesting_contract_address: $.copy(contract_address),
        amount: $.copy(total_distribution_amount)
      },
      new SimpleStructTag(DistributeEvent)
    ),
    $c,
    [new SimpleStructTag(DistributeEvent)]
  );
  return;
}

export function buildPayload_distribute(
  contract_address: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(new HexString('0x1'), 'vesting', 'distribute', typeParamStrings, [contract_address], isJSON);
}
export function get_beneficiary_(contract: VestingContract, shareholder: HexString, $c: AptosDataCache): HexString {
  let temp$1;
  if (
    Simple_map.contains_key_(contract.beneficiaries, shareholder, $c, [AtomicTypeTag.Address, AtomicTypeTag.Address])
  ) {
    temp$1 = $.copy(
      Simple_map.borrow_(contract.beneficiaries, shareholder, $c, [AtomicTypeTag.Address, AtomicTypeTag.Address])
    );
  } else {
    temp$1 = $.copy(shareholder);
  }
  return temp$1;
}

export function get_role_holder_(contract_address: HexString, role: String.String, $c: AptosDataCache): HexString {
  let roles;
  if (!$c.exists(new SimpleStructTag(VestingAccountManagement), $.copy(contract_address))) {
    throw $.abortCode(Error.not_found_($.copy(EVESTING_ACCOUNT_HAS_NO_ROLES), $c));
  }
  roles = $c.borrow_global<VestingAccountManagement>(
    new SimpleStructTag(VestingAccountManagement),
    $.copy(contract_address)
  ).roles;
  if (
    !Simple_map.contains_key_(roles, role, $c, [
      new StructTag(new HexString('0x1'), 'string', 'String', []),
      AtomicTypeTag.Address
    ])
  ) {
    throw $.abortCode(Error.not_found_($.copy(EROLE_NOT_FOUND), $c));
  }
  return $.copy(
    Simple_map.borrow_(roles, role, $c, [
      new StructTag(new HexString('0x1'), 'string', 'String', []),
      AtomicTypeTag.Address
    ])
  );
}

export function get_vesting_account_signer_(
  admin: HexString,
  contract_address: HexString,
  $c: AptosDataCache
): HexString {
  let temp$1, temp$2, vesting_contract;
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  [temp$1, temp$2] = [admin, vesting_contract];
  verify_admin_(temp$1, temp$2, $c);
  return get_vesting_account_signer_internal_(vesting_contract, $c);
}

export function get_vesting_account_signer_internal_(vesting_contract: VestingContract, $c: AptosDataCache): HexString {
  return Account.create_signer_with_capability_(vesting_contract.signer_cap, $c);
}

export function operator_(vesting_contract_address: HexString, $c: AptosDataCache): HexString {
  assert_vesting_contract_exists_($.copy(vesting_contract_address), $c);
  return $.copy(
    $c.borrow_global<VestingContract>(new SimpleStructTag(VestingContract), $.copy(vesting_contract_address)).staking
      .operator
  );
}

export function operator_commission_percentage_(vesting_contract_address: HexString, $c: AptosDataCache): U64 {
  assert_vesting_contract_exists_($.copy(vesting_contract_address), $c);
  return $.copy(
    $c.borrow_global<VestingContract>(new SimpleStructTag(VestingContract), $.copy(vesting_contract_address)).staking
      .commission_percentage
  );
}

export function remaining_grant_(vesting_contract_address: HexString, $c: AptosDataCache): U64 {
  assert_vesting_contract_exists_($.copy(vesting_contract_address), $c);
  return $.copy(
    $c.borrow_global<VestingContract>(new SimpleStructTag(VestingContract), $.copy(vesting_contract_address))
      .remaining_grant
  );
}

export function reset_beneficiary_(
  account: HexString,
  contract_address: HexString,
  shareholder: HexString,
  $c: AptosDataCache
): void {
  let temp$1, temp$2, temp$3, addr, beneficiaries, vesting_contract;
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  addr = Signer.address_of_(account, $c);
  if ($.copy(addr).hex() === $.copy(vesting_contract.admin).hex()) {
    temp$1 = true;
  } else {
    temp$1 =
      $.copy(addr).hex() ===
      get_role_holder_($.copy(contract_address), String.utf8_($.copy(ROLE_BENEFICIARY_RESETTER), $c), $c).hex();
  }
  if (!temp$1) {
    throw $.abortCode(Error.permission_denied_($.copy(EPERMISSION_DENIED), $c));
  }
  beneficiaries = vesting_contract.beneficiaries;
  [temp$2, temp$3] = [beneficiaries, shareholder];
  if (Simple_map.contains_key_(temp$2, temp$3, $c, [AtomicTypeTag.Address, AtomicTypeTag.Address])) {
    Simple_map.remove_(beneficiaries, shareholder, $c, [AtomicTypeTag.Address, AtomicTypeTag.Address]);
  } else {
  }
  return;
}

export function buildPayload_reset_beneficiary(
  contract_address: HexString,
  shareholder: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'vesting',
    'reset_beneficiary',
    typeParamStrings,
    [contract_address, shareholder],
    isJSON
  );
}
export function reset_lockup_(admin: HexString, contract_address: HexString, $c: AptosDataCache): void {
  let temp$1, temp$2, temp$3, contract_signer, vesting_contract;
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  [temp$1, temp$2] = [admin, vesting_contract];
  verify_admin_(temp$1, temp$2, $c);
  temp$3 = get_vesting_account_signer_internal_(vesting_contract, $c);
  contract_signer = temp$3;
  Staking_contract.reset_lockup_(contract_signer, $.copy(vesting_contract.staking.operator), $c);
  Event.emit_event_(
    vesting_contract.reset_lockup_events,
    new ResetLockupEvent(
      {
        admin: $.copy(vesting_contract.admin),
        vesting_contract_address: $.copy(contract_address),
        staking_pool_address: $.copy(vesting_contract.staking.pool_address),
        new_lockup_expiration_secs: Stake.get_lockup_secs_($.copy(vesting_contract.staking.pool_address), $c)
      },
      new SimpleStructTag(ResetLockupEvent)
    ),
    $c,
    [new SimpleStructTag(ResetLockupEvent)]
  );
  return;
}

export function buildPayload_reset_lockup(
  contract_address: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(new HexString('0x1'), 'vesting', 'reset_lockup', typeParamStrings, [contract_address], isJSON);
}
export function set_beneficiary_(
  admin: HexString,
  contract_address: HexString,
  shareholder: HexString,
  new_beneficiary: HexString,
  $c: AptosDataCache
): void {
  let temp$1, temp$2, temp$3, temp$4, temp$5, temp$6, beneficiaries, beneficiary, old_beneficiary, vesting_contract;
  Aptos_account.assert_account_is_registered_for_apt_($.copy(new_beneficiary), $c);
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  [temp$1, temp$2] = [admin, vesting_contract];
  verify_admin_(temp$1, temp$2, $c);
  [temp$3, temp$4] = [vesting_contract, $.copy(shareholder)];
  old_beneficiary = get_beneficiary_(temp$3, temp$4, $c);
  beneficiaries = vesting_contract.beneficiaries;
  [temp$5, temp$6] = [beneficiaries, shareholder];
  if (Simple_map.contains_key_(temp$5, temp$6, $c, [AtomicTypeTag.Address, AtomicTypeTag.Address])) {
    beneficiary = Simple_map.borrow_mut_(beneficiaries, shareholder, $c, [
      AtomicTypeTag.Address,
      AtomicTypeTag.Address
    ]);
    $.set(beneficiary, $.copy(new_beneficiary));
  } else {
    Simple_map.add_(beneficiaries, $.copy(shareholder), $.copy(new_beneficiary), $c, [
      AtomicTypeTag.Address,
      AtomicTypeTag.Address
    ]);
  }
  Event.emit_event_(
    vesting_contract.set_beneficiary_events,
    new SetBeneficiaryEvent(
      {
        admin: $.copy(vesting_contract.admin),
        vesting_contract_address: $.copy(contract_address),
        shareholder: $.copy(shareholder),
        old_beneficiary: $.copy(old_beneficiary),
        new_beneficiary: $.copy(new_beneficiary)
      },
      new SimpleStructTag(SetBeneficiaryEvent)
    ),
    $c,
    [new SimpleStructTag(SetBeneficiaryEvent)]
  );
  return;
}

export function buildPayload_set_beneficiary(
  contract_address: HexString,
  shareholder: HexString,
  new_beneficiary: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'vesting',
    'set_beneficiary',
    typeParamStrings,
    [contract_address, shareholder, new_beneficiary],
    isJSON
  );
}
export function set_beneficiary_resetter_(
  admin: HexString,
  contract_address: HexString,
  beneficiary_resetter: HexString,
  $c: AptosDataCache
): void {
  set_management_role_(
    admin,
    $.copy(contract_address),
    String.utf8_($.copy(ROLE_BENEFICIARY_RESETTER), $c),
    $.copy(beneficiary_resetter),
    $c
  );
  return;
}

export function buildPayload_set_beneficiary_resetter(
  contract_address: HexString,
  beneficiary_resetter: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'vesting',
    'set_beneficiary_resetter',
    typeParamStrings,
    [contract_address, beneficiary_resetter],
    isJSON
  );
}
export function set_management_role_(
  admin: HexString,
  contract_address: HexString,
  role: String.String,
  role_holder: HexString,
  $c: AptosDataCache
): void {
  let temp$1, temp$2, temp$3, temp$4, temp$5, contract_signer, roles, vesting_contract;
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  [temp$1, temp$2] = [admin, vesting_contract];
  verify_admin_(temp$1, temp$2, $c);
  if (!$c.exists(new SimpleStructTag(VestingAccountManagement), $.copy(contract_address))) {
    temp$3 = get_vesting_account_signer_internal_(vesting_contract, $c);
    contract_signer = temp$3;
    $c.move_to(
      new SimpleStructTag(VestingAccountManagement),
      contract_signer,
      new VestingAccountManagement(
        {
          roles: Simple_map.create_($c, [
            new StructTag(new HexString('0x1'), 'string', 'String', []),
            AtomicTypeTag.Address
          ])
        },
        new SimpleStructTag(VestingAccountManagement)
      )
    );
  } else {
  }
  roles = $c.borrow_global_mut<VestingAccountManagement>(
    new SimpleStructTag(VestingAccountManagement),
    $.copy(contract_address)
  ).roles;
  [temp$4, temp$5] = [roles, role];
  if (
    Simple_map.contains_key_(temp$4, temp$5, $c, [
      new StructTag(new HexString('0x1'), 'string', 'String', []),
      AtomicTypeTag.Address
    ])
  ) {
    $.set(
      Simple_map.borrow_mut_(roles, role, $c, [
        new StructTag(new HexString('0x1'), 'string', 'String', []),
        AtomicTypeTag.Address
      ]),
      $.copy(role_holder)
    );
  } else {
    Simple_map.add_(roles, $.copy(role), $.copy(role_holder), $c, [
      new StructTag(new HexString('0x1'), 'string', 'String', []),
      AtomicTypeTag.Address
    ]);
  }
  return;
}

export function buildPayload_set_management_role(
  contract_address: HexString,
  role: String.String,
  role_holder: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'vesting',
    'set_management_role',
    typeParamStrings,
    [contract_address, role, role_holder],
    isJSON
  );
}
export function stake_pool_address_(vesting_contract_address: HexString, $c: AptosDataCache): HexString {
  assert_vesting_contract_exists_($.copy(vesting_contract_address), $c);
  return $.copy(
    $c.borrow_global<VestingContract>(new SimpleStructTag(VestingContract), $.copy(vesting_contract_address)).staking
      .pool_address
  );
}

export function terminate_vesting_contract_(admin: HexString, contract_address: HexString, $c: AptosDataCache): void {
  let temp$1, temp$2, temp$3, temp$4, active_stake, pending_active_stake, vesting_contract;
  assert_active_vesting_contract_($.copy(contract_address), $c);
  distribute_($.copy(contract_address), $c);
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  [temp$1, temp$2] = [admin, vesting_contract];
  verify_admin_(temp$1, temp$2, $c);
  [active_stake, , pending_active_stake] = Stake.get_stake_($.copy(vesting_contract.staking.pool_address), $c);
  if (!$.copy(pending_active_stake).eq(u64('0'))) {
    throw $.abortCode(Error.invalid_state_($.copy(EPENDING_STAKE_FOUND), $c));
  }
  vesting_contract.state = $.copy(VESTING_POOL_TERMINATED);
  vesting_contract.remaining_grant = u64('0');
  [temp$3, temp$4] = [vesting_contract, $.copy(active_stake)];
  unlock_stake_(temp$3, temp$4, $c);
  Event.emit_event_(
    vesting_contract.terminate_events,
    new TerminateEvent(
      { admin: $.copy(vesting_contract.admin), vesting_contract_address: $.copy(contract_address) },
      new SimpleStructTag(TerminateEvent)
    ),
    $c,
    [new SimpleStructTag(TerminateEvent)]
  );
  return;
}

export function buildPayload_terminate_vesting_contract(
  contract_address: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'vesting',
    'terminate_vesting_contract',
    typeParamStrings,
    [contract_address],
    isJSON
  );
}
export function unlock_rewards_(contract_address: HexString, $c: AptosDataCache): void {
  let temp$1, contract_signer, vesting_contract;
  assert_active_vesting_contract_($.copy(contract_address), $c);
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  temp$1 = get_vesting_account_signer_internal_(vesting_contract, $c);
  contract_signer = temp$1;
  Staking_contract.unlock_rewards_(contract_signer, $.copy(vesting_contract.staking.operator), $c);
  return;
}

export function buildPayload_unlock_rewards(
  contract_address: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'vesting',
    'unlock_rewards',
    typeParamStrings,
    [contract_address],
    isJSON
  );
}
export function unlock_stake_(vesting_contract: VestingContract, amount: U64, $c: AptosDataCache): void {
  let temp$1, contract_signer;
  temp$1 = get_vesting_account_signer_internal_(vesting_contract, $c);
  contract_signer = temp$1;
  Staking_contract.unlock_stake_(contract_signer, $.copy(vesting_contract.staking.operator), $.copy(amount), $c);
  return;
}

export function update_operator_(
  admin: HexString,
  contract_address: HexString,
  new_operator: HexString,
  commission_percentage: U64,
  $c: AptosDataCache
): void {
  let temp$1, temp$2, temp$3, contract_signer, old_operator, vesting_contract;
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  [temp$1, temp$2] = [admin, vesting_contract];
  verify_admin_(temp$1, temp$2, $c);
  temp$3 = get_vesting_account_signer_internal_(vesting_contract, $c);
  contract_signer = temp$3;
  old_operator = $.copy(vesting_contract.staking.operator);
  Staking_contract.switch_operator_(
    contract_signer,
    $.copy(old_operator),
    $.copy(new_operator),
    $.copy(commission_percentage),
    $c
  );
  vesting_contract.staking.operator = $.copy(new_operator);
  vesting_contract.staking.commission_percentage = $.copy(commission_percentage);
  Event.emit_event_(
    vesting_contract.update_operator_events,
    new UpdateOperatorEvent(
      {
        admin: $.copy(vesting_contract.admin),
        vesting_contract_address: $.copy(contract_address),
        staking_pool_address: $.copy(vesting_contract.staking.pool_address),
        old_operator: $.copy(old_operator),
        new_operator: $.copy(new_operator),
        commission_percentage: $.copy(commission_percentage)
      },
      new SimpleStructTag(UpdateOperatorEvent)
    ),
    $c,
    [new SimpleStructTag(UpdateOperatorEvent)]
  );
  return;
}

export function buildPayload_update_operator(
  contract_address: HexString,
  new_operator: HexString,
  commission_percentage: U64,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'vesting',
    'update_operator',
    typeParamStrings,
    [contract_address, new_operator, commission_percentage],
    isJSON
  );
}
export function update_operator_with_same_commission_(
  admin: HexString,
  contract_address: HexString,
  new_operator: HexString,
  $c: AptosDataCache
): void {
  let commission_percentage;
  commission_percentage = operator_commission_percentage_($.copy(contract_address), $c);
  update_operator_(admin, $.copy(contract_address), $.copy(new_operator), $.copy(commission_percentage), $c);
  return;
}

export function buildPayload_update_operator_with_same_commission(
  contract_address: HexString,
  new_operator: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'vesting',
    'update_operator_with_same_commission',
    typeParamStrings,
    [contract_address, new_operator],
    isJSON
  );
}
export function update_voter_(
  admin: HexString,
  contract_address: HexString,
  new_voter: HexString,
  $c: AptosDataCache
): void {
  let temp$1, temp$2, temp$3, contract_signer, old_voter, vesting_contract;
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  [temp$1, temp$2] = [admin, vesting_contract];
  verify_admin_(temp$1, temp$2, $c);
  temp$3 = get_vesting_account_signer_internal_(vesting_contract, $c);
  contract_signer = temp$3;
  old_voter = $.copy(vesting_contract.staking.voter);
  Staking_contract.update_voter_(contract_signer, $.copy(vesting_contract.staking.operator), $.copy(new_voter), $c);
  vesting_contract.staking.voter = $.copy(new_voter);
  Event.emit_event_(
    vesting_contract.update_voter_events,
    new UpdateVoterEvent(
      {
        admin: $.copy(vesting_contract.admin),
        vesting_contract_address: $.copy(contract_address),
        staking_pool_address: $.copy(vesting_contract.staking.pool_address),
        old_voter: $.copy(old_voter),
        new_voter: $.copy(new_voter)
      },
      new SimpleStructTag(UpdateVoterEvent)
    ),
    $c,
    [new SimpleStructTag(UpdateVoterEvent)]
  );
  return;
}

export function buildPayload_update_voter(
  contract_address: HexString,
  new_voter: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'vesting',
    'update_voter',
    typeParamStrings,
    [contract_address, new_voter],
    isJSON
  );
}
export function verify_admin_(admin: HexString, vesting_contract: VestingContract, $c: AptosDataCache): void {
  if (!(Signer.address_of_(admin, $c).hex() === $.copy(vesting_contract.admin).hex())) {
    throw $.abortCode(Error.unauthenticated_($.copy(ENOT_ADMIN), $c));
  }
  return;
}

export function vest_(contract_address: HexString, $c: AptosDataCache): void {
  let temp$1,
    temp$2,
    temp$3,
    last_completed_period,
    last_vested_period,
    next_period_to_vest,
    schedule,
    schedule_index,
    total_grant,
    vested_amount,
    vesting_contract,
    vesting_fraction,
    vesting_schedule;
  unlock_rewards_($.copy(contract_address), $c);
  vesting_contract = $c.borrow_global_mut<VestingContract>(
    new SimpleStructTag(VestingContract),
    $.copy(contract_address)
  );
  if ($.copy(vesting_contract.vesting_schedule.start_timestamp_secs).gt(Timestamp.now_seconds_($c))) {
    return;
  } else {
  }
  vesting_schedule = vesting_contract.vesting_schedule;
  last_vested_period = $.copy(vesting_schedule.last_vested_period);
  next_period_to_vest = $.copy(last_vested_period).add(u64('1'));
  last_completed_period = Timestamp.now_seconds_($c)
    .sub($.copy(vesting_schedule.start_timestamp_secs))
    .div($.copy(vesting_schedule.period_duration));
  if ($.copy(last_completed_period).lt($.copy(next_period_to_vest))) {
    return;
  } else {
  }
  schedule = vesting_schedule.schedule;
  schedule_index = $.copy(next_period_to_vest).sub(u64('1'));
  if (
    $.copy(schedule_index).lt(
      Vector.length_(schedule, $c, [new StructTag(new HexString('0x1'), 'fixed_point32', 'FixedPoint32', [])])
    )
  ) {
    temp$1 = $.copy(
      Vector.borrow_(schedule, $.copy(schedule_index), $c, [
        new StructTag(new HexString('0x1'), 'fixed_point32', 'FixedPoint32', [])
      ])
    );
  } else {
    temp$1 = $.copy(
      Vector.borrow_(
        schedule,
        Vector.length_(schedule, $c, [new StructTag(new HexString('0x1'), 'fixed_point32', 'FixedPoint32', [])]).sub(
          u64('1')
        ),
        $c,
        [new StructTag(new HexString('0x1'), 'fixed_point32', 'FixedPoint32', [])]
      )
    );
  }
  vesting_fraction = temp$1;
  total_grant = Pool_u64.total_coins_(vesting_contract.grant_pool, $c);
  vested_amount = Fixed_point32.multiply_u64_($.copy(total_grant), $.copy(vesting_fraction), $c);
  vested_amount = Math64.min_($.copy(vested_amount), $.copy(vesting_contract.remaining_grant), $c);
  vesting_contract.remaining_grant = $.copy(vesting_contract.remaining_grant).sub($.copy(vested_amount));
  vesting_schedule.last_vested_period = $.copy(next_period_to_vest);
  [temp$2, temp$3] = [vesting_contract, $.copy(vested_amount)];
  unlock_stake_(temp$2, temp$3, $c);
  Event.emit_event_(
    vesting_contract.vest_events,
    new VestEvent(
      {
        admin: $.copy(vesting_contract.admin),
        vesting_contract_address: $.copy(contract_address),
        staking_pool_address: $.copy(vesting_contract.staking.pool_address),
        period_vested: $.copy(next_period_to_vest),
        amount: $.copy(vested_amount)
      },
      new SimpleStructTag(VestEvent)
    ),
    $c,
    [new SimpleStructTag(VestEvent)]
  );
  return;
}

export function buildPayload_vest(
  contract_address: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(new HexString('0x1'), 'vesting', 'vest', typeParamStrings, [contract_address], isJSON);
}
export function vesting_contracts_(admin: HexString, $c: AptosDataCache): HexString[] {
  let temp$1;
  if (!$c.exists(new SimpleStructTag(AdminStore), $.copy(admin))) {
    temp$1 = Vector.empty_($c, [AtomicTypeTag.Address]);
  } else {
    temp$1 = $.copy($c.borrow_global<AdminStore>(new SimpleStructTag(AdminStore), $.copy(admin)).vesting_contracts);
  }
  return temp$1;
}

export function vesting_start_secs_(vesting_contract_address: HexString, $c: AptosDataCache): U64 {
  assert_vesting_contract_exists_($.copy(vesting_contract_address), $c);
  return $.copy(
    $c.borrow_global<VestingContract>(new SimpleStructTag(VestingContract), $.copy(vesting_contract_address))
      .vesting_schedule.start_timestamp_secs
  );
}

export function voter_(vesting_contract_address: HexString, $c: AptosDataCache): HexString {
  assert_vesting_contract_exists_($.copy(vesting_contract_address), $c);
  return $.copy(
    $c.borrow_global<VestingContract>(new SimpleStructTag(VestingContract), $.copy(vesting_contract_address)).staking
      .voter
  );
}

export function withdraw_stake_(
  vesting_contract: VestingContract,
  contract_address: HexString,
  $c: AptosDataCache
): Coin.Coin {
  let temp$1, contract_signer, withdrawn_coins;
  Staking_contract.distribute_($.copy(contract_address), $.copy(vesting_contract.staking.operator), $c);
  withdrawn_coins = Coin.balance_($.copy(contract_address), $c, [
    new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
  ]);
  temp$1 = get_vesting_account_signer_internal_(vesting_contract, $c);
  contract_signer = temp$1;
  return Coin.withdraw_(contract_signer, $.copy(withdrawn_coins), $c, [
    new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
  ]);
}

export function loadParsers(repo: AptosParserRepo) {
  repo.addParser('0x1::vesting::AdminStore', AdminStore.AdminStoreParser);
  repo.addParser('0x1::vesting::AdminWithdrawEvent', AdminWithdrawEvent.AdminWithdrawEventParser);
  repo.addParser(
    '0x1::vesting::CreateVestingContractEvent',
    CreateVestingContractEvent.CreateVestingContractEventParser
  );
  repo.addParser('0x1::vesting::DistributeEvent', DistributeEvent.DistributeEventParser);
  repo.addParser('0x1::vesting::ResetLockupEvent', ResetLockupEvent.ResetLockupEventParser);
  repo.addParser('0x1::vesting::SetBeneficiaryEvent', SetBeneficiaryEvent.SetBeneficiaryEventParser);
  repo.addParser('0x1::vesting::StakingInfo', StakingInfo.StakingInfoParser);
  repo.addParser('0x1::vesting::TerminateEvent', TerminateEvent.TerminateEventParser);
  repo.addParser('0x1::vesting::UnlockRewardsEvent', UnlockRewardsEvent.UnlockRewardsEventParser);
  repo.addParser('0x1::vesting::UpdateOperatorEvent', UpdateOperatorEvent.UpdateOperatorEventParser);
  repo.addParser('0x1::vesting::UpdateVoterEvent', UpdateVoterEvent.UpdateVoterEventParser);
  repo.addParser('0x1::vesting::VestEvent', VestEvent.VestEventParser);
  repo.addParser('0x1::vesting::VestingAccountManagement', VestingAccountManagement.VestingAccountManagementParser);
  repo.addParser('0x1::vesting::VestingContract', VestingContract.VestingContractParser);
  repo.addParser('0x1::vesting::VestingSchedule', VestingSchedule.VestingScheduleParser);
}
export class App {
  constructor(public client: AptosClient, public repo: AptosParserRepo, public cache: AptosLocalCache) {}
  get moduleAddress() {
    {
      return moduleAddress;
    }
  }
  get moduleName() {
    {
      return moduleName;
    }
  }
  get AdminStore() {
    return AdminStore;
  }
  async loadAdminStore(owner: HexString, loadFull = true, fillCache = true) {
    const val = await AdminStore.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 AdminWithdrawEvent() {
    return AdminWithdrawEvent;
  }
  get CreateVestingContractEvent() {
    return CreateVestingContractEvent;
  }
  get DistributeEvent() {
    return DistributeEvent;
  }
  get ResetLockupEvent() {
    return ResetLockupEvent;
  }
  get SetBeneficiaryEvent() {
    return SetBeneficiaryEvent;
  }
  get StakingInfo() {
    return StakingInfo;
  }
  get TerminateEvent() {
    return TerminateEvent;
  }
  get UnlockRewardsEvent() {
    return UnlockRewardsEvent;
  }
  get UpdateOperatorEvent() {
    return UpdateOperatorEvent;
  }
  get UpdateVoterEvent() {
    return UpdateVoterEvent;
  }
  get VestEvent() {
    return VestEvent;
  }
  get VestingAccountManagement() {
    return VestingAccountManagement;
  }
  async loadVestingAccountManagement(owner: HexString, loadFull = true, fillCache = true) {
    const val = await VestingAccountManagement.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 VestingContract() {
    return VestingContract;
  }
  async loadVestingContract(owner: HexString, loadFull = true, fillCache = true) {
    const val = await VestingContract.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 VestingSchedule() {
    return VestingSchedule;
  }
  payload_admin_withdraw(
    contract_address: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_admin_withdraw(contract_address, isJSON);
  }
  async admin_withdraw(
    _account: AptosAccount,
    contract_address: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_admin_withdraw(contract_address, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_distribute(
    contract_address: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_distribute(contract_address, isJSON);
  }
  async distribute(_account: AptosAccount, contract_address: HexString, option?: OptionTransaction, _isJSON = false) {
    const payload__ = buildPayload_distribute(contract_address, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_reset_beneficiary(
    contract_address: HexString,
    shareholder: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_reset_beneficiary(contract_address, shareholder, isJSON);
  }
  async reset_beneficiary(
    _account: AptosAccount,
    contract_address: HexString,
    shareholder: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_reset_beneficiary(contract_address, shareholder, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_reset_lockup(
    contract_address: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_reset_lockup(contract_address, isJSON);
  }
  async reset_lockup(_account: AptosAccount, contract_address: HexString, option?: OptionTransaction, _isJSON = false) {
    const payload__ = buildPayload_reset_lockup(contract_address, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_set_beneficiary(
    contract_address: HexString,
    shareholder: HexString,
    new_beneficiary: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_set_beneficiary(contract_address, shareholder, new_beneficiary, isJSON);
  }
  async set_beneficiary(
    _account: AptosAccount,
    contract_address: HexString,
    shareholder: HexString,
    new_beneficiary: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_set_beneficiary(contract_address, shareholder, new_beneficiary, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_set_beneficiary_resetter(
    contract_address: HexString,
    beneficiary_resetter: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_set_beneficiary_resetter(contract_address, beneficiary_resetter, isJSON);
  }
  async set_beneficiary_resetter(
    _account: AptosAccount,
    contract_address: HexString,
    beneficiary_resetter: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_set_beneficiary_resetter(contract_address, beneficiary_resetter, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_set_management_role(
    contract_address: HexString,
    role: String.String,
    role_holder: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_set_management_role(contract_address, role, role_holder, isJSON);
  }
  async set_management_role(
    _account: AptosAccount,
    contract_address: HexString,
    role: String.String,
    role_holder: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_set_management_role(contract_address, role, role_holder, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_terminate_vesting_contract(
    contract_address: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_terminate_vesting_contract(contract_address, isJSON);
  }
  async terminate_vesting_contract(
    _account: AptosAccount,
    contract_address: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_terminate_vesting_contract(contract_address, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_unlock_rewards(
    contract_address: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_unlock_rewards(contract_address, isJSON);
  }
  async unlock_rewards(
    _account: AptosAccount,
    contract_address: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_unlock_rewards(contract_address, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_update_operator(
    contract_address: HexString,
    new_operator: HexString,
    commission_percentage: U64,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_update_operator(contract_address, new_operator, commission_percentage, isJSON);
  }
  async update_operator(
    _account: AptosAccount,
    contract_address: HexString,
    new_operator: HexString,
    commission_percentage: U64,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_update_operator(contract_address, new_operator, commission_percentage, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_update_operator_with_same_commission(
    contract_address: HexString,
    new_operator: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_update_operator_with_same_commission(contract_address, new_operator, isJSON);
  }
  async update_operator_with_same_commission(
    _account: AptosAccount,
    contract_address: HexString,
    new_operator: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_update_operator_with_same_commission(contract_address, new_operator, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_update_voter(
    contract_address: HexString,
    new_voter: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_update_voter(contract_address, new_voter, isJSON);
  }
  async update_voter(
    _account: AptosAccount,
    contract_address: HexString,
    new_voter: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_update_voter(contract_address, new_voter, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_vest(
    contract_address: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_vest(contract_address, isJSON);
  }
  async vest(_account: AptosAccount, contract_address: HexString, option?: OptionTransaction, _isJSON = false) {
    const payload__ = buildPayload_vest(contract_address, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
}