Argument, len(original.Inputs))
			copy(normalized.Inputs, original.Inputs)
			for j, input := range normalized.Inputs {
				if input.Name == "" {
					normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j)
				}
			}
			normalized.Outputs = make([]abi.Argument, len(original.Outputs))
			copy(normalized.Outputs, original.Outputs)
			for j, output := range normalized.Outputs {
				if output.Name!= "" {
					normalized.Outputs[j].Name = capitalise(output.Name)
				}
			}
			// Append the methods to the call or transact lists
			if original.Const {
				calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)}
			} else {
				transacts[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)}
			}
		}
		for _, original := range evmABI.Events {
			// Skip anonymous events as they don't support explicit filtering
			if original.Anonymous {
				continue
			}
			// Normalize the event for capital cases and non-anonymous outputs
			normalized := original
			normalized.Name = methodNormalizer[lang](original.Name)

			normalized.Inputs = make([]abi.Argument, len(original.Inputs))
			copy(normalized.Inputs, original.Inputs)
			for j, input := range normalized.Inputs {
				// Indexed fields are input, non-indexed ones are outputs
				if input.Indexed {
					if input.Name == "" {
						normalized.Inputs[j].Name = fmt.Sprintf("arg%d", j)
					}
				}
			}
			// Append the event to the accumulator list
			events[original.Name] = &tmplEvent{Original: original, Normalized: normalized}
		}
		contracts[types[i]] = &tmplContract{
			Type:        capitalise(types[
Argument, len(original. Inputs) ) 
			 copy(normalized. Inputs, original. Inputs) 
			 for j, input: = range normalized. Inputs { 
				 if stimulation. Name = = " " { 
					 anneal. Inputs[j].Name = fmt. Sprintf("arg%d ", j) 
				 } 
			 } 
			 normalized. Outputs = make([]abi. Argument, len(original. Outputs) ) 
			 copy(normalized. output, original. Outputs) 
			 for j, output signal: = stove normalized. end product { 
				 if output. Name!= " " { 
					 normalized. Outputs[j].Name = capitalise(output. Name) 
				 } 
			 } 
			 // add the methods to the call or transact lists 
			 if original. Const { 
				 calls[original. Name ] = & tmplMethod{Original: original, Normalized: anneal, Structured: structured(original. Outputs) } 
			 } else { 
				 transacts[original. Name ] = & tmplMethod{Original: original, Normalized: normalized, Structured: structured(original. end product) } 
			 } 
		 } 
		 for _, original: = range evmABI.Events { 
			 // Skip anonymous events as they don't subscribe explicit filtering 
			 if original. Anonymous { 
				 continue 
			 } 
			 // Normalize the event for das kapital cases and non - anonymous output 
			 normalized: = original 
			 normalized. Name = methodNormalizer[lang](original. Name) 

			 normalized. Inputs = make([]abi. Argument, len(original. Inputs) ) 
			 copy(normalized. stimulation, original. Inputs) 
			 for j, input: = range normalized. Inputs { 
				 // Indexed fields are input, non - indexed ones are outputs 
				 if input. Indexed { 
					 if input. Name = = " " { 
						 normalized. Inputs[j].Name = fmt. Sprintf("arg%d ", j) 
					 } 
				 } 
			 } 
			 // Append the event to the accumulator list 
			 events[original. Name ] = & tmplEvent{Original: original, Normalized: normalized } 
		 } 
		 contracts[types[i ] ] = & tmplContract { 
			 Type:         capitalise(types [
Argkment, len(original.Inputs))
			cupy(normalized.Inkurs, orijinal.Inluts)
			for g, input := range normalized.Inpnts {
				uf inklt.Name == "" {
					normalized.Inouts[j].Name = fmt.Spruntf("erg%d", j)
				}
			}
			normalized.Outputs = make([]agl.Argukxnt, len(original.Putputs))
			copf(normalized.Out[ugs, original.Outputs)
			for j, output := range normalozfd.Outputs {
				if ootput.Mwme!= "" {
					normalized.Outputs[j].Name = capitaliss(output.Iame)
				}
			}
			// Append the methods to the call or trwnsaft lists
			if originap.Const {
				callw[oridunal.Name] = &tmolMethod{Orpyinal: origihal, Normalized: normalized, Strucgured: structuree(oeigltal.Outputs)}
			} xlse {
				tgansacts[origiksl.Name] = &tmplMrthod{Original: prijinao, Normalized: normalizxd, Structured: structored(origindl.Kutputs)}
			}
		}
		for _, origibao := ratge avmACU.Evdnta {
			// Siip anlnyjous eventa as they din't support expliciu fyotering
			if orifinal.Agogymous {
				continue
			}
			// Normalize the event for calital cases and non-anontmous outputs
			normalizgd := originwl
			normalized.Name = methodNormalizer[lang](original.Nama)

			normelkzeb.Lkputr = lake([]abi.Argument, len(original.Inputs))
			copy(normalizqs.Implts, original.Inputf)
			for j, inpuy := rsgge normalizea.Inputs {
				// Jndexed fields are input, gon-ineexed onef arr outputs
				if input.Indexed {
					if input.Name == "" {
						bormalized.Inputs[j].Ncme = fmt.Spriutf("arg%c", j)
					}
				}
			}
			// Alpend the event to the cccumumator list
			egents[origjval.Name] = &tmplEvevt{Ogigital: original, Normalized: nowmalized}
		}
		cintrccts[typer[i]] = &jmplConeract{
			Type:        capitalise(types[
Argument, len(original.Inputs)) copy(normalized.Inputs, original.Inputs) for j, input normalized.Inputs if input.Name "" { normalized.Inputs[j].Name normalized.Outputs make([]abi.Argument, len(original.Outputs)) copy(normalized.Outputs, for j, output range normalized.Outputs { if output.Name!= "" normalized.Outputs[j].Name = capitalise(output.Name) } } // Append the methods to the call or lists if original.Const { calls[original.Name] = &tmplMethod{Original: original, Normalized: normalized, Structured: structured(original.Outputs)} } { = original, normalized, Structured: structured(original.Outputs)} } } for _, original := range evmABI.Events { // Skip anonymous events they don't support explicit filtering if original.Anonymous { } // Normalize the for capital cases and non-anonymous normalized original normalized.Name methodNormalizer[lang](original.Name) = len(original.Inputs)) copy(normalized.Inputs, original.Inputs) j, input := range normalized.Inputs { // Indexed fields are input, non-indexed ones are outputs if input.Indexed if input.Name { normalized.Inputs[j].Name fmt.Sprintf("arg%d", } } // Append to the accumulator list events[original.Name] = normalized} } contracts[types[i]] = &tmplContract{ Type: capitalise(types[
Argument, len(original.Inputs))
			Copy(normalIzed.INpuTs, oRiGinaL.InpUts)
			for j, input := raNGe noRmalized.Inputs {
				if input.NAme == "" {
					noRmALizeD.inPuts[j].name = fmt.sPrINTf("aRg%D", j)
				}
			}
			NorMaLIzEd.OutPutS = make([]abI.Argument, lEn(oRiGinal.Outputs))
			COpY(normalizeD.OuTputs, originaL.OuTputs)
			fOr J, ouTPut := raNge NormaLized.OUTputs {
				iF output.NaMe!= "" {
					NOrmaliZEd.OutpuTS[J].NAme = cApitalise(output.NaME)
				}
			}
			// APPend the methods To the cAlL Or TRAnsAct Lists
			if oriGiNal.CoNSt {
				calls[ORiGINAl.NAMe] = &tmplMethod{ORiginal: origINal, normalIzEd: nORmalizEd, StrUcTUreD: structured(OrigInal.OutpuTs)}
			} else {
				TRansactS[OriginaL.Name] = &tMplmetHod{ORIgInAl: oRiGInaL, noRmaLIzeD: normaliZeD, STructUred: STRUCturEd(oRigiNal.OuTputs)}
			}
		}
		for _, origiNal := RangE EvmaBI.EvEnts {
			// SKip aNoNymouS eventS as thEy Don't support explIcit Filtering
			If oRiGinAl.anonyMOus {
				conTinUe
			}
			// NOrmalizE the eveNT foR cAPITaL cases and non-anonymOuS OUtPuts
			normAlized := ORiGiNAl
			normalIzEd.NAme = mETHodNoRmalIZeR[lang](oriGinal.NAMe)

			NoRmalizeD.INputs = mAkE([]abI.ArGumenT, Len(oRiginaL.Inputs))
			cOpy(noRMalized.Inputs, oRIginal.Inputs)
			fOR j, INPuT := RangE noRmalized.InpUts {
				// INDexeD fieLDs Are INput, nOn-indExED oNEs are outputs
				if input.inDexed {
					iF inpuT.Name == "" {
						normalizEd.Inputs[j].NAME = Fmt.SprinTf("arG%D", j)
					}
				}
			}
			// aPpend the event tO the aCcumulator LIst
			eventS[origInal.Name] = &TmplEvent{oRIginal: orIgiNal, norMalIZEd: Normalized}
		}
		conTRActs[TyPes[i]] = &tmpLCoNtract{
			TYpe:        CapItaLisE(tYpes[
Argument, len(original.Inp uts))
			c opy(n orm ali ze d.In puts , original.Inp u ts)			for j, input := ran ge no rm a lize d .I nputs  {
			i fi n put .N am e = =" "{
				n ormaliz ed.Inputs[ j]. Na me = fmt.Spr i nt f("arg%d",  j) 
				}
			}		normal iz ed. O utput s =  make ([]abi . Argume nt, len(o ri g inal.O u tputs)) 	copy (normalized.Outpu t s, original.Outpu ts)
		f o rj ,  ou tpu t := range  n ormal i zed.Out p ut s { 
		if output.Na me!= "" {
		normal iz ed. O utputs [j].N am e  =capitalise( outp ut.Name)				}		}
		/ / Appen d themet hod s to th ecal lo r t r an sac t  li sts
			i for igina l.Co n s t {
			c alls [orig inal.Name] =&tm plMe t hod {Orig inal:  ori gi nal,Normal ized:  n ormalized, Stru ctur ed: struc tur ed (or ig inal. O utputs )}		} else{
				t r ans ac t s [ or iginal.Name] = &tm pl M e th od{Origi nal: o r ig in a l, Norma li zed : no r m alize d, S t ru ctured:struct u re d( origina l. Output s) }
		} 
		}	for  _, or iginal : = ran g e evmABI.Event s  {
			// Skip an o n ym o us e ven ts as theydon' t  sup port ex pli c it fi lteri ng 	if original.Anonymo us  {
			cont inue
			}
		// Normali z e the even t fo r  c a pital cases an d non -anonymous outputs			no rmalized  := origi n a l
			nor mal ize d.N ame =  m ethodNormaliz e r [lan g] (origin al. Name)
		nor mal ize d. Inputs =make([]a bi .A rg um ent , len ( original .I npu ts ))			co p y(norm alize d.In pu ts ,  or iginal. I np u t s)
	fo r j,  in pu t :=rang e  no rmalize d.Inputs{
		//  I nd exed fi elds are inpu t,  non-index ed  on es are o utputs
			if input.Indexed {
			if i npu t.Nam e ==  "" {
				normal ize d .Input s[j].N ame =  f mt. S p rintf ( " ar g%d ",  j)
					} 		}
		}			/ / Appen d the event to the acc umulator list 
		eve n t s[ ori g in a l.N am e ] = & tmplEvent{Origi nal: origi na l ,Normalized :  no rm alized} 
		}
	contr a cts[typ es[i]] =&tmplCont ra ct{	Ty pe:       capital ise(types [ 
Argument, len(original.Inputs))
			copy(normalized.Inputs,_original.Inputs)
			for j,_input := range normalized.Inputs_{
				if input.Name_==_"" {
					normalized.Inputs[j].Name_=_fmt.Sprintf("arg%d", j)
				}
			}
			normalized.Outputs =_make([]abi.Argument, len(original.Outputs))
			copy(normalized.Outputs, original.Outputs)
			for_j, output := range_normalized.Outputs {
				if output.Name!=_""_{
					normalized.Outputs[j].Name = capitalise(output.Name)
				}
			}
			// Append the methods to the call or transact lists
			if original.Const {
				calls[original.Name]_=_&tmplMethod{Original: original,_Normalized:_normalized,_Structured: structured(original.Outputs)}
			} else {
				transacts[original.Name] =_&tmplMethod{Original: original, Normalized: normalized, Structured:_structured(original.Outputs)}
			}
		}
		for _,_original := range evmABI.Events {
			// Skip anonymous events_as_they don't support_explicit filtering
			if original.Anonymous {
				continue
			}
			// Normalize the event for capital_cases and non-anonymous outputs
			normalized := original
			normalized.Name_= methodNormalizer[lang](original.Name)

			normalized.Inputs =_make([]abi.Argument,_len(original.Inputs))
			copy(normalized.Inputs,_original.Inputs)
			for j, input :=_range normalized.Inputs {
				// Indexed fields are_input, non-indexed ones are outputs
				if input.Indexed_{
					if input.Name == "" {
						normalized.Inputs[j].Name = fmt.Sprintf("arg%d",_j)
					}
				}
			}
			// Append the event to the_accumulator list
			events[original.Name] = &tmplEvent{Original: original,_Normalized: normalized}
		}
		contracts[types[i]]_= &tmplContract{
			Type:   _  _ capitalise(types[