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

export const EWRONG_SIZE : U64 = u64("2");
export const EZERO_PUBKEYS : U64 = u64("1");
export const PUBLIC_KEY_NUM_BYTES : U64 = u64("48");
export const RANDOM_PK : U8[] = [u8("138"), u8("83"), u8("231"), u8("174"), u8("82"), u8("112"), u8("227"), u8("231"), u8("101"), u8("205"), u8("138"), u8("64"), u8("50"), u8("194"), u8("231"), u8("124"), u8("111"), u8("126"), u8("135"), u8("164"), u8("78"), u8("187"), u8("133"), u8("191"), u8("40"), u8("164"), u8("215"), u8("134"), u8("85"), u8("101"), u8("105"), u8("143"), u8("151"), u8("83"), u8("70"), u8("113"), u8("66"), u8("98"), u8("249"), u8("228"), u8("124"), u8("111"), u8("62"), u8("13"), u8("93"), u8("149"), u8("22"), u8("96")];
export const RANDOM_SIGNATURE : U8[] = [u8("160"), u8("26"), u8("101"), u8("133"), u8("79"), u8("152"), u8("125"), u8("52"), u8("52"), u8("20"), u8("155"), u8("127"), u8("8"), u8("247"), u8("7"), u8("48"), u8("227"), u8("11"), u8("36"), u8("25"), u8("132"), u8("232"), u8("113"), u8("43"), u8("194"), u8("172"), u8("168"), u8("133"), u8("214"), u8("50"), u8("170"), u8("252"), u8("237"), u8("76"), u8("63"), u8("102"), u8("18"), u8("9"), u8("222"), u8("187"), u8("107"), u8("28"), u8("134"), u8("1"), u8("50"), u8("102"), u8("35"), u8("204"), u8("22"), u8("202"), u8("47"), u8("108"), u8("158"), u8("220"), u8("83"), u8("183"), u8("184"), u8("139"), u8("116"), u8("53"), u8("251"), u8("107"), u8("5"), u8("221"), u8("236"), u8("228"), u8("24"), u8("210"), u8("195"), u8("77"), u8("198"), u8("172"), u8("162"), u8("245"), u8("161"), u8("26"), u8("121"), u8("230"), u8("119"), u8("116"), u8("88"), u8("44"), u8("20"), u8("8"), u8("74"), u8("1"), u8("220"), u8("183"), u8("130"), u8("14"), u8("76"), u8("180"), u8("186"), u8("208"), u8("234"), u8("141")];
export const SIGNATURE_SIZE : U64 = u64("96");


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

  ];
  static fields: FieldDeclType[] = [
  { name: "bytes", typeTag: new VectorTag(AtomicTypeTag.U8) }];

  bytes: U8[];

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

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "bytes", typeTag: new VectorTag(AtomicTypeTag.U8) }];

  bytes: U8[];

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

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "bytes", typeTag: new VectorTag(AtomicTypeTag.U8) }];

  bytes: U8[];

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

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "bytes", typeTag: new VectorTag(AtomicTypeTag.U8) }];

  bytes: U8[];

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

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "bytes", typeTag: new VectorTag(AtomicTypeTag.U8) }];

  bytes: U8[];

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

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "bytes", typeTag: new VectorTag(AtomicTypeTag.U8) }];

  bytes: U8[];

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

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

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

}
export function aggr_or_multi_signature_from_bytes_ (
  bytes: U8[],
  $c: AptosDataCache,
): AggrOrMultiSignature {
  if (!(Vector.length_(bytes, $c, [AtomicTypeTag.U8])).eq(($.copy(SIGNATURE_SIZE)))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EWRONG_SIZE), $c));
  }
  return new AggrOrMultiSignature({ bytes: $.copy(bytes) }, new SimpleStructTag(AggrOrMultiSignature));
}

export function aggr_or_multi_signature_subgroup_check_ (
  signature: AggrOrMultiSignature,
  $c: AptosDataCache,
): boolean {
  return signature_subgroup_check_internal_($.copy(signature.bytes), $c);
}

export function aggr_or_multi_signature_to_bytes_ (
  sig: AggrOrMultiSignature,
  $c: AptosDataCache,
): U8[] {
  return $.copy(sig.bytes);
}

export function aggregate_pubkey_to_bytes_ (
  apk: AggrPublicKeysWithPoP,
  $c: AptosDataCache,
): U8[] {
  return $.copy(apk.bytes);
}

export function aggregate_pubkeys_ (
  public_keys: PublicKeyWithPoP[],
  $c: AptosDataCache,
): AggrPublicKeysWithPoP {
  let bytes, success;
  [bytes, success] = aggregate_pubkeys_internal_($.copy(public_keys), $c);
  if (!success) {
    throw $.abortCode(Error.invalid_argument_($.copy(EZERO_PUBKEYS), $c));
  }
  return new AggrPublicKeysWithPoP({ bytes: $.copy(bytes) }, new SimpleStructTag(AggrPublicKeysWithPoP));
}

export function aggregate_pubkeys_internal_ (
  public_keys: PublicKeyWithPoP[],
  $c: AptosDataCache,
): [U8[], boolean] {
  return $.aptos_std_bls12381_aggregate_pubkeys_internal(public_keys, $c);

}
export function aggregate_signatures_ (
  signatures: Signature[],
  $c: AptosDataCache,
): Option.Option {
  let temp$1, bytes, success;
  [bytes, success] = aggregate_signatures_internal_($.copy(signatures), $c);
  if (success) {
    temp$1 = Option.some_(new AggrOrMultiSignature({ bytes: $.copy(bytes) }, new SimpleStructTag(AggrOrMultiSignature)), $c, [new SimpleStructTag(AggrOrMultiSignature)]);
  }
  else{
    temp$1 = Option.none_($c, [new SimpleStructTag(AggrOrMultiSignature)]);
  }
  return temp$1;
}

export function aggregate_signatures_internal_ (
  signatures: Signature[],
  $c: AptosDataCache,
): [U8[], boolean] {
  return $.aptos_std_bls12381_aggregate_signatures_internal(signatures, $c);

}
export function proof_of_possession_from_bytes_ (
  bytes: U8[],
  $c: AptosDataCache,
): ProofOfPossession {
  return new ProofOfPossession({ bytes: $.copy(bytes) }, new SimpleStructTag(ProofOfPossession));
}

export function proof_of_possession_to_bytes_ (
  pop: ProofOfPossession,
  $c: AptosDataCache,
): U8[] {
  return $.copy(pop.bytes);
}

export function public_key_from_bytes_ (
  bytes: U8[],
  $c: AptosDataCache,
): Option.Option {
  let temp$1;
  if (validate_pubkey_internal_($.copy(bytes), $c)) {
    temp$1 = Option.some_(new PublicKey({ bytes: $.copy(bytes) }, new SimpleStructTag(PublicKey)), $c, [new SimpleStructTag(PublicKey)]);
  }
  else{
    temp$1 = Option.none_($c, [new SimpleStructTag(PublicKey)]);
  }
  return temp$1;
}

export function public_key_from_bytes_with_pop_ (
  pk_bytes: U8[],
  pop: ProofOfPossession,
  $c: AptosDataCache,
): Option.Option {
  let temp$1;
  if (verify_proof_of_possession_internal_($.copy(pk_bytes), $.copy(pop.bytes), $c)) {
    temp$1 = Option.some_(new PublicKeyWithPoP({ bytes: $.copy(pk_bytes) }, new SimpleStructTag(PublicKeyWithPoP)), $c, [new SimpleStructTag(PublicKeyWithPoP)]);
  }
  else{
    temp$1 = Option.none_($c, [new SimpleStructTag(PublicKeyWithPoP)]);
  }
  return temp$1;
}

export function public_key_to_bytes_ (
  pk: PublicKey,
  $c: AptosDataCache,
): U8[] {
  return $.copy(pk.bytes);
}

export function public_key_with_pop_to_bytes_ (
  pk: PublicKeyWithPoP,
  $c: AptosDataCache,
): U8[] {
  return $.copy(pk.bytes);
}

export function signature_from_bytes_ (
  bytes: U8[],
  $c: AptosDataCache,
): Signature {
  return new Signature({ bytes: $.copy(bytes) }, new SimpleStructTag(Signature));
}

export function signature_subgroup_check_ (
  signature: Signature,
  $c: AptosDataCache,
): boolean {
  return signature_subgroup_check_internal_($.copy(signature.bytes), $c);
}

export function signature_subgroup_check_internal_ (
  signature: U8[],
  $c: AptosDataCache,
): boolean {
  return $.aptos_std_bls12381_signature_subgroup_check_internal(signature, $c);

}
export function signature_to_bytes_ (
  sig: Signature,
  $c: AptosDataCache,
): U8[] {
  return $.copy(sig.bytes);
}

export function validate_pubkey_internal_ (
  public_key: U8[],
  $c: AptosDataCache,
): boolean {
  return $.aptos_std_bls12381_validate_pubkey_internal(public_key, $c);

}
export function verify_aggregate_signature_ (
  aggr_sig: AggrOrMultiSignature,
  public_keys: PublicKeyWithPoP[],
  messages: U8[][],
  $c: AptosDataCache,
): boolean {
  return verify_aggregate_signature_internal_($.copy(aggr_sig.bytes), $.copy(public_keys), $.copy(messages), $c);
}

export function verify_aggregate_signature_internal_ (
  aggsig: U8[],
  public_keys: PublicKeyWithPoP[],
  messages: U8[][],
  $c: AptosDataCache,
): boolean {
  return $.aptos_std_bls12381_verify_aggregate_signature_internal(aggsig, public_keys, messages, $c);

}
export function verify_multisignature_ (
  multisig: AggrOrMultiSignature,
  aggr_public_key: AggrPublicKeysWithPoP,
  message: U8[],
  $c: AptosDataCache,
): boolean {
  return verify_multisignature_internal_($.copy(multisig.bytes), $.copy(aggr_public_key.bytes), $.copy(message), $c);
}

export function verify_multisignature_internal_ (
  multisignature: U8[],
  agg_public_key: U8[],
  message: U8[],
  $c: AptosDataCache,
): boolean {
  return $.aptos_std_bls12381_verify_multisignature_internal(multisignature, agg_public_key, message, $c);

}
export function verify_normal_signature_ (
  signature: Signature,
  public_key: PublicKey,
  message: U8[],
  $c: AptosDataCache,
): boolean {
  return verify_normal_signature_internal_($.copy(signature.bytes), $.copy(public_key.bytes), $.copy(message), $c);
}

export function verify_normal_signature_internal_ (
  signature: U8[],
  public_key: U8[],
  message: U8[],
  $c: AptosDataCache,
): boolean {
  return $.aptos_std_bls12381_verify_normal_signature_internal(signature, public_key, message, $c);

}
export function verify_proof_of_possession_internal_ (
  public_key: U8[],
  proof_of_possesion: U8[],
  $c: AptosDataCache,
): boolean {
  return $.aptos_std_bls12381_verify_proof_of_possession_internal(public_key, proof_of_possesion, $c);

}
export function verify_signature_share_ (
  signature_share: Signature,
  public_key: PublicKeyWithPoP,
  message: U8[],
  $c: AptosDataCache,
): boolean {
  return verify_signature_share_internal_($.copy(signature_share.bytes), $.copy(public_key.bytes), $.copy(message), $c);
}

export function verify_signature_share_internal_ (
  signature_share: U8[],
  public_key: U8[],
  message: U8[],
  $c: AptosDataCache,
): boolean {
  return $.aptos_std_bls12381_verify_signature_share_internal(signature_share, public_key, message, $c);

}
export function loadParsers(repo: AptosParserRepo) {
  repo.addParser("0x1::bls12381::AggrOrMultiSignature", AggrOrMultiSignature.AggrOrMultiSignatureParser);
  repo.addParser("0x1::bls12381::AggrPublicKeysWithPoP", AggrPublicKeysWithPoP.AggrPublicKeysWithPoPParser);
  repo.addParser("0x1::bls12381::ProofOfPossession", ProofOfPossession.ProofOfPossessionParser);
  repo.addParser("0x1::bls12381::PublicKey", PublicKey.PublicKeyParser);
  repo.addParser("0x1::bls12381::PublicKeyWithPoP", PublicKeyWithPoP.PublicKeyWithPoPParser);
  repo.addParser("0x1::bls12381::Signature", Signature.SignatureParser);
}
export class App {
  constructor(
    public client: AptosClient,
    public repo: AptosParserRepo,
    public cache: AptosLocalCache,
  ) {
  }
  get moduleAddress() {{ return moduleAddress; }}
  get moduleName() {{ return moduleName; }}
  get AggrOrMultiSignature() { return AggrOrMultiSignature; }
  get AggrPublicKeysWithPoP() { return AggrPublicKeysWithPoP; }
  get ProofOfPossession() { return ProofOfPossession; }
  get PublicKey() { return PublicKey; }
  get PublicKeyWithPoP() { return PublicKeyWithPoP; }
  get Signature() { return Signature; }
}