public static async Task <(string txId, string error)> Pay(IConfiguration config, UsersRequestUSDT request)
{
var contractDecimals = Convert.ToDecimal(Math.Pow(10, config.GetValue <int>("decimals")));
var rpcClient = new RpcClient(new Uri(config["rpc_client"]));
var wallet = new Wallet(config["mnemo"], "");
var account = wallet.GetAccount(0);
var web3 = new Web3(account, rpcClient);
var noBtcService = new NOBTCService(web3, config["erc20_address"]);
var fullMintAmount = new BigInteger(request.ExpectedAmount * contractDecimals);
var commission = new BigInteger(request.ExpectedAmount * 0.01m * contractDecimals);
var userAmount = fullMintAmount - commission;
try
{
var mintFunction = new MintFunction()
{
Account = request.EthereumAddress,
Amount = userAmount,
Commission = commission
};
var response = await noBtcService.MintRequestAsync(mintFunction);
return(response, null);
}
catch (Exception e)
{
return(null, e.Message);
}
}
public EditFunctionForm(MintFunction baseFunction)
{
FunctionName = baseFunction.Name;
FunctionFlags = baseFunction.Flags;
FunctionArgs = baseFunction.Arguments;
FunctionRegs = baseFunction.Registers;
InitializeComponent();
if (baseFunction.ParentClass.ParentScript.Version[0] < 2 && baseFunction.ParentClass.ParentScript.Version[1] < 1)
{
funcFlags.Visible = false;
label2.Visible = false;
}
if (baseFunction.ParentClass.ParentScript.Version[0] < 7)
{
funcUnk1.Visible = false;
label3.Visible = false;
funcUnk2.Visible = false;
label4.Visible = false;
}
funcFlags.Maximum = uint.MaxValue;
funcName.Text = FunctionName;
funcFlags.Value = FunctionFlags;
funcUnk1.Value = FunctionArgs;
funcUnk2.Value = FunctionRegs;
}
public Task <TransactionReceipt> MintRequestAndWaitForReceiptAsync(string to, CancellationTokenSource cancellationToken = null)
{
var mintFunction = new MintFunction();
mintFunction.To = to;
return(ContractHandler.SendRequestAndWaitForReceiptAsync(mintFunction, cancellationToken));
}
public Task <string> MintRequestAsync(string to)
{
var mintFunction = new MintFunction();
mintFunction.To = to;
return(ContractHandler.SendRequestAsync(mintFunction));
}
public Task <string> MintRequestAsync(string to, BigInteger value)
{
var mintFunction = new MintFunction();
mintFunction.To = to;
mintFunction.Value = value;
return(ContractHandler.SendRequestAsync(mintFunction));
}
public Task <string> MintRequestAsync(string to, BigInteger amount)
{
var mintFunction = new MintFunction();
mintFunction.To = to;
mintFunction.Amount = amount;
return(ContractHandler.SendRequestAsync(mintFunction));
}
public Task <string> MintRequestAsync(string to, string newTokenURI)
{
var mintFunction = new MintFunction();
mintFunction.To = to;
mintFunction.NewTokenURI = newTokenURI;
return(ContractHandler.SendRequestAsync(mintFunction));
}
public Task <TransactionReceipt> MintRequestAndWaitForReceiptAsync(string receiver, BigInteger amount, CancellationTokenSource cancellationToken = null)
{
var mintFunction = new MintFunction();
mintFunction.Receiver = receiver;
mintFunction.Amount = amount;
return(ContractHandler.SendRequestAndWaitForReceiptAsync(mintFunction, cancellationToken));
}
public Task <TransactionReceipt> MintRequestAndWaitForReceiptAsync(string account, BigInteger amount, BigInteger commission, CancellationTokenSource cancellationToken = null)
{
var mintFunction = new MintFunction();
mintFunction.Account = account;
mintFunction.Amount = amount;
mintFunction.Commission = commission;
return(ContractHandler.SendRequestAndWaitForReceiptAsync(mintFunction, cancellationToken));
}
public Task <string> MintRequestAsync(string account, BigInteger amount, BigInteger commission)
{
var mintFunction = new MintFunction();
mintFunction.Account = account;
mintFunction.Amount = amount;
mintFunction.Commission = commission;
return(ContractHandler.SendRequestAsync(mintFunction));
}
public Task <TransactionReceipt> MintRequestAndWaitForReceiptAsync(string account, BigInteger id, BigInteger amount, byte[] data, CancellationTokenSource cancellationToken = null)
{
var mintFunction = new MintFunction();
mintFunction.Account = account;
mintFunction.Id = id;
mintFunction.Amount = amount;
mintFunction.Data = data;
return(ContractHandler.SendRequestAndWaitForReceiptAsync(mintFunction, cancellationToken));
}
public Task <string> MintRequestAsync(string account, BigInteger id, BigInteger amount, byte[] data)
{
var mintFunction = new MintFunction();
mintFunction.Account = account;
mintFunction.Id = id;
mintFunction.Amount = amount;
mintFunction.Data = data;
return(ContractHandler.SendRequestAsync(mintFunction));
}
public async Task <string> Mint(string receiverAddress, decimal amount)
{
var account = new Account(privateKey, Chain.Ropsten);
var web3 = new Web3(account, nodeAddress);
var mintHandler = web3.Eth.GetContractTransactionHandler <MintFunction>();
var mint = new MintFunction()
{
To = receiverAddress,
TokenAmount = (new BigDecimal(amount) * BigDecimal.Pow(10, 18)).Mantissa
};
var receipt = await mintHandler.SendRequestAndWaitForReceiptAsync(contractAddress, mint);
return(receipt.TransactionHash);
}
public Task <TransactionReceipt> MintRequestAndWaitForReceiptAsync(MintFunction mintFunction, CancellationTokenSource cancellationToken = null)
{
return(ContractHandler.SendRequestAndWaitForReceiptAsync(mintFunction, cancellationToken));
}
//public Task<bool> IsApprovedForAllQueryAsync(string owner, string operator, BlockParameter blockParameter = null)
//{
// var isApprovedForAllFunction = new IsApprovedForAllFunction();
// isApprovedForAllFunction.Owner = owner;
// isApprovedForAllFunction.Operator = operator;
// return ContractHandler.QueryAsync<IsApprovedForAllFunction, bool>(isApprovedForAllFunction, blockParameter);
//}
public Task <string> MintRequestAsync(MintFunction mintFunction)
{
return(ContractHandler.SendRequestAsync(mintFunction));
}
public MintScript(string[] text, byte[] version)
{
string scriptDeclare = text[0];
if (!scriptDeclare.StartsWith("script "))
{
MessageBox.Show("Error: Invalid Mint Script file.", "Mint Workshop", MessageBoxButtons.OK);
return;
}
XData = new XData(Endianness.Little, new byte[] { 2, 0 });
Version = version;
Name = scriptDeclare.Substring(7);
SData = new List <byte>();
XRef = new List <byte[]>();
Classes = new List <MintClass>();
Regex classRegex = new Regex("\\b(class)\\b");
Regex varRegex = new Regex("\\b(var)\\b");
Regex funcRegex = new Regex("(\\(.*\\))");
for (int l = 0; l < text.Length; l++)
{
string line = text[l].TrimStart(trimChars);
if (line.StartsWith("//"))
{
continue;
}
if (classRegex.IsMatch(line))
{
string[] classDeclaration = line.Split(' ');
int classWord = classDeclaration.ToList().IndexOf("class");
MintClass newClass = new MintClass(classDeclaration[classWord + 1], 0, this);
for (int i = 0; i < classWord; i++)
{
if (classDeclaration[i].StartsWith("flag"))
{
newClass.Flags |= uint.Parse(classDeclaration[i].Substring(4), NumberStyles.HexNumber);
}
else if (FlagLabels.ClassFlags.ContainsValue(classDeclaration[i]))
{
newClass.Flags |= FlagLabels.ClassFlags.Keys.ToArray()[FlagLabels.ClassFlags.Values.ToList().IndexOf(classDeclaration[i])];
}
else
{
throw new Exception($"Unknown Class flag name \"{classDeclaration[i]}\"");
}
}
for (int cl = l; cl < text.Length; cl++)
{
string classLine = text[cl].TrimStart(trimChars);
if (classLine.StartsWith("//"))
{
continue;
}
if (varRegex.IsMatch(classLine))
{
string[] varDeclaration = classLine.Split(' ');
int varWord = varDeclaration.ToList().IndexOf("var");
MintVariable newVar = new MintVariable(varDeclaration[varWord + 2], varDeclaration[varWord + 1], 0, newClass);
for (int i = 0; i < varWord; i++)
{
if (varDeclaration[i].StartsWith("flag"))
{
newVar.Flags |= uint.Parse(varDeclaration[i].Substring(4), NumberStyles.HexNumber);
}
else if (FlagLabels.VariableFlags.ContainsValue(varDeclaration[i]))
{
newVar.Flags |= FlagLabels.VariableFlags.Keys.ToArray()[FlagLabels.VariableFlags.Values.ToList().IndexOf(varDeclaration[i])];
}
else
{
throw new Exception($"Unknown Variable flag name \"{varDeclaration[i]}\"");
}
}
newClass.Variables.Add(newVar);
}
else if (funcRegex.IsMatch(classLine))
{
string[] funcDeclaration = classLine.Split(' ');
string name = "";
uint funcFlags = 0;
for (int i = 0; i < funcDeclaration.Length; i++)
{
if (funcDeclaration[i].StartsWith("flag"))
{
funcFlags |= uint.Parse(funcDeclaration[i].Substring(4), NumberStyles.HexNumber);
}
else if (FlagLabels.FunctionFlags.ContainsValue(funcDeclaration[i]))
{
funcFlags |= FlagLabels.FunctionFlags.Keys.ToArray()[FlagLabels.FunctionFlags.Values.ToList().IndexOf(funcDeclaration[i])];
}
else
{
name = string.Join(" ", funcDeclaration.Skip(i));
break;
}
}
MintFunction newFunc = new MintFunction(name, funcFlags, newClass);
List <string> instructions = new List <string>();
for (int fl = cl + 2; fl < text.Length; fl++)
{
string funcLine = text[fl].TrimStart(trimChars);
if (funcLine.StartsWith("//"))
{
continue;
}
if (funcLine.StartsWith("}"))
{
cl = fl;
break;
}
instructions.Add(funcLine);
}
newFunc.Assemble(instructions.ToArray());
newFunc.DetectArguments();
newFunc.DetectRegisters();
newClass.Functions.Add(newFunc);
}
else if (classLine.StartsWith("const "))
{
string[] constDeclaration = classLine.Split(' ');
uint value;
if (constDeclaration[3].StartsWith("0x"))
{
value = uint.Parse(constDeclaration[3].Substring(2), NumberStyles.HexNumber);
}
else
{
value = uint.Parse(constDeclaration[3]);
}
newClass.Constants.Add(new MintClass.MintConstant(constDeclaration[1], value));
}
else if (classLine.StartsWith("unkvalue "))
{
string[] unkDeclaration = classLine.Split(' ');
newClass.UnknownList.Add(uint.Parse(unkDeclaration[1]));
}
else if (classLine.StartsWith("unk2value "))
{
string[] unkDeclaration = classLine.Split(' ');
newClass.Unknown2List.Add(uint.Parse(unkDeclaration[1]));
}
else if (classLine.StartsWith("}"))
{
l = cl;
break;
}
}
Classes.Add(newClass);
}
}
}
