public override void AddToken(IPEndPoint endPoint, uint token, TokenFlags tokenFlags) { if (token == TokenHelper.TokenNone) { return; } for (var i = 0; i < ConnlessPacketList.Count; i++) { var info = ConnlessPacketList[i]; if (info.EndPoint.Compare(endPoint, true)) { info.SendCallback?.Invoke(info.TrackID, info.CallbackContext); NetworkHelper.SendPacketConnless(Client, info.EndPoint, token, TokenManager.GenerateToken(info.EndPoint), info.Data, info.DataSize); ConnlessPacketList.RemoveAt(i--); } } if (!tokenFlags.HasFlag(TokenFlags.ResponseOnly)) { TokenCache.Add(new AddressInfo() { EndPoint = endPoint, Token = token, Expiry = Time.Get() + Time.Freq() * TokenHelper.TokenCacheAddressExpiry }); } }
internal StringExpandableToken(InternalScriptExtent scriptExtent, TokenKind tokenKind, string value, string formatString, List<Token> nestedTokens, TokenFlags flags) : base(scriptExtent, tokenKind, flags, value) { if ((nestedTokens != null) && nestedTokens.Any<Token>()) { this._nestedTokens = new ReadOnlyCollection<Token>(nestedTokens.ToArray()); } this._formatString = formatString; }
public void SetFlag(TokenFlags flag, bool on) { if (on) { _flags |= flag; } else { _flags &= ~flag; } }
/////////////////////////////////////////////////////////////////////// public static bool HasFlags( TokenFlags flags, TokenFlags hasFlags, bool all ) { if (all) { return((flags & hasFlags) == hasFlags); } else { return((flags & hasFlags) != TokenFlags.None); } }
private void CreateTokens() { string[] tokenList = { maxDivTokenSymbol, nonDivisibleTokenSymbol }; simulator.BeginBlock(); foreach (var symbol in tokenList) { int decimals = 0; BigInteger supply = 0; TokenFlags flags = TokenFlags.Divisible; switch (symbol) { case maxDivTokenSymbol: decimals = NexusContract.MAX_TOKEN_DECIMALS; supply = UnitConversion.ToBigInteger(100000000, decimals); flags = TokenFlags.Transferable | TokenFlags.Fungible | TokenFlags.Finite | TokenFlags.Divisible; break; case minDivTokenSymbol: decimals = 1; supply = UnitConversion.ToBigInteger(100000000, 18); flags = TokenFlags.Transferable | TokenFlags.Fungible | TokenFlags.Finite | TokenFlags.Divisible; break; case nonDivisibleTokenSymbol: decimals = 0; supply = UnitConversion.ToBigInteger(100000000, 18); flags = TokenFlags.Transferable | TokenFlags.Fungible | TokenFlags.Finite; break; } simulator.GenerateToken(simulatorOwner, symbol, $"{symbol}Token", DomainSettings.PlatformName, Hash.FromString(symbol), supply, decimals, flags); simulator.MintTokens(simulatorOwner, simulatorOwner.Address, symbol, supply); } simulator.EndBlock(); }
public bool IsSet(TokenFlags flag) { return((Flags & flag) != 0); }
internal TokenInfo(string symbol, string name, BigInteger maxSupply, int decimals, TokenFlags flags, byte[] script) { this.Symbol = symbol; this.Name = name; this.Flags = flags; this.Decimals = decimals; this.MaxSupply = maxSupply; this.Script = script; }
public TokenInfo(string symbol, string name, Address owner, BigInteger maxSupply, int decimals, TokenFlags flags, byte[] script, ContractInterface ABI) { Throw.IfNullOrEmpty(symbol, nameof(symbol)); Throw.IfNullOrEmpty(name, nameof(name)); Throw.If(owner.IsNull, "token owner can't be null address"); Throw.If(decimals < 0, "decimals can't be negative"); Throw.If(flags == TokenFlags.None, "token must have flags set"); Throw.If(script == null || script.Length == 0, "token script can't be empty"); Throw.If(flags.HasFlag(TokenFlags.Swappable), "swappable swap can't be set in token creation"); Throw.If(maxSupply < 0, "negative supply"); Throw.If(maxSupply == 0 && flags.HasFlag(TokenFlags.Finite), "finite requires a supply"); Throw.If(maxSupply > 0 && !flags.HasFlag(TokenFlags.Finite), "infinite requires no supply"); if (!flags.HasFlag(TokenFlags.Fungible)) { Throw.If(flags.HasFlag(TokenFlags.Divisible), "non-fungible token must be indivisible"); } if (flags.HasFlag(TokenFlags.Divisible)) { Throw.If(decimals <= 0, "divisible token must have decimals"); } else { Throw.If(decimals > 0, "indivisible token can't have decimals"); } this.Symbol = symbol; this.Name = name; this.Owner = owner; this.Flags = flags; this.Decimals = decimals; this.MaxSupply = maxSupply; this.Script = script; this.ABI = ABI; }
internal TokenInfo(string tokenString, TokenFlags flags, int precedence) : this(tokenString, flags) { _precedence = precedence; }
/// <summary> /// Return true if the <ref>TokenKind</ref> has the given trait. /// </summary> public static bool HasTrait(this TokenKind kind, TokenFlags flag) { return (GetTraits(kind) & flag) != TokenFlags.None; }
static TokenTraits() { TokenFlags[] flagsArray = new TokenFlags[0x9b]; flagsArray[8] = TokenFlags.ParseModeInvariant; flagsArray[9] = TokenFlags.ParseModeInvariant; flagsArray[10] = TokenFlags.ParseModeInvariant; flagsArray[11] = TokenFlags.ParseModeInvariant; flagsArray[12] = TokenFlags.ParseModeInvariant; flagsArray[13] = TokenFlags.ParseModeInvariant; flagsArray[14] = TokenFlags.ParseModeInvariant; flagsArray[15] = TokenFlags.ParseModeInvariant; flagsArray[0x10] = TokenFlags.ParseModeInvariant; flagsArray[0x11] = TokenFlags.ParseModeInvariant; flagsArray[0x12] = TokenFlags.ParseModeInvariant; flagsArray[0x13] = TokenFlags.ParseModeInvariant; flagsArray[0x15] = TokenFlags.ParseModeInvariant; flagsArray[0x16] = TokenFlags.ParseModeInvariant; flagsArray[0x17] = TokenFlags.ParseModeInvariant; flagsArray[0x18] = TokenFlags.ParseModeInvariant; flagsArray[0x19] = TokenFlags.ParseModeInvariant; flagsArray[0x1a] = TokenFlags.ParseModeInvariant | TokenFlags.BinaryOperator; flagsArray[0x1b] = TokenFlags.ParseModeInvariant | TokenFlags.BinaryOperator; flagsArray[0x1c] = TokenFlags.ParseModeInvariant | TokenFlags.SpecialOperator; flagsArray[0x1d] = TokenFlags.ParseModeInvariant | TokenFlags.SpecialOperator; flagsArray[30] = TokenFlags.ParseModeInvariant | TokenFlags.UnaryOperator; flagsArray[0x1f] = TokenFlags.PrefixOrPostfixOperator | TokenFlags.DisallowedInRestrictedMode | TokenFlags.UnaryOperator; flagsArray[0x20] = TokenFlags.PrefixOrPostfixOperator | TokenFlags.DisallowedInRestrictedMode | TokenFlags.UnaryOperator; flagsArray[0x21] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceMask; flagsArray[0x22] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.SpecialOperator; flagsArray[0x23] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.SpecialOperator; flagsArray[0x24] = TokenFlags.CanConstantFold | TokenFlags.UnaryOperator; flagsArray[0x25] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceMultiply; flagsArray[0x26] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceMultiply; flagsArray[0x27] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceMultiply; flagsArray[40] = TokenFlags.CanConstantFold | TokenFlags.UnaryOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceAdd; flagsArray[0x29] = TokenFlags.CanConstantFold | TokenFlags.UnaryOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceAdd; flagsArray[0x2a] = TokenFlags.AssignmentOperator; flagsArray[0x2b] = TokenFlags.AssignmentOperator; flagsArray[0x2c] = TokenFlags.AssignmentOperator; flagsArray[0x2d] = TokenFlags.AssignmentOperator; flagsArray[0x2e] = TokenFlags.AssignmentOperator; flagsArray[0x2f] = TokenFlags.AssignmentOperator; flagsArray[0x30] = TokenFlags.DisallowedInRestrictedMode; flagsArray[0x31] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.ParseModeInvariant; flagsArray[50] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceFormat; flagsArray[0x33] = TokenFlags.CanConstantFold | TokenFlags.UnaryOperator; flagsArray[0x34] = TokenFlags.CanConstantFold | TokenFlags.UnaryOperator; flagsArray[0x35] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceLogical; flagsArray[0x36] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceLogical; flagsArray[0x37] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceLogical; flagsArray[0x38] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceBitwise; flagsArray[0x39] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceBitwise; flagsArray[0x3a] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceBitwise; flagsArray[0x3b] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.UnaryOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[60] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x3d] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x3e] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x3f] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x40] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x41] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x42] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x43] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x44] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x45] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[70] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x47] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x48] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x49] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x4a] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x4b] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.UnaryOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x4c] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x4d] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x4e] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x4f] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[80] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x51] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x52] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x53] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x54] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x55] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x56] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x57] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x58] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x59] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[90] = TokenFlags.CaseSensitiveOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x5b] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.CaseSensitiveOperator | TokenFlags.UnaryOperator | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x5c] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x5d] = TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x5e] = TokenFlags.DisallowedInRestrictedMode | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x5f] = TokenFlags.PrefixOrPostfixOperator | TokenFlags.DisallowedInRestrictedMode | TokenFlags.UnaryOperator; flagsArray[0x60] = TokenFlags.PrefixOrPostfixOperator | TokenFlags.DisallowedInRestrictedMode | TokenFlags.UnaryOperator; flagsArray[0x61] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x62] = TokenFlags.CanConstantFold | TokenFlags.BinaryOperator | TokenFlags.BinaryPrecedenceComparison; flagsArray[0x77] = TokenFlags.ScriptBlockBlockName | TokenFlags.Keyword; flagsArray[120] = TokenFlags.Keyword; flagsArray[0x79] = TokenFlags.Keyword; flagsArray[0x7a] = TokenFlags.Keyword; flagsArray[0x7b] = TokenFlags.Keyword; flagsArray[0x7c] = TokenFlags.Keyword; flagsArray[0x7d] = TokenFlags.Keyword; flagsArray[0x7e] = TokenFlags.Keyword; flagsArray[0x7f] = TokenFlags.ScriptBlockBlockName | TokenFlags.Keyword; flagsArray[0x80] = TokenFlags.Keyword; flagsArray[0x81] = TokenFlags.Keyword; flagsArray[130] = TokenFlags.ScriptBlockBlockName | TokenFlags.Keyword; flagsArray[0x83] = TokenFlags.Keyword; flagsArray[0x84] = TokenFlags.Keyword; flagsArray[0x85] = TokenFlags.Keyword; flagsArray[0x86] = TokenFlags.Keyword; flagsArray[0x87] = TokenFlags.Keyword; flagsArray[0x88] = TokenFlags.Keyword; flagsArray[0x89] = TokenFlags.Keyword; flagsArray[0x8a] = TokenFlags.Keyword; flagsArray[0x8b] = TokenFlags.Keyword; flagsArray[140] = TokenFlags.Keyword; flagsArray[0x8d] = TokenFlags.ScriptBlockBlockName | TokenFlags.Keyword; flagsArray[0x8e] = TokenFlags.Keyword; flagsArray[0x8f] = TokenFlags.Keyword; flagsArray[0x90] = TokenFlags.Keyword; flagsArray[0x91] = TokenFlags.Keyword; flagsArray[0x92] = TokenFlags.Keyword; flagsArray[0x93] = TokenFlags.Keyword; flagsArray[0x94] = TokenFlags.Keyword; flagsArray[0x95] = TokenFlags.Keyword; flagsArray[150] = TokenFlags.Keyword; flagsArray[0x97] = TokenFlags.Keyword; flagsArray[0x98] = TokenFlags.Keyword; flagsArray[0x99] = TokenFlags.Keyword; flagsArray[0x9a] = TokenFlags.Keyword; _staticTokenFlags = flagsArray; _tokenText = new string[] { "unknown", "var", "@var", "param", "number", "label", "ident", "generic", "newline", "line continuation", "comment", "eof", "sqstr", "dqstr", "sq here string", "dq here string", "(", ")", "{", "}", "[", "]", "@(", "@{", "$(", ";", "&&", "||", "&", "|", ",", "--", "++", "..", "::", ".", "!", "*", "/", "%", "+", "-", "=", "+=", "-=", "*=", "/=", "%=", "redirection", "<", "-f", "-not", "-bnot", "-and", "-or", "-xor", "-band", "-bor", "-bxor", "-join", "-eq", "-ne", "-ge", "-gt", "-lt", "-le", "-ilike", "-inotlike", "-imatch", "-inotmatch", "-ireplace", "-icontains", "-inotcontains", "-iin", "-inotin", "-isplit", "-ceq", "-cne", "-cge", "-cgt", "-clt", "-cle", "-clike", "-cnotlike", "-cmatch", "-cnotmatch", "-creplace", "-ccontains", "-cnotcontains", "-cin", "-cnotin", "-csplit", "-is", "-isnot", "-as", "++", "--", "-shl", "-shr", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "begin", "break", "catch", "class", "continue", "data", "define", "do", "dynamicparam", "else", "elseif", "end", "exit", "filter", "finally", "for", "foreach", "from", "function", "if", "in", "param", "process", "return", "switch", "throw", "trap", "try", "until", "using", "var", "while", "workflow", "parallel", "sequence", "inlinescript" }; }
public abstract void AddToken(IPEndPoint endPoint, uint token, TokenFlags tokenFlags);
public Transaction GenerateToken(KeyPair owner, string symbol, string name, BigInteger totalSupply, int decimals, TokenFlags flags) { var chain = Nexus.RootChain; var script = ScriptUtils. BeginScript(). AllowGas(owner.Address, Address.Null, 1, 9999). CallContract("nexus", "CreateToken", owner.Address, symbol, name, totalSupply, decimals, flags). SpendGas(owner.Address). EndScript(); var tx = MakeTransaction(owner, chain, script); tx.Sign(owner); return(tx); }
internal StringLiteralToken(InternalScriptExtent scriptExtent, TokenFlags flags, TokenKind tokenKind, string value) : base(scriptExtent, tokenKind, flags, value) { }
private static void DeployOrUpgrade(string[] args, SpookSettings settings, NexusAPI api, BigInteger minFee, bool isUpgrade) { if (args.Length != 1) { throw new CommandException("Invalid number of arguments, expected file name"); } DoChecks(api); var fileName = args[0]; if (!File.Exists(fileName)) { throw new CommandException("Provided file does not exist"); } if (!FileExistsCaseSensitive(fileName)) { throw new CommandException("Provided file case does not match real file name case"); } var extension = ScriptModule.ScriptExtension; if (!fileName.EndsWith(extension)) { throw new CommandException($"Provided file is not a compiled {extension} script"); } var abiFile = fileName.Replace(extension, ".abi"); if (!File.Exists(abiFile)) { throw new CommandException($"No ABI file {abiFile} that matches provided script file"); } var contractName = Path.GetFileNameWithoutExtension(fileName); var contractScript = File.ReadAllBytes(fileName); var abiBytes = File.ReadAllBytes(abiFile); var abi = ContractInterface.FromBytes(abiBytes); var sb = new ScriptBuilder(); int nexusVersion = 0; try { var nexusDetails = api.Execute("getNexus", new object[] { false }); var root = LunarLabs.Parser.JSON.JSONReader.ReadFromString(nexusDetails); var governance = root["governance"]; var entry = governance.Children.Where(x => x.GetNode("name").Value == "nexus.protocol.version").FirstOrDefault(); entry = entry.GetNodeByIndex(1); nexusVersion = Int32.Parse(entry.Value); } catch (Exception e) { Console.WriteLine(e); nexusVersion = -1; } if (nexusVersion <= 1) { throw new CommandException("Failed to obtain nexus version via API"); } bool isToken = ValidationUtils.IsValidTicker(contractName); var availableFlags = Enum.GetValues(typeof(TokenFlags)).Cast <TokenFlags>().ToArray(); sb.AllowGas(Keys.Address, Address.Null, minFee, 9999); if (isUpgrade) { // check for modification in flags if (isToken) { var symbol = contractName; var resultStr = api.Execute("getToken", new[] { symbol, "false" }); logger.Debug($"{resultStr}"); //2021.08.27 sfichera: Fixed api obj deserialization. //dynamic apiResult = System.Text.Json.JsonSerializer.Deserialize<TokenResult>(resultStr); dynamic apiResult = JsonConvert.DeserializeObject <TokenResult>(resultStr); if (apiResult is TokenResult) { var oldToken = (TokenResult)apiResult; var oldFlags = TokenFlags.None; var splitFlags = oldToken.flags.Split(','); foreach (var entry in splitFlags) { TokenFlags flag; if (Enum.TryParse <TokenFlags>(entry, true, out flag)) { oldFlags |= flag; } } foreach (var flag in availableFlags) { var propName = "is" + flag; if (abi.HasMethod(propName)) { var isSet = ExecuteScript(contractScript, abi, propName).AsBool(); var wasSet = oldFlags.HasFlag(flag); if (isSet != wasSet) { throw new CommandException($"Detected '{flag}' flag change: {wasSet} => {isSet}"); } } } } else { throw new CommandException("could not find any deployed token contract for " + symbol); } } sb.CallInterop("Runtime.UpgradeContract", Keys.Address, contractName, contractScript, abiBytes); } else if (isToken) { if (!abi.HasMethod("getName")) { throw new CommandException("token contract is missing required 'name' property"); } string symbol = null; if (nexusVersion < 6) { symbol = contractName; } else { if (abi.HasMethod("getSymbol")) { symbol = ExecuteScript(contractScript, abi, "getSymbol").AsString(); } if (string.IsNullOrEmpty(symbol)) { throw new CommandException("token contract 'symbol' property is either missing or returning an empty value"); } } var name = ExecuteScript(contractScript, abi, "getName").AsString(); if (string.IsNullOrEmpty(name)) { throw new CommandException("token contract 'name' property is either missing or returning an empty value"); } BigInteger maxSupply = abi.HasMethod("getMaxSupply") ? ExecuteScript(contractScript, abi, "getMaxSupply").AsNumber() : 0; BigInteger decimals = abi.HasMethod("getDecimals") ? ExecuteScript(contractScript, abi, "getDecimals").AsNumber() : 0; TokenFlags flags = TokenFlags.None; foreach (var flag in availableFlags) { var propName = "is" + flag; if (abi.HasMethod(propName) && ExecuteScript(contractScript, abi, propName).AsBool()) { flags |= flag; } } if (nexusVersion < 6) { sb.CallInterop("Nexus.CreateToken", Keys.Address, symbol, name, maxSupply, decimals, flags, contractScript, abiBytes); } else { sb.CallInterop("Nexus.CreateToken", Keys.Address, contractScript, abiBytes); } contractName = symbol; } else { sb.CallInterop("Runtime.DeployContract", Keys.Address, contractName, contractScript, abiBytes); } sb.SpendGas(Keys.Address); var script = sb.EndScript(); if (!isUpgrade) { var upgradeTrigger = AccountContract.GetTriggerForABI(AccountTrigger.OnUpgrade); if (abi.Implements(upgradeTrigger)) { logger.Message($"{contractName} implements proper triggers, and can be upgraded later."); } else { logger.Warning($"{contractName} does not implements proper triggers, can't be upgraded later."); } } var hash = ExecuteTransaction(settings, api, script, ProofOfWork.Minimal, Keys); if (hash != Hash.Null) { var expectedEvent = isUpgrade ? EventKind.ContractUpgrade : (isToken ? EventKind.TokenCreate : EventKind.ContractDeploy); var expectedEventStr = expectedEvent.ToString(); var events = GetTransactionEvents(hash); if (events.Any(x => x.kind == expectedEventStr)) { var contractAddress = SmartContract.GetAddressForName(contractName); string action = isUpgrade ? "Upgraded" : "Deployed"; logger.Message($"{action} {contractName} at {contractAddress}"); } else { throw new CommandException("Transaction was confirmed but deployment event is missing!"); } } }
internal UnscannedSubExprToken(InternalScriptExtent scriptExtent, TokenFlags tokenFlags, string value, BitArray skippedCharOffsets) : base(scriptExtent, tokenFlags, TokenKind.StringLiteral, value) { this.SkippedCharOffsets = skippedCharOffsets; }
internal LabelToken(InternalScriptExtent scriptExtent, TokenFlags tokenFlags, string labelText) : base(scriptExtent, TokenKind.Label, tokenFlags) { LabelText = labelText; }
internal VariableToken(InternalScriptExtent scriptExtent, VariablePath path, TokenFlags tokenFlags, bool splatted) : base(scriptExtent, splatted ? TokenKind.SplattedVariable : TokenKind.Variable, tokenFlags) { VariablePath = path; }
/// <summary> /// Constructor /// </summary> public Token(string InText, TokenType InType, TokenFlags InFlags) { Text = InText; Type = InType; Flags = InFlags; }
public void CreateToken(Address from, string symbol, string name, string platform, Hash hash, BigInteger maxSupply, BigInteger decimals, TokenFlags flags, byte[] script) { var pow = Runtime.Transaction.Hash.GetDifficulty(); Runtime.Expect(pow >= (int)ProofOfWork.Minimal, "expected proof of work"); Runtime.Expect(!string.IsNullOrEmpty(symbol), "token symbol required"); Runtime.Expect(!string.IsNullOrEmpty(name), "token name required"); Runtime.Expect(maxSupply >= 0, "token supply cant be negative"); Runtime.Expect(decimals >= 0, "token decimals cant be negative"); Runtime.Expect(decimals <= MAX_TOKEN_DECIMALS, $"token decimals cant exceed {MAX_TOKEN_DECIMALS}"); Runtime.Expect(!Runtime.Nexus.TokenExists(symbol), "token already exists"); if (symbol == Nexus.FuelTokenSymbol) { Runtime.Expect(flags.HasFlag(TokenFlags.Fuel), "token should be native"); } else { Runtime.Expect(!flags.HasFlag(TokenFlags.Fuel), "token can't be native"); } if (symbol == Nexus.StakingTokenSymbol) { Runtime.Expect(flags.HasFlag(TokenFlags.Stakable), "token should be stakable"); } if (symbol == Nexus.FiatTokenSymbol) { Runtime.Expect(flags.HasFlag(TokenFlags.Fiat), "token should be fiat"); } Runtime.Expect(!string.IsNullOrEmpty(platform), "chain name required"); if (flags.HasFlag(TokenFlags.External)) { Runtime.Expect(from == Runtime.Nexus.GenesisAddress, "genesis address only"); Runtime.Expect(platform != Nexus.PlatformName, "external token chain required"); Runtime.Expect(Runtime.Nexus.PlatformExists(platform), "platform not found"); } else { Runtime.Expect(platform == Nexus.PlatformName, "chain name is invalid"); } Runtime.Expect(IsWitness(from), "invalid witness"); Runtime.Expect(from.IsUser, "owner address must be user address"); Runtime.Expect(this.Runtime.Nexus.CreateToken(symbol, name, platform, hash, maxSupply, (int)decimals, flags, script), "token creation failed"); Runtime.Notify(EventKind.TokenCreate, from, symbol); }
internal StringToken(InternalScriptExtent scriptExtent, TokenKind kind, TokenFlags tokenFlags, string value) : base(scriptExtent, kind, tokenFlags) { this._value = value; }
internal NumberToken(InternalScriptExtent scriptExtent, object value, TokenFlags tokenFlags) : base(scriptExtent, TokenKind.Number, tokenFlags) { _value = value; }
internal TokenInfo(string tokenString, TokenFlags flags) { _tokenString = tokenString; _flags = flags; _precedence = TokenInfo.InvalidPrecedence; }
internal StringExpandableToken(InternalScriptExtent scriptExtent, TokenKind tokenKind, string value, string formatString, List <Token> nestedTokens, TokenFlags flags) : base(scriptExtent, tokenKind, flags, value) { if ((nestedTokens != null) && nestedTokens.Any <Token>()) { this._nestedTokens = new ReadOnlyCollection <Token>(nestedTokens.ToArray()); } this._formatString = formatString; }
private Transaction TokenCreateTx(Chain chain, KeyPair owner, string symbol, string name, BigInteger totalSupply, int decimals, TokenFlags flags, bool useGas) { var sb = ScriptUtils.BeginScript(); if (useGas) { sb.AllowGas(owner.Address, Address.Null, 1, 9999); } sb.CallContract(ScriptBuilderExtensions.NexusContract, "CreateToken", owner.Address, symbol, name, totalSupply, decimals, flags); if (symbol == StakingTokenSymbol) { sb.CallContract(ScriptBuilderExtensions.TokenContract, "MintTokens", owner.Address, symbol, UnitConversion.ToBigInteger(8863626, StakingTokenDecimals)); } else if (symbol == FuelTokenSymbol) { // requires staking token to be created previously // note this is a completly arbitrary number just to be able to generate energy in the genesis, better change it later sb.CallContract(ScriptBuilderExtensions.EnergyContract, "Stake", owner.Address, UnitConversion.ToBigInteger(100000, StakingTokenDecimals)); sb.CallContract(ScriptBuilderExtensions.EnergyContract, "Claim", owner.Address, owner.Address); } if (useGas) { sb.SpendGas(owner.Address); } var script = sb.EndScript(); var tx = new Transaction(Name, chain.Name, script, Timestamp.Now + TimeSpan.FromDays(300)); tx.Sign(owner); return(tx); }
public bool CreateToken(string symbol, string name, string platform, Hash hash, BigInteger maxSupply, int decimals, TokenFlags flags, byte[] script) { return(Nexus.CreateToken(symbol, name, platform, hash, maxSupply, decimals, flags, script)); }
internal Token(Address owner, string symbol, string name, BigInteger maxSupply, int decimals, TokenFlags flags) { Throw.If(maxSupply < 0, "negative supply"); Throw.If(maxSupply == 0 && flags.HasFlag(TokenFlags.Finite), "finite requires a supply"); Throw.If(maxSupply > 0 && !flags.HasFlag(TokenFlags.Finite), "infinite requires no supply"); if (!flags.HasFlag(TokenFlags.Fungible)) { Throw.If(flags.HasFlag(TokenFlags.Divisible), "non-fungible token must be indivisible"); } if (flags.HasFlag(TokenFlags.Divisible)) { Throw.If(decimals <= 0, "divisible token must have decimals"); } else { Throw.If(decimals > 0, "indivisible token can't have decimals"); } this.Owner = owner; this.Symbol = symbol; this.Name = name; this.MaxSupply = maxSupply; this.Decimals = decimals; this.Flags = flags; _supply = 0; }
private Transaction TokenCreateTx(Chain chain, KeyPair owner, string symbol, string name, BigInteger totalSupply, int decimals, TokenFlags flags) { var sb = ScriptUtils.BeginScript(); if (symbol != FuelTokenSymbol) { sb.AllowGas(owner.Address, Address.Null, 1, 9999); } sb.CallContract(ScriptBuilderExtensions.NexusContract, "CreateToken", owner.Address, symbol, name, totalSupply, decimals, flags); if (symbol == FuelTokenSymbol) { sb.CallContract(ScriptBuilderExtensions.TokenContract, "MintTokens", owner.Address, symbol, totalSupply); sb.AllowGas(owner.Address, Address.Null, 1, 9999); // done here only because before fuel token does not exist yet! } else if (symbol == StakingTokenSymbol) { sb.CallContract(ScriptBuilderExtensions.TokenContract, "MintTokens", owner.Address, symbol, UnitConversion.ToBigInteger(8863626, StakingTokenDecimals)); } var script = sb.SpendGas(owner.Address).EndScript(); var tx = new Transaction(Name, chain.Name, script, Timestamp.Now + TimeSpan.FromDays(300)); tx.Sign(owner); return(tx); }
internal LabelToken(InternalScriptExtent scriptExtent, TokenFlags tokenFlags, string labelText) : base(scriptExtent, TokenKind.Label, tokenFlags) { this._labelText = labelText; }
internal bool CreateToken(Address owner, string symbol, string name, BigInteger maxSupply, int decimals, TokenFlags flags, byte[] script) { if (symbol == null || name == null || maxSupply < 0) { return(false); } symbol = symbol.ToUpper(); // check if already exists something with that name if (TokenExists(symbol)) { return(false); } Throw.If(maxSupply < 0, "negative supply"); Throw.If(maxSupply == 0 && flags.HasFlag(TokenFlags.Finite), "finite requires a supply"); Throw.If(maxSupply > 0 && !flags.HasFlag(TokenFlags.Finite), "infinite requires no supply"); if (!flags.HasFlag(TokenFlags.Fungible)) { Throw.If(flags.HasFlag(TokenFlags.Divisible), "non-fungible token must be indivisible"); } if (flags.HasFlag(TokenFlags.Divisible)) { Throw.If(decimals <= 0, "divisible token must have decimals"); } else { Throw.If(decimals > 0, "indivisible token can't have decimals"); } var tokenInfo = new TokenInfo(owner, symbol, name, maxSupply, decimals, flags, script); EditToken(symbol, tokenInfo); // add to persistent list of tokens var tokenList = this.Tokens.ToList(); tokenList.Add(symbol); this.Tokens = tokenList; return(true); }
internal Token CreateToken(Address owner, string symbol, string name, BigInteger maxSupply, int decimals, TokenFlags flags) { if (symbol == null || name == null || maxSupply < 0) { return(null); } // check if already exists something with that name var temp = FindTokenBySymbol(symbol); if (temp != null) { return(null); } var token = new Token(owner, symbol, name, maxSupply, decimals, flags); if (symbol == FuelTokenSymbol) { FuelToken = token; } else if (symbol == StakingTokenSymbol) { StakingToken = token; } else if (symbol == StableTokenSymbol) { StableToken = token; } _tokens[symbol] = token; return(token); }
public void CreateToken(Address owner, string symbol, string name, BigInteger maxSupply, BigInteger decimals, TokenFlags flags, byte[] script) { Runtime.Expect(!string.IsNullOrEmpty(symbol), "token symbol required"); Runtime.Expect(!string.IsNullOrEmpty(name), "token name required"); Runtime.Expect(maxSupply >= 0, "token supply cant be negative"); Runtime.Expect(decimals >= 0, "token decimals cant be negative"); Runtime.Expect(decimals <= MAX_TOKEN_DECIMALS, $"token decimals cant exceed {MAX_TOKEN_DECIMALS}"); if (symbol == Nexus.FuelTokenSymbol) { Runtime.Expect(flags.HasFlag(TokenFlags.Fuel), "token should be native"); } else { Runtime.Expect(!flags.HasFlag(TokenFlags.Fuel), "token can't be native"); } if (symbol == Nexus.StakingTokenSymbol) { Runtime.Expect(flags.HasFlag(TokenFlags.Stakable), "token should be stakable"); } if (symbol == Nexus.StableTokenSymbol) { Runtime.Expect(flags.HasFlag(TokenFlags.Stable), "token should be stable"); } if (flags.HasFlag(TokenFlags.External)) { Runtime.Expect(owner == Runtime.Nexus.GenesisAddress, "external token not permitted"); } Runtime.Expect(IsWitness(owner), "invalid witness"); symbol = symbol.ToUpperInvariant(); Runtime.Expect(this.Runtime.Nexus.CreateToken(owner, symbol, name, maxSupply, (int)decimals, flags, script), "token creation failed"); Runtime.Notify(EventKind.TokenCreate, owner, symbol); }
public Transaction GenerateToken(PhantasmaKeys owner, string symbol, string name, BigInteger totalSupply, int decimals, TokenFlags flags, byte[] tokenScript = null) { if (tokenScript == null) { // small script that restricts minting of tokens to transactions where the owner is a witness var addressStr = Base16.Encode(owner.Address.ToByteArray()); var scriptString = new string[] { $"alias r1, $triggerMint", $"alias r2, $currentTrigger", $"alias r3, $result", $"alias r4, $owner", $@"load $triggerMint, ""{AccountTrigger.OnMint}""", $"pop $currentTrigger", $"equal $triggerMint, $currentTrigger, $result", $"jmpif $result, @mintHandler", $"jmp @end", $"@mintHandler: nop", $"load $owner 0x{addressStr}", "push $owner", "extcall \"Address()\"", "extcall \"Runtime.IsWitness\"", "pop $result", $"jmpif $result, @end", $"throw", $"@end: ret" }; tokenScript = AssemblerUtils.BuildScript(scriptString); } var script = ScriptUtils. BeginScript(). AllowGas(owner.Address, Address.Null, MinimumFee, 9999). CallInterop("Nexus.CreateToken", owner.Address, symbol, name, totalSupply, decimals, flags, tokenScript). SpendGas(owner.Address). EndScript(); var tx = MakeTransaction(owner, ProofOfWork.Minimal, Nexus.RootChain, script); return tx; }
public void CreateToken(Address from, string symbol, string name, BigInteger maxSupply, int decimals, TokenFlags flags, byte[] script) { var Runtime = this; Runtime.Expect(Runtime.IsRootChain(), "must be root chain"); var pow = Runtime.Transaction.Hash.GetDifficulty(); Runtime.Expect(pow >= (int)ProofOfWork.Minimal, "expected proof of work"); Runtime.Expect(!string.IsNullOrEmpty(symbol), "token symbol required"); Runtime.Expect(!string.IsNullOrEmpty(name), "token name required"); Runtime.Expect(ValidationUtils.IsValidTicker(symbol), "invalid symbol"); Runtime.Expect(!Runtime.TokenExists(symbol), "token already exists"); Runtime.Expect(maxSupply >= 0, "token supply cant be negative"); Runtime.Expect(decimals >= 0, "token decimals cant be negative"); Runtime.Expect(decimals <= DomainSettings.MAX_TOKEN_DECIMALS, $"token decimals cant exceed {DomainSettings.MAX_TOKEN_DECIMALS}"); if (symbol == DomainSettings.FuelTokenSymbol) { Runtime.Expect(flags.HasFlag(TokenFlags.Fuel), "token should be native"); } else { Runtime.Expect(!flags.HasFlag(TokenFlags.Fuel), "token can't be native"); } if (symbol == DomainSettings.StakingTokenSymbol) { Runtime.Expect(flags.HasFlag(TokenFlags.Stakable), "token should be stakable"); } if (symbol == DomainSettings.FiatTokenSymbol) { Runtime.Expect(flags.HasFlag(TokenFlags.Fiat), "token should be fiat"); } if (!flags.HasFlag(TokenFlags.Fungible)) { Runtime.Expect(!flags.HasFlag(TokenFlags.Divisible), "non-fungible token must be indivisible"); } if (flags.HasFlag(TokenFlags.Divisible)) { Runtime.Expect(decimals > 0, "divisible token must have decimals"); } else { Runtime.Expect(decimals == 0, "indivisible token can't have decimals"); } Runtime.Expect(from.IsUser, "owner address must be user address"); Runtime.Expect(Runtime.IsStakeMaster(from), "needs to be master"); Runtime.Expect(Runtime.IsWitness(from), "invalid witness"); Nexus.CreateToken(RootStorage, symbol, name, maxSupply, decimals, flags, script); Runtime.Notify(EventKind.TokenCreate, from, symbol); }
/// <summary> /// Reads a single token from a text buffer /// </summary> /// <param name="Text">The text buffer to read from</param> /// <param name="LineIdx">The current line index</param> /// <param name="ColumnIdx">The current column index</param> /// <param name="Flags">Flags for the new token</param> /// <returns>The next token, or null at the end of the file</returns> static bool ReadToken(TextBuffer Text, ref int LineIdx, ref int ColumnIdx, TokenFlags Flags, TokenReaderContext Context, out Token Result) { int StartLineIdx = LineIdx; int StartColumnIdx = ColumnIdx; char Character = Text.ReadCharacter(ref LineIdx, ref ColumnIdx); if (Character == '\0') { Result = new Token("", TokenType.Placemarker, Flags); return(false); } else if (Context.HasFlag(TokenReaderContext.TokenString)) { // Raw token string until the end of the current line StringBuilder Builder = new StringBuilder(); if (Character == '\n') { LineIdx = StartLineIdx; ColumnIdx = StartColumnIdx; } else { Builder.Append(Character); for (;;) { Character = Text[LineIdx, ColumnIdx]; if (Character == '\n') { break; } Builder.Append(Character); if (!Text.MoveNext(ref LineIdx, ref ColumnIdx)) { break; } } } Result = new Token(Builder.ToString().TrimEnd(), TokenType.StringOfTokens, Flags); return(true); } else if (Character == '\'') { // Character literal SkipTextLiteral(Text, ref LineIdx, ref ColumnIdx, '\''); Result = new Token(Text.ExtractString(StartLineIdx, StartColumnIdx, LineIdx, ColumnIdx), TokenType.CharacterLiteral, Flags); return(true); } else if (Character == '\"') { // String literal SkipTextLiteral(Text, ref LineIdx, ref ColumnIdx, '\"'); Result = new Token(Text.ExtractString(StartLineIdx, StartColumnIdx, LineIdx, ColumnIdx), TokenType.StringLiteral, Flags); return(true); } else if ((Character >= 'a' && Character <= 'z') || (Character >= 'A' && Character <= 'Z') || Character == '_') { // Identifier (or text literal with prefix) for (;;) { Character = Text[LineIdx, ColumnIdx]; if ((Character < 'a' || Character > 'z') && (Character < 'A' || Character > 'Z') && (Character < '0' || Character > '9') && Character != '_' && Character != '$') { break; } Text.MoveNext(ref LineIdx, ref ColumnIdx); } // Check if it's a prefixed text literal if (Character == '\'') { Text.MoveNext(ref LineIdx, ref ColumnIdx); SkipTextLiteral(Text, ref LineIdx, ref ColumnIdx, '\''); Result = new Token(Text.ExtractString(StartLineIdx, StartColumnIdx, LineIdx, ColumnIdx), TokenType.CharacterLiteral, Flags); return(true); } else if (Character == '\"') { Text.MoveNext(ref LineIdx, ref ColumnIdx); SkipTextLiteral(Text, ref LineIdx, ref ColumnIdx, '\"'); Result = new Token(Text.ExtractString(StartLineIdx, StartColumnIdx, LineIdx, ColumnIdx), TokenType.StringLiteral, Flags); return(true); } else { Result = new Token(Text.ExtractString(StartLineIdx, StartColumnIdx, LineIdx, ColumnIdx), TokenType.Identifier, Flags); return(true); } } else if ((Character >= '0' && Character <= '9') || (Character == '.' && (Text[LineIdx, ColumnIdx] >= '0' && Text[LineIdx, ColumnIdx] <= '9'))) { // pp-number token char LastCharacter = Character; for (;;) { Character = Text[LineIdx, ColumnIdx]; if ((Character < 'a' || Character > 'z') && (Character < 'A' || Character > 'Z') && (Character < '0' || Character > '9') && Character != '_' && Character != '$' && Character != '\'') { if ((Character != '+' && Character != '-') || (LastCharacter != 'e' && LastCharacter != 'E')) { break; } } LastCharacter = Text.ReadCharacter(ref LineIdx, ref ColumnIdx); } Result = new Token(Text.ExtractString(StartLineIdx, StartColumnIdx, LineIdx, ColumnIdx), TokenType.NumericLiteral, Flags); return(true); } else if (Character == '<' && Context.HasFlag(TokenReaderContext.IncludeDirective)) { StringBuilder Builder = new StringBuilder("<"); while (Builder[Builder.Length - 1] != '>') { Builder.Append(Text[LineIdx, ColumnIdx]); ColumnIdx++; } Result = new Token(Builder.ToString(), TokenType.SystemInclude, Flags); return(true); } else { // Try to read a symbol if (ColumnIdx > 0) { for (int Idx = 0; Idx < SymbolicTokens.Length; Idx++) { string SymbolicToken = SymbolicTokens[Idx]; for (int Length = 0; Text[LineIdx, ColumnIdx + Length - 1] == SymbolicToken[Length]; Length++) { if (Length + 1 == SymbolicToken.Length) { ColumnIdx += Length; Result = new Token(SymbolicToken, TokenType.Symbol, Flags); return(true); } } } } // Otherwise just return a single character TokenType Type; switch (Character) { case '(': Type = TokenType.LeftParen; break; case ')': Type = TokenType.RightParen; break; case ',': Type = TokenType.Comma; break; default: Type = TokenType.Symbol; break; } Result = new Token(Character.ToString(), Type, Flags); return(true); } }
internal TokenInfo(Address owner, string symbol, string name, BigInteger maxSupply, int decimals, TokenFlags flags) { this.Owner = owner; this.Symbol = symbol; this.Name = name; this.Flags = flags; this.Decimals = decimals; this.MaxSupply = maxSupply; }
public Transaction GenerateToken(PhantasmaKeys owner, string symbol, string name, BigInteger totalSupply, int decimals, TokenFlags flags, byte[] tokenScript = null, Dictionary <string, int> labels = null, IEnumerable <ContractMethod> customMethods = null, uint seriesID = 0) { var version = _cli.Nexus.GetGovernanceValue(_cli.Nexus.RootStorage, Nexus.NexusProtocolVersionTag); labels ??= new Dictionary <string, int>(); if (tokenScript == null) { // small script that restricts minting of tokens to transactions where the owner is a witness var addressStr = Base16.Encode(owner.Address.ToByteArray()); string[] scriptString; if (version >= 4) { scriptString = new[] { $"alias r3, $result", $"alias r4, $owner", $"@{AccountTrigger.OnMint}: nop", $"load $owner 0x{addressStr}", "push $owner", "extcall \"Address()\"", "extcall \"Runtime.IsWitness\"", "pop $result", $"jmpif $result, @end", $"load r0 \"invalid witness\"", $"throw r0", $"@getOwner: nop", $"load $owner 0x{addressStr}", "push $owner", $"jmp @end", $"@getSymbol: nop", $"load r0 \"" + symbol + "\"", "push r0", $"jmp @end", $"@getName: nop", $"load r0 \"" + name + "\"", "push r0", $"jmp @end", $"@getMaxSupply: nop", $"load r0 " + totalSupply + "", "push r0", $"jmp @end", $"@getDecimals: nop", $"load r0 " + decimals + "", "push r0", $"jmp @end", $"@getTokenFlags: nop", $"load r0 " + (int)flags + "", "push r0", $"jmp @end", $"@end: ret" }; } else { scriptString = new string[] { $"alias r1, $triggerMint", $"alias r2, $currentTrigger", $"alias r3, $result", $"alias r4, $owner", $@"load $triggerMint, ""{AccountTrigger.OnMint}""", $"pop $currentTrigger", $"equal $triggerMint, $currentTrigger, $result", $"jmpif $result, @mintHandler", $"jmp @end", $"@mintHandler: nop", $"load $owner 0x{addressStr}", "push $owner", "extcall \"Address()\"", "extcall \"Runtime.IsWitness\"", "pop $result", $"jmpif $result, @end", $"load r0 \"invalid witness\"", $"throw r0", $"@end: ret" }; } DebugInfo debugInfo; tokenScript = AssemblerUtils.BuildScript(scriptString, "GenerateToken", out debugInfo, out labels); } var sb = ScriptUtils. BeginScript(). AllowGas(owner.Address, Address.Null, 100000, 9999); if (version >= 4) { var triggerMap = new Dictionary <AccountTrigger, int>(); var onMintLabel = AccountTrigger.OnMint.ToString(); if (labels.ContainsKey(onMintLabel)) { triggerMap[AccountTrigger.OnMint] = labels[onMintLabel]; } var methods = AccountContract.GetTriggersForABI(triggerMap); if (version >= 6) { methods = methods.Concat(new ContractMethod[] { new ("getOwner", VMType.Object, labels, new ContractParameter[0]), new ("getSymbol", VMType.String, labels, new ContractParameter[0]), new ("getName", VMType.String, labels, new ContractParameter[0]), new ("getDecimals", VMType.Number, labels, new ContractParameter[0]), new ("getMaxSupply", VMType.Number, labels, new ContractParameter[0]), new ("getTokenFlags", VMType.Enum, labels, new ContractParameter[0]), });
internal Token(InternalScriptExtent scriptExtent, TokenKind kind, TokenFlags tokenFlags) { _scriptExtent = scriptExtent; _kind = kind; _tokenFlags = tokenFlags | kind.GetTraits(); }
public Transaction GenerateToken(PhantasmaKeys owner, string symbol, string name, BigInteger totalSupply, int decimals, TokenFlags flags, byte[] tokenScript = null, Dictionary <string, int> labels = null, IEnumerable <ContractMethod> customMethods = null) { var version = Nexus.GetGovernanceValue(Nexus.RootStorage, Nexus.NexusProtocolVersionTag); if (labels == null) { labels = new Dictionary <string, int>(); } if (tokenScript == null) { // small script that restricts minting of tokens to transactions where the owner is a witness var addressStr = Base16.Encode(owner.Address.ToByteArray()); string[] scriptString; if (version >= 4) { scriptString = new string[] { $"alias r3, $result", $"alias r4, $owner", $"@{AccountTrigger.OnMint}: nop", $"load $owner 0x{addressStr}", "push $owner", "extcall \"Address()\"", "extcall \"Runtime.IsWitness\"", "pop $result", $"jmpif $result, @end", $"load r0 \"invalid witness\"", $"throw r0", $"@end: ret" }; } else { scriptString = new string[] { $"alias r1, $triggerMint", $"alias r2, $currentTrigger", $"alias r3, $result", $"alias r4, $owner", $@"load $triggerMint, ""{AccountTrigger.OnMint}""", $"pop $currentTrigger", $"equal $triggerMint, $currentTrigger, $result", $"jmpif $result, @mintHandler", $"jmp @end", $"@mintHandler: nop", $"load $owner 0x{addressStr}", "push $owner", "extcall \"Address()\"", "extcall \"Runtime.IsWitness\"", "pop $result", $"jmpif $result, @end", $"load r0 \"invalid witness\"", $"throw r0", $"@end: ret" }; } DebugInfo debugInfo; tokenScript = AssemblerUtils.BuildScript(scriptString, "GenerateToken", out debugInfo, out labels); } var sb = ScriptUtils. BeginScript(). AllowGas(owner.Address, Address.Null, MinimumFee, 9999); if (version >= 4) { var triggerMap = new Dictionary <AccountTrigger, int>(); var onMintLabel = AccountTrigger.OnMint.ToString(); if (labels.ContainsKey(onMintLabel)) { triggerMap[AccountTrigger.OnMint] = labels[onMintLabel]; } var methods = AccountContract.GetTriggersForABI(triggerMap); if (customMethods != null) { methods = methods.Concat(customMethods); } var abi = new ContractInterface(methods, Enumerable.Empty <ContractEvent>()); var abiBytes = abi.ToByteArray(); sb.CallInterop("Nexus.CreateToken", owner.Address, symbol, name, totalSupply, decimals, flags, tokenScript, abiBytes); } else { sb.CallInterop("Nexus.CreateToken", owner.Address, symbol, name, totalSupply, decimals, flags, tokenScript); } if (!flags.HasFlag(TokenFlags.Fungible)) { ContractInterface nftABI; byte[] nftScript; NFTUtils.GenerateNFTDummyScript(symbol, name, name, "http://simulator/nft/*", "http://simulator/img/*", out nftScript, out nftABI); sb.CallInterop("Nexus.CreateTokenSeries", owner.Address, symbol, new BigInteger(0), totalSupply, TokenSeriesMode.Unique, nftScript, nftABI.ToByteArray()); } sb.SpendGas(owner.Address); var script = sb.EndScript(); var tx = MakeTransaction(owner, ProofOfWork.Minimal, Nexus.RootChain, script); return(tx); }
internal VariableToken(InternalScriptExtent scriptExtent, System.Management.Automation.VariablePath path, TokenFlags tokenFlags, bool splatted) : base(scriptExtent, splatted ? TokenKind.SplattedVariable : TokenKind.Variable, tokenFlags) { this.VariablePath = path; }