public override void ReadWrite(BitcoinStream stream)
{
if (stream.Serializing)
{
var ms = new MemoryStream();
var bs = new BitcoinStream(ms, true)
{
Type = SerializationType.Hash
};
bs.ReadWrite(new VarString(Encoding.UTF8.GetBytes(Code)));
bs.ReadWrite(new VarString(Encoding.UTF8.GetBytes(Name)));
var packBytes = ms.ToArray();
stream.ReadWriteAsVarString(ref packBytes);
}
else
{
var packVar = new VarString();
stream.ReadWrite(ref packVar);
var bs = new BitcoinStream(packVar.GetString());
var codeVar = new VarString();
bs.ReadWrite(ref codeVar);
var nameVar = new VarString();
bs.ReadWrite(ref nameVar);
Code = Encoding.UTF8.GetString(codeVar.GetString());
Name = Encoding.UTF8.GetString(nameVar.GetString());
}
}
internal void SubspaceReceive(string channel, string type, string data)
{
string hook = (string)(VarString)channel;
foreach (KeyValuePair <int, Language.Program> kv in programs)
{
var their_net = kv.Value.scope.globals.meta.string_vars["_parent"].string_vars["net"].string_vars;
if (their_net["connections"].string_vars.ContainsKey(hook))
{
VarList args = new VarList();
Var bc_dat = Var.nil;
if (type == "text")
{
bc_dat = new VarString(data);
}
else if (type == "num")
{
bc_dat = new VarNumber(double.Parse(data));
}
else
{
bc_dat = new VarList();
(bc_dat as VarList).privateVariables["subspace_ref"] = data;
}
args.number_vars[0] = bc_dat;
args.string_vars["message"] = bc_dat;
their_net["connections"].string_vars[hook].Call(kv.Value.scope, new Dictionary <int, Var>(), 0, args);
}
}
}
public Raw(byte[] data)
{
var str = new VarString();
str.FromBytes(data);
_Data = str.GetString(true);
}
protected internal override void OnEnter(IFsm <IProcedureManager> procedureOwner)
{
base.OnEnter(procedureOwner);
//根据绝对路径设置与获取数据
DataNodeComponent dataComponent = GameEntry.GetComponent <DataNodeComponent>();
VarString var1 = new VarString();
var1.SetValue("Ellan");
dataComponent.SetData <VarString> ("Player.Name", var1);
string playerName = dataComponent.GetData <LocalVariable <string> >("Player.Name").Value;
Log.Info(playerName);
//根据相对路径设置与获取数据
IDataNode playerNode = dataComponent.GetNode("Player");
VarInt var2 = new VarInt();
var2.SetValue(99);
dataComponent.SetData <VarInt>("Level", var2, playerNode);
int playerLevel = dataComponent.GetData <VarInt>("Level", playerNode).Value;
Log.Info(playerLevel);
//直接通过数据结点来操作
VarInt var3 = new VarInt();
var3.SetValue(1000);
IDataNode playerExpNode = playerNode.GetOrAddChild("Exp");
playerExpNode.SetData(var3);
int playerExp = playerExpNode.GetData <VarInt>().Value;
Log.Info(playerExp);
}
public string Visit(VarString node)
{
var v = node.AnchorToken.Lexeme;
var sz = v.Length;
var st = "";
st += "\t\tldc.i4 " + sz + "\n";
st += "\t\tcall int32 class ['deeplingolib']'DeepLingo'.'Utils'::'New'(int32)\n";
// st += tab(2) + "ldstr "+node.AnchorToken.Lexeme+"\n";
// st += tab(2) + "call int32 class ['deeplingolib']'DeepLingo'.'Utils'::'Conv'(string)\n";
for (var i = 1; i < sz - 1; i++)
{
var intAdded = (int)v[i];
if (i + 1 < sz - 1 && en.ContainsKey(v.Substring(i, 2)))
{
intAdded = en[v.Substring(i, 2)];
i += 1;
}
else if (i + 7 < sz - 1 && v.Substring(i, 2) == @"\u")
{
intAdded = getCode(v.Substring(i + 2, 6));
i += 7;
}
st += "\t\tdup\n";
st += "\t\tldc.i4 " + intAdded + "\n";
st += "\t\tcall int32 class ['deeplingolib']'DeepLingo'.'Utils'::'Add'(int32,int32)\n";
st += "\t\tpop\n";
}
return(st);
}
private void UpdatePayload(BitcoinStream stream)
{
MemoryStream ms = new MemoryStream();
var seria = new BitcoinStream(ms, true);
seria.CopyParameters(stream);
this.ReadWritePayloadFields(seria);
this.payload = new VarString(ms.ToArray());
}
// FIXME: why do we need version parameter?
// it shouldn't be called "version" because the it a field with the same name
public void UpdateSignature(Key key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
this.UpdatePayload();
this.signature = new VarString(key.Sign(Hashes.Hash256(this.payload.GetString())).ToDER());
}
public void ReadWriteAsVarString(ref byte[] bytes)
{
if (Serializing)
{
VarString.StaticWrite(this, bytes);
}
else
{
VarString.StaticRead(this, ref bytes);
}
}
public void ReadWrite(ref string str)
{
VarString tempVarString = new VarString(string.IsNullOrEmpty(str) ? new byte[0] : UTF8Encoding.UTF8.GetBytes(str));
this.ReadWrite(ref tempVarString);
if (!this.Serializing)
{
str = Encoding.UTF8.GetString(tempVarString.GetString());
}
}
void createRejectPayload()
{
List <byte> rejectPayload = new List <byte>();
rejectPayload.AddRange(VarString.GetBytes(MessageTypeRejected));
rejectPayload.Add((byte)RejectionCode);
rejectPayload.AddRange(VarString.GetBytes(RejectionReason));
rejectPayload.AddRange(ExtraData);
Payload = rejectPayload.ToArray();
}
public void Read()
{
foreach (var str in Strings)
{
byte[] full = ArrayHelpers.ConcatArrays(str.Item2, Encoding.ASCII.GetBytes(str.Item1));
using (BinaryReader reader = new BinaryReader(new MemoryStream(full))) {
VarString v = VarString.Read(reader);
Assert.AreEqual(str.Item1, v.Value);
}
}
}
private static void InitCustomDataNode()
{
VarBool isBind = new VarBool(false);
DataNode.SetData(Constant.DataNode.IsWXBind, isBind);
VarString v_userId = new VarString("");
DataNode.SetData(Constant.DataNode.UserId, v_userId);
VarUInt v_score = new VarUInt(0);
DataNode.SetData(Constant.DataNode.UserScore, v_score);
}
void deserializePayload()
{
int startIndex = 0;
MessageTypeRejected = VarString.GetString(Payload, ref startIndex);
RejectionCode = Payload[startIndex];
startIndex += 1;
RejectionReason = VarString.GetString(Payload, ref startIndex);
deserializeExtraData(ref startIndex);
}
void DeserializePayload()
{
int startIndex = 0;
ProtocolVersion = BitConverter.ToUInt32(Payload, startIndex);
startIndex += 4;
NetworkServicesLocal = BitConverter.ToUInt64(Payload, startIndex);
startIndex += 8;
UnixTimeSeconds = BitConverter.ToInt64(Payload, startIndex);
startIndex += 8;
NetworkServicesRemote = BitConverter.ToUInt64(Payload, startIndex);
startIndex += 8;
IPAddressRemote = new IPAddress(Payload.Skip(startIndex).Take(16).ToArray());
startIndex += 16;
PortRemote = BitConverter.ToUInt16(Payload, startIndex);
startIndex += 2;
// This is ignored as it is the same as above
// NetworkServicesLocal = BitConverter.ToUInt64(Payload, startIndex);
startIndex += 8;
IPAddressLocal = new IPAddress(Payload.Skip(startIndex).Take(16).ToArray());
startIndex += 16;
PortLocal = BitConverter.ToUInt16(Payload, startIndex);
startIndex += 2;
Nonce = BitConverter.ToUInt64(Payload, startIndex);
startIndex += 8;
UserAgent = VarString.GetString(Payload, ref startIndex);
BlockchainHeight = BitConverter.ToInt32(Payload, startIndex);
startIndex += 4;
if (startIndex == Payload.Length)
{
RelayOption = 0x01;
}
else
{
RelayOption = Payload[startIndex];
startIndex += 1;
}
}
public void ReadWriteAsVarString(ref byte[] bytes)
{
if (Serializing)
{
VarString str = new VarString(bytes);
str.ReadWrite(this);
}
else
{
VarString str = new VarString();
str.ReadWrite(this);
bytes = str.GetString(true);
}
}
private void writeString(VarString value, bool prepend)
{
byte[] data = _encoder.GetBytes(value);
writeVarInt(data.Length, prepend);
if (prepend)
{
_data.InsertRange(0, data);
}
else
{
_data.AddRange(data);
}
}
public void Write() {
foreach(var str in Strings) {
using(MemoryStream stream = new MemoryStream()) {
using(BinaryWriter writer = new BinaryWriter(stream)) {
Console.WriteLine(str.Item1);
byte[] fullPayload = ArrayHelpers.ConcatArrays(str.Item2, Encoding.ASCII.GetBytes(str.Item1));
VarString v = new VarString(str.Item1);
v.Write(writer);
Assert.AreEqual(stream.ToArray(), fullPayload);
}
}
}
}
public override void ReadPayload(BinaryReader reader)
{
Version = reader.ReadInt32();
AvailableServices = (Services)reader.ReadUInt64();
Time = UnixTime.DateTimeFromUnixTime(reader.ReadInt64());
Recipient = NetworkNode.FromBinaryReader(reader);
Sender = NetworkNode.FromBinaryReader(reader);
Nonce = reader.ReadUInt64();
UserAgent = VarString.Read(reader).Value;
BlockHeight = reader.ReadInt32();
Relay = (Version >= 70001) && reader.ReadBoolean(); // BIP 0037
}
public Script ReadWrite(Script data)
{
if (Serializing)
{
var bytes = data == null?Script.Empty.ToBytes(true) : data.ToBytes(true);
ReadWriteAsVarString(ref bytes);
return(data);
}
else
{
var varString = new VarString();
varString.ReadWrite(this);
return(Script.FromBytesUnsafe(varString.GetString(true)));
}
}
public Script ReadWrite(Script data)
{
if (Serializing)
{
var bytes = data == null?Script.Empty.ToBytes(true) : data.ToBytes(true);
ReadWriteAsVarString(ref bytes);
return(data);
}
else
{
byte[] bytes = null;
VarString.StaticRead(this, ref bytes);
return(Script.FromBytesUnsafe(bytes));
}
}
public void Write()
{
foreach (var str in Strings)
{
using (MemoryStream stream = new MemoryStream()) {
using (BinaryWriter writer = new BinaryWriter(stream)) {
Console.WriteLine(str.Item1);
byte[] fullPayload = ArrayHelpers.ConcatArrays(str.Item2, Encoding.ASCII.GetBytes(str.Item1));
VarString v = new VarString(str.Item1);
v.Write(writer);
Assert.AreEqual(stream.ToArray(), fullPayload);
}
}
}
}
public void ReadWrite(BitcoinStream stream)
{
if (stream.Serializing)
{
var ms = new MemoryStream();
var bs = new BitcoinStream(ms, true)
{
Type = SerializationType.Hash
};
if (KeyId != null)
{
stream.ReadWrite(new uint160(KeyId.ToBytes()));
}
else
{
bs.ReadWriteAsCompactVarInt(ref Height);
bs.ReadWriteAsCompactVarInt(ref Index);
}
var packBytes = ms.ToArray();
stream.ReadWriteAsVarString(ref packBytes);
}
else
{
var packVar = new VarString();
stream.ReadWrite(ref packVar);
var bs = new BitcoinStream(packVar.GetString());
if (packVar.Length >= 20)
{
var keyHash = uint160.Zero;
stream.ReadWrite(ref keyHash);
KeyId = new KeyId(keyHash);
}
else
{
bs.ReadWriteAsCompactVarInt(ref Height);
bs.ReadWriteAsCompactVarInt(ref Index);
}
}
}
public void SerializePayload()
{
List <byte> versionPayload = new List <byte>();
versionPayload.AddRange(BitConverter.GetBytes(ProtocolVersion));
versionPayload.AddRange(BitConverter.GetBytes(NetworkServicesLocal));
versionPayload.AddRange(BitConverter.GetBytes(UnixTimeSeconds));
versionPayload.AddRange(BitConverter.GetBytes(NetworkServicesRemote));
versionPayload.AddRange(IPAddressRemote.GetAddressBytes());
versionPayload.AddRange(GetBytes(PortRemote));
versionPayload.AddRange(BitConverter.GetBytes(NetworkServicesLocal));
versionPayload.AddRange(IPAddressLocal.GetAddressBytes());
versionPayload.AddRange(GetBytes(PortLocal));
versionPayload.AddRange(BitConverter.GetBytes(Nonce));
versionPayload.AddRange(VarString.GetBytes(UserAgent));
versionPayload.AddRange(BitConverter.GetBytes(BlockchainHeight));
versionPayload.Add(RelayOption);
Payload = versionPayload.ToArray();
}
public static VarList String(VarList globals)
{
VarList outp = new VarList();
Dictionary <string, Var> str = outp.string_vars;
str["_add"] = GenericConcat;
str["_concat"] = GenericConcat;
str["_index"] = globals.string_vars["string"];
str["_eq[string]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarString left = (VarString)arguments.number_vars[0];
VarString right = (VarString)arguments.number_vars[1];
returnTarget[returnID] = left.data == right.data ? 1 : 0;
});
str["_ne[string]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarString left = (VarString)arguments.number_vars[0];
VarString right = (VarString)arguments.number_vars[1];
returnTarget[returnID] = left.data != right.data ? 1 : 0;
});
str["_eq"] = ReturnZero;
str["_ne"] = ReturnOne;
str["_len"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarString left = (VarString)arguments.number_vars[0];
returnTarget[returnID] = left.data.Length;
});
str["_and"] = And;
str["_or"] = Or;
str["_tostring"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
returnTarget[returnID] = arguments.number_vars[0];
});
str["_tonumber"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
double d = 0.0d;
Double.TryParse((string)(VarString)arguments.number_vars[0], out d);
returnTarget[returnID] = d;
});
return(outp);
}
public IEnumerator FsmTestWithEnumeratorPasses()
{
// Use the Assert class to test conditions.
// yield to skip a frame
AshUnityEntry.New();
IFsmManager fsmManager = AshEntry.GetModule <IFsmManager>();
FsmOwer fsmOwer = new FsmOwer();
Status1 status1 = new Status1();
Status2 status2 = new Status2();
//fsmManager.CreateFsm<FsmOwer>( fsmOwer, status1, status2);
fsmManager.CreateFsm <FsmOwer>("Test", fsmOwer, status1, status2);
Log.Debug("有限状态机的数量时{0}", fsmManager.Count);
IFsm <FsmOwer> fsm = fsmManager.GetFsm <FsmOwer> ("Test");
Assert.IsNotNull(fsm);
VarString v = new VarString();
v.SetValue("Variable data"); // v.Value = "Variable data";
fsm.SetData("data", v);
fsm.Start <Status1> ();
Assert.AreEqual(fsm.CurrentState, status1);
yield return(new WaitForSeconds(1));
fsm.FireEvent(this, 1, "userData");
// Assert.AreEqual (fsm.CurrentState, status2);
yield return(null);
}
protected override void OnUpdate(IFsm <IProcedureManager> procedureOwner, float elapseSeconds, float realElapseSeconds)
{
base.OnUpdate(procedureOwner, elapseSeconds, realElapseSeconds);
VarString nextScene = procedureOwner.GetData <VarString>("NextScene");
SceneLoadEnum next = (SceneLoadEnum)Enum.Parse(typeof(SceneLoadEnum), nextScene);
switch (next)
{
case SceneLoadEnum.CreateRoleScene:
UIManger.Instance._UIComponent.OpenUIForm(ConfigEnum.LoadingForm, ConfigEnum.CreateRoleForm);
ChangeState <ProcedureCreatePeople>(procedureOwner);
SceneManger.Instance._SceneCompent.LoadScene(SceneLoadEnum.CreateRoleScene);
break;
case SceneLoadEnum.HomeScene:
UIManger.Instance._UIComponent.OpenUIForm(ConfigEnum.LoadingForm, ConfigEnum.MainForm);
ChangeState <ProcedureHome>(procedureOwner);
SceneManger.Instance._SceneCompent.LoadScene(SceneLoadEnum.HomeScene);
break;
default:
break;
}
}
public StringValueContext(ScriptRunner scriptRunner) : base(scriptRunner)
{
_variable = new VarString(scriptRunner.CollectString());
}
public Raw(byte[] data)
{
var str = new VarString();
str.FromBytes(data);
_Data = str.GetString(true);
}
public void Write(VarString value, bool prepend = false)
{
writeString(value, prepend);
}
public StringValueContext(ScriptRunner scriptRunner, string rawValue) : base(scriptRunner)
{
_variable = new VarString(rawValue, false);
}
public static VarList Number(VarList globals)
{
VarList outp = new VarList();
Dictionary <string, Var> number = outp.string_vars;
number["_add[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data + right.data;
});
number["_sub[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data - right.data;
});
number["_mult[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data * right.data;
});
number["_intdiv[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = (int)(left.data / right.data);
});
number["_div[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data / right.data;
});
number["_pow[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = Math.Pow(left.data, right.data);
});
number["_mod[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data % right.data;
});
number["_bitor[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = ((int)left) | ((int)right);
});
number["_bitand[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = ((int)left) & ((int)right);
});
number["_bitxor[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = ((int)left) ^ ((int)right);
});
number["_bitshiftl[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = ((int)left) << ((int)right);
});
number["_bitshiftr[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = ((int)left) >> ((int)right);
});
number["_concat"] = GenericConcat;
number["_le[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data <= right.data ? 1 : 0;
});
number["_lt[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data < right.data ? 1 : 0;
});
number["_ge[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data >= right.data ? 1 : 0;
});
number["_gt[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data > right.data ? 1 : 0;
});
number["_eq[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data == right.data ? 1 : 0;
});
number["_ne[number]"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
VarNumber right = (VarNumber)arguments.number_vars[1];
returnTarget[returnID] = left.data != right.data ? 1 : 0;
});
number["_eq"] = ReturnZero;
number["_ne"] = ReturnOne;
number["_not"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
returnTarget[returnID] = left.data == 0?1:0;
});
number["_unm"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
returnTarget[returnID] = -left.data;
});
number["_len"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
returnTarget[returnID] = left.data;
});
number["_bitnot"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
VarNumber left = (VarNumber)arguments.number_vars[0];
returnTarget[returnID] = ~(int)left.data;
});
number["_and"] = And;
number["_or"] = Or;
number["_tostring"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
returnTarget[returnID] = new VarString("" + (double)(VarNumber)arguments.number_vars[0]);
});
number["_tonumber"] = new VarFunction(delegate(Scope scope, Dictionary <int, Var> returnTarget, int returnID, VarList arguments){
returnTarget[returnID] = arguments.number_vars[0];
});
return(outp);
}
/// <summary>
/// 使用指定的私钥签名改交易
/// </summary>
/// <param name="key">私钥</param>
public void SignByKey(Key key)
{
this.Signature = new VarString(key.Sign(this.GetSignatureHash()).ToDER());
}
