private async Task <EvmContract> GetContract(byte[] privateKey, byte[] publicKey, string abi)
{
ILogger logger = NullLogger.Instance;
IRpcClient writer = RpcClientFactory.Configure()
.WithLogger(logger)
.WithWebSocket("ws://127.0.0.1:46657/websocket")
.Create();
IRpcClient reader = RpcClientFactory.Configure()
.WithLogger(logger)
.WithWebSocket("ws://127.0.0.1:9999/queryws")
.Create();
DAppChainClient client = new DAppChainClient(writer, reader)
{
Logger = logger
};
// required middleware
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[]
{
new NonceTxMiddleware(publicKey, client),
new SignedTxMiddleware(privateKey)
});
Address contractAddr = await client.ResolveContractAddressAsync("Tests");
Address callerAddr = Address.FromPublicKey(publicKey);
return(new EvmContract(client, contractAddr, callerAddr, abi));
}
async Task <EvmContract> GetContract(byte[] privateKey, byte[] publicKey)
{
var writer = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
// .WithHTTP("http://127.0.0.1:46658/rpc")
.WithWebSocket("ws://127.0.0.1:46657/websocket")
.Create();
var reader = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
// .WithHTTP("http://127.0.0.1:46658/query")
.WithWebSocket("ws://127.0.0.1:9999/queryws")
.Create();
var client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
// required middleware
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware {
PublicKey = publicKey,
Client = client
},
new SignedTxMiddleware(privateKey)
});
string abi = simpleStoreABI.ToString();
var contractAddr = await client.ResolveContractAddressAsync("SimpleStore");
var callerAddr = Address.FromPublicKey(publicKey);
return(new EvmContract(client, contractAddr, callerAddr, abi));
}
public async Task CreateContract(byte[] privateKey)
{
byte[] publicKey = CryptoUtils.PublicKeyFromPrivateKey(privateKey);
Address callerAddr = Address.FromPublicKey(publicKey);
IRpcClient writer = RpcClientFactory.Configure().WithLogger(Debug.unityLogger).WithWebSocket(WriterHost)
.Create();
IRpcClient reader = RpcClientFactory.Configure().WithLogger(Debug.unityLogger).WithWebSocket(ReaderHost)
.Create();
DAppChainClient client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[]
{
new NonceTxMiddleware(publicKey, client), new SignedTxMiddleware(privateKey)
});
client.AutoReconnect = false;
await client.ReadClient.ConnectAsync();
await client.WriteClient.ConnectAsync();
Address contractAddr = await client.ResolveContractAddressAsync("ZombieBattleground");
Contract oldContract = Contract;
Contract = new Contract(client, contractAddr, callerAddr);
ContractCreated?.Invoke(oldContract, Contract);
}
async Task <Contract> GetContract(byte[] privateKey, byte[] publicKey)
{
var writer = RpcClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithHttp("http://127.0.0.1:46658/rpc")
//.WithWebSocket("ws://127.0.0.1:46658/websocket")
.Create();
var reader = RpcClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithHttp("http://127.0.0.1:46658/query")
//.WithWebSocket("ws://127.0.0.1:46658/queryws")
.Create();
var client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
// required middleware
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware(publicKey, client),
new SignedTxMiddleware(privateKey)
});
var contractAddr = await client.ResolveContractAddressAsync("BluePrint");
var callerAddr = Address.FromPublicKey(publicKey);
return(new Contract(client, contractAddr, callerAddr));
}
// Get's the contract as an object
async Task <EvmContract> GetContract(byte[] privateKey, byte[] publicKey)
{
var writer = RpcClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithHTTP("http://127.0.0.1:46658/rpc")
.Create();
var reader = RpcClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithHTTP("http://127.0.0.1:46658/query")
.Create();
var client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
// Required middleware
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware(publicKey, client),
new SignedTxMiddleware(privateKey)
});
// ABI of the Solidity contract
string abi = simpleStoreABI.ToString();
var contractAddr = new Address(simpleStoreAddress.ToString());
var callerAddr = Address.FromPublicKey(publicKey);
return(new EvmContract(client, contractAddr, callerAddr, abi));
}
private async Task <EvmContract> GetContract()
{
this.writer = RpcClientFactory.Configure()
.WithLogger(this.logger)
.WithWebSocket("ws://" + this.backendHost + ":46657/websocket")
.Create();
this.reader = RpcClientFactory.Configure()
.WithLogger(this.logger)
.WithWebSocket("ws://" + this.backendHost + ":9999/queryws")
.Create();
this.client = new DAppChainClient(this.writer, this.reader)
{
Logger = this.logger
};
// required middleware
this.client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[]
{
new NonceTxMiddleware(this.publicKey, this.client),
new SignedTxMiddleware(this.privateKey)
});
Address contractAddr = await this.client.ResolveContractAddressAsync("BlackJack");
Address callerAddr = Address.FromPublicKey(this.publicKey);
EvmContract evmContract = new EvmContract(this.client, contractAddr, callerAddr, this.abi);
evmContract.EventReceived += EventReceivedHandler;
return(evmContract);
}
async Task <EvmContract> GetContract()
{
var writer = RPCClientFactory.Configure()
// .WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:46657/websocket")
.Create();
var reader = RPCClientFactory.Configure()
// .WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:9999/queryws")
.Create();
var client = new DAppChainClient(writer, reader)
{
// Logger = Debug.unityLogger
};
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware {
PublicKey = publicKey,
Client = client
},
new SignedTxMiddleware(privateKey)
});
string abi = bettingABI.ToString();
var contractAddr = Address.FromHexString(bettingAddress.ToString());
EvmContract evmContract = new EvmContract(client, contractAddr, from, abi);
evmContract.EventReceived += ContractEventReceived;
return(evmContract);
}
/// <summary>
/// Connects to the DAppChain and returns an instance of a contract.
/// </summary>
/// <returns></returns>
private async Task <EvmContract> GetContract()
{
this.writer = RpcClientFactory.Configure()
.WithLogger(this.logger)
.WithWebSocket("ws://" + this.backendHost + ":46657/websocket")
.Create();
this.reader = RpcClientFactory.Configure()
.WithLogger(this.logger)
.WithWebSocket("ws://" + this.backendHost + ":9999/queryws")
.Create();
this.client = new DAppChainClient(this.writer, this.reader)
{
Logger = this.logger
};
// required middleware
this.client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[]
{
new NonceTxMiddleware(this.publicKey, this.client),
new SignedTxMiddleware(this.privateKey)
});
// If 'truffle deploy' was used to deploy the contract,
// you will have to use the contract address directly
// instead of resolving it from contract name
Address contractAddr = await this.client.ResolveContractAddressAsync("Blueprint");
EvmContract evmContract = new EvmContract(this.client, contractAddr, this.address, this.abi);
return(evmContract);
}
public async Task <EvmContract> GetContract()
{
this.writer = RpcClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://extdev-plasma-us1.dappchains.com:80/websocket")
.Create();
this.reader = RpcClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://extdev-plasma-us1.dappchains.com:80/queryws")
.Create();
this.client = new DAppChainClient(this.writer, this.reader)
{
Logger = this.logger
};
this.client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[]
{
new NonceTxMiddleware(this.publicKey, this.client),
new SignedTxMiddleware(this.privateKey)
});
await this.client.ReadClient.ConnectAsync();
await this.client.WriteClient.ConnectAsync();
var calller = Address.FromPublicKey(this.publicKey);
EvmContract evmContract = new EvmContract(this.client, this.contractAddress, calller, GetAbi());
//evmContract.EventReceived += this.EventReceiveHandler;
await evmContract.Client.SubscribeToAllEvents();
return(evmContract);
}
async Task <EvmContract> GetContract(byte[] privateKey, byte[] publicKey)
{
var writer = RpcClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:46658/websocket")
.Create();
var reader = RpcClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:46658/queryws")
.Create();
var client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
// required middleware
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[]
{
new NonceTxMiddleware(publicKey, client),
new SignedTxMiddleware(privateKey)
});
// ABI of the Solidity contract
const string abi = "[{\"constant\":false,\"inputs\":[{\"name\":\"_tileState\",\"type\":\"string\"}],\"name\":\"SetTileMapState\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"GetTileMapState\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"state\",\"type\":\"string\"}],\"name\":\"OnTileMapStateUpdate\",\"type\":\"event\"}]\r\n";
var contractAddr = await client.ResolveContractAddressAsync("TilesChain");
var callerAddr = Address.FromPublicKey(publicKey);
return(new EvmContract(client, contractAddr, callerAddr, abi));
}
public async void SignIn()
{
var privateKey = CryptoUtils.GeneratePrivateKey();
var publicKey = CryptoUtils.PublicKeyFromPrivateKey(privateKey);
var callerAddr = Address.FromPublicKey(publicKey);
this.statusTextRef.text = "Signed in as " + callerAddr.ToAddressString();
var writer = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
//.WithHTTP("http://127.0.0.1:46658/rpc")
.WithWebSocket("ws://127.0.0.1:46657/websocket")
.Create();
var reader = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
//.WithHTTP("http://127.0.0.1:46658/query")
.WithWebSocket("ws://127.0.0.1:9999/queryws")
.Create();
var client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware {
PublicKey = publicKey,
Client = client
},
new SignedTxMiddleware(privateKey)
});
var contractAddr = await client.ResolveContractAddressAsync("BluePrint");
this.contract = new Contract(client, contractAddr, callerAddr);
// Subscribe to DAppChainClient.OnChainEvent to receive all events
/*
* client.OnChainEvent += (sender, e) =>
* {
* var jsonStr = System.Text.Encoding.UTF8.GetString(e.Data);
* var data = JsonConvert.DeserializeObject<SampleEvent>(jsonStr);
* Debug.Log(string.Format("Chain Event: {0}, {1}, {2} from block {3}", data.Method, data.Key, data.Value, e.BlockHeight));
* };
*/
// Subscribe to DAppChainClient.OnEvent to receive events from a specific smart contract
this.contract.OnEvent += (sender, e) =>
{
var jsonStr = System.Text.Encoding.UTF8.GetString(e.Data);
var data = JsonConvert.DeserializeObject <SampleEvent>(jsonStr);
Debug.Log(string.Format("Contract Event: {0}, {1}, {2} from block {3}", data.Method, data.Key, data.Value, e.BlockHeight));
};
}
public async void SignIn()
{
#if !UNITY_WEBGL
try
{
CertValidationBypass.Enable();
var authClient = this.CreateAuthClient();
var accessToken = await authClient.GetAccessTokenAsync();
var keyStore = await this.CreateKeyStore(accessToken);
this.identity = await authClient.GetIdentityAsync(accessToken, keyStore);
}
finally
{
CertValidationBypass.Disable();
}
#else
var authClient = this.CreateAuthClient();
this.identity = await authClient.GetIdentityAsync("", null);
#endif
this.statusTextRef.text = "Signed in as " + this.identity.Username;
var writer = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithHTTP("http://127.0.0.1:46658/rpc")
//.WithWebSocket("ws://127.0.0.1:46657/websocket")
.Create();
var reader = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithHTTP("http://127.0.0.1:46658/query")
//.WithWebSocket("ws://127.0.0.1:47000/queryws")
.Create();
var client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware {
PublicKey = this.identity.PublicKey,
Client = client
},
new SignedTxMiddleware(this.identity.PrivateKey)
});
var contractAddr = await client.ResolveContractAddressAsync("BluePrint");
var callerAddr = this.identity.ToAddress("default");
this.contract = new Contract(client, contractAddr, callerAddr);
}
public async void SignIn()
{
try
{
CertValidationBypass.Enable();
var authClient = AuthClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithClientId("25pDQvX4O5j7wgwT052Sh3UzXVR9X6Ud") // unity3d sdk
.WithDomain("loomx.auth0.com")
.WithScheme("io.loomx.unity3d")
.WithAudience("https://keystore.loomx.io/")
.WithScope("openid profile email picture")
.WithRedirectUrl("http://127.0.0.1:9999/auth/auth0/")
.Create();
var accessToken = await authClient.GetAccessTokenAsync();
var keyStore = await KeyStoreFactory.CreateVaultStore(new VaultStoreConfig
{
Url = "https://stage-vault.delegatecall.com/v1/",
VaultPrefix = "unity3d-sdk",
AccessToken = accessToken
});
this.identity = await authClient.GetIdentityAsync(accessToken, keyStore);
}
finally
{
CertValidationBypass.Disable();
}
this.statusTextRef.text = "Signed in as " + this.identity.Username;
// This DAppChain client will connect to the example REST server in the Loom Go SDK.
this.chainClient = new DAppChainClient("http://localhost", 46657, 47000)
{
Logger = Debug.unityLogger
};
this.chainClient.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware {
PublicKey = this.identity.PublicKey,
Client = this.chainClient
},
new SignedTxMiddleware(this.identity.PrivateKey)
});
this.callerAddr = this.identity.ToAddress("default");
}
public async void SignIn()
{
var privateKey = CryptoUtils.GeneratePrivateKey();
var publicKey = CryptoUtils.PublicKeyFromPrivateKey(privateKey);
var callerAddr = Address.FromPublicKey(publicKey);
this.statusTextRef.text = "Signed in as " + callerAddr.QualifiedAddress;
var writer = RpcClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:46658/websocket")
.Create();
var reader = RpcClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:46658/queryws")
.Create();
var client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
// required middleware
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[]
{
new NonceTxMiddleware(publicKey, client),
new SignedTxMiddleware(privateKey)
});
const string abi = "[{\"constant\":false,\"inputs\":[{\"name\":\"_tileState\",\"type\":\"string\"}],\"name\":\"SetTileMapState\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"GetTileMapState\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"state\",\"type\":\"string\"}],\"name\":\"OnTileMapStateUpdate\",\"type\":\"event\"}]\r\n";
var contractAddr = await client.ResolveContractAddressAsync("TilesChain");
contract = new EvmContract(client, contractAddr, callerAddr, abi);
// Subscribe to DAppChainClient.ChainEventReceived to receive events from a specific smart contract
this.contract.EventReceived += (sender, e) =>
{
OnTileMapStateUpdateEvent tileMapStateUpdateEvent = e.DecodeEventDto <OnTileMapStateUpdateEvent>();
Debug.Log(string.Format("Contract Event: {0}, {1}, from block {2}", e.EventName, tileMapStateUpdateEvent.State, e.BlockHeight));
};
}
public static async Task <EvmContract> GetEvmContract(byte[] privateKey, byte[] publicKey, string abi, CustomTxMiddlewareFunc customTxMiddlewareFunc = null)
{
ILogger logger = Debug.unityLogger;
IRpcClient writer = RpcClientFactory.Configure()
.WithLogger(logger)
.WithWebSocket("ws://127.0.0.1:46658/websocket")
.Create();
IRpcClient reader = RpcClientFactory.Configure()
.WithLogger(logger)
.WithWebSocket("ws://127.0.0.1:46658/queryws")
.Create();
DAppChainClient client = new DAppChainClient(writer, reader)
{
Logger = logger
};
// required middleware
ITxMiddlewareHandler[] txMiddlewareHandlers;
if (customTxMiddlewareFunc != null)
{
txMiddlewareHandlers = customTxMiddlewareFunc(client, privateKey, publicKey);
}
else
{
txMiddlewareHandlers = new ITxMiddlewareHandler[]
{
new NonceTxMiddleware(publicKey, client),
new SignedTxMiddleware(privateKey)
};
}
client.TxMiddleware = new TxMiddleware(txMiddlewareHandlers);
Address contractAddress = await client.ResolveContractAddressAsync("Tests");
Address callerAddress = Address.FromPublicKey(publicKey);
return(new EvmContract(client, contractAddress, callerAddress, abi));
}
Contract GetContract(byte[] privateKey, byte[] publicKey)
{
var client = new DAppChainClient("http://localhost:46658", "http://localhost:47000")
{
Logger = Debug.unityLogger
};
// required middleware
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware {
PublicKey = publicKey,
Client = client
},
new SignedTxMiddleware(privateKey)
});
// address of the `helloworld` smart contract on the Loom DAppChain
var contractAddr = Address.FromHexString("0x005B17864f3adbF53b1384F2E6f2120c6652F779");
var callerAddr = Address.FromPublicKey(publicKey);
return(new Contract(client, contractAddr, "helloworld", callerAddr));
}
public async void SignIn()
{
#if !UNITY_WEBGL
try
{
CertValidationBypass.Enable();
var authClient = this.CreateAuthClient();
var accessToken = await authClient.GetAccessTokenAsync();
var keyStore = await this.CreateKeyStore(accessToken);
this.identity = await authClient.GetIdentityAsync(accessToken, keyStore);
}
finally
{
CertValidationBypass.Disable();
}
#else
var authClient = this.CreateAuthClient();
this.identity = await authClient.GetIdentityAsync("", null);
#endif
this.statusTextRef.text = "Signed in as " + this.identity.Username;
// This DAppChain client will connect to the example REST server in the Loom Go SDK.
var client = new DAppChainClient("http://localhost:46657", "http://localhost:47000")
{
Logger = Debug.unityLogger
};
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware {
PublicKey = this.identity.PublicKey,
Client = client
},
new SignedTxMiddleware(this.identity.PrivateKey)
});
// There is only one contract address at the moment...
var contractAddr = Address.FromHexString("0x005B17864f3adbF53b1384F2E6f2120c6652F779");
var callerAddr = this.identity.ToAddress("default");
this.contract = new Contract(client, contractAddr, "helloworld", callerAddr);
}
// Get's the contract as an object
async Task <EvmContract> GetContract(byte[] privateKey, byte[] publicKey)
{
// Get the writer and reader for the Loom node
var writer = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:46657/websocket")
.Create();
var reader = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:9999/queryws")
.Create();
// Create a client object from them
var client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
// required middleware
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[]
{
new NonceTxMiddleware
{
PublicKey = publicKey,
Client = client
},
new SignedTxMiddleware(privateKey)
});
// ABI of the Solidity contract
string abi = realmBaseABI.ToString();
// Address of the Solidity contract
var contractAddr = Address.FromHexString(realmBaseAddress.ToString());
// Address of the user
var callerAddr = Address.FromPublicKey(publicKey);
// Return the Contract object
return(new EvmContract(client, contractAddr, callerAddr, abi));
}
private async Task <EvmContract> GetContract()
{
this.writer = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:46657/websocket")
.Create();
this.reader = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:9999/queryws")
.Create();
this.client = new DAppChainClient(this.writer, this.reader)
{
Logger = this.logger
};
// required middleware
this.client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[]
{
new NonceTxMiddleware
{
PublicKey = this.publicKey,
Client = this.client
},
new SignedTxMiddleware(this.privateKey)
});
const string abi = "[{\"constant\":false,\"inputs\":[{\"name\":\"_tileState\",\"type\":\"string\"}],\"name\":\"SetTileMapState\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"GetTileMapState\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"state\",\"type\":\"string\"}],\"name\":\"OnTileMapStateUpdate\",\"type\":\"event\"}]\r\n";
var contractAddr = await this.client.ResolveContractAddressAsync("TilesChain");
var callerAddr = Address.FromPublicKey(this.publicKey);
EvmContract evmContract = new EvmContract(this.client, contractAddr, callerAddr, abi);
evmContract.EventReceived += this.EventReceivedHandler;
return(evmContract);
}
private async Task <Contract> GetContract()
{
this.writer = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:46657/websocket")
.Create();
this.reader = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithWebSocket("ws://127.0.0.1:9999/queryws")
.Create();
this.client = new DAppChainClient(this.writer, this.reader)
{
Logger = this.logger
};
// required middleware
this.client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[]
{
new NonceTxMiddleware
{
PublicKey = this.publicKey,
Client = this.client
},
new SignedTxMiddleware(this.privateKey)
});
var contractAddr = await this.client.ResolveContractAddressAsync("TileChain");
var callerAddr = Address.FromPublicKey(this.publicKey);
Contract contract = new Contract(this.client, contractAddr, callerAddr);
contract.EventReceived += ChainEventReceivedHandler;
return(contract);
}
public ControllableNonceTxMiddleware(byte[] publicKey, DAppChainClient client) : base(publicKey, client)
{
}
public RawChainEventContract(DAppChainClient client, Address contractAddress, Address callerAddress)
: base(client, contractAddress, callerAddress)
{
}
public InvalidNonceTxMiddleware(byte[] publicKey, DAppChainClient client) : base(publicKey, client)
{
}
public async void SignIn()
{
#if !UNITY_WEBGL
try
{
CertValidationBypass.Enable();
var authClient = this.CreateAuthClient();
var accessToken = await authClient.GetAccessTokenAsync();
var keyStore = await this.CreateKeyStore(accessToken);
this.identity = await authClient.GetIdentityAsync(accessToken, keyStore);
}
finally
{
CertValidationBypass.Disable();
}
#else
var authClient = this.CreateAuthClient();
this.identity = await authClient.GetIdentityAsync("", null);
#endif
this.statusTextRef.text = "Signed in as " + this.identity.Username;
var writer = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
//.WithHTTP("http://127.0.0.1:46658/rpc")
.WithWebSocket("ws://127.0.0.1:46657/websocket")
.Create();
var reader = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
//.WithHTTP("http://127.0.0.1:46658/query")
.WithWebSocket("ws://127.0.0.1:9999/queryws")
.Create();
var client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware {
PublicKey = this.identity.PublicKey,
Client = client
},
new SignedTxMiddleware(this.identity.PrivateKey)
});
var contractAddr = await client.ResolveContractAddressAsync("BluePrint");
var callerAddr = this.identity.ToAddress("default");
this.contract = new Contract(client, contractAddr, callerAddr);
// Subscribe to DAppChainClient.OnChainEvent to receive all events
/*
* client.OnChainEvent += (sender, e) =>
* {
* var jsonStr = System.Text.Encoding.UTF8.GetString(e.Data);
* var data = JsonConvert.DeserializeObject<SampleEvent>(jsonStr);
* Debug.Log(string.Format("Chain Event: {0}, {1}, {2} from block {3}", data.Method, data.Key, data.Value, e.BlockHeight));
* };
*/
// Subscribe to DAppChainClient.OnEvent to receive events from a specific smart contract
this.contract.OnEvent += (sender, e) =>
{
var jsonStr = System.Text.Encoding.UTF8.GetString(e.Data);
var data = JsonConvert.DeserializeObject <SampleEvent>(jsonStr);
Debug.Log(string.Format("Contract Event: {0}, {1}, {2} from block {3}", data.Method, data.Key, data.Value, e.BlockHeight));
};
}
public async void SignIn()
{
if (dAppChainCfg == null)
{
Start();
}
if (this.identity != null)
{
return;
}
#if !UNITY_WEBGL
if (PlayerPrefs.GetString("identityString") == "" && PlayerPrefs.GetString("usernameString") == "")
{
try
{
CertValidationBypass.Enable();
var authClient = this.CreateAuthClient();
var accessToken = await authClient.GetAccessTokenAsync();
var keyStore = await this.CreateKeyStore(accessToken);
this.identity = await authClient.GetIdentityAsync(accessToken, keyStore);
}
finally
{
CertValidationBypass.Disable();
}
}
else
{
this.identity = new Identity {
Username = PlayerPrefs.GetString("usernameString"),
PrivateKey = CryptoUtils.HexStringToBytes(PlayerPrefs.GetString("identityString"))
};
}
#else
var authClient = this.CreateAuthClient();
this.identity = await authClient.GetIdentityAsync("", null);
#endif
PlayerPrefs.SetString("identityString", CryptoUtils.BytesToHexString(this.identity.PrivateKey));
PlayerPrefs.SetString("usernameString", this.identity.Username);
var writer = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithHTTP(dAppChainCfg.write_host)
//.WithWebSocket("ws://etherboy-stage.loomapps.io/websocket")
.Create();
var reader = RPCClientFactory.Configure()
.WithLogger(Debug.unityLogger)
.WithHTTP(dAppChainCfg.read_host)
//.WithWebSocket("ws://etherboy-stage.loomapps.io/queryws")
.Create();
var client = new DAppChainClient(writer, reader)
{
Logger = Debug.unityLogger
};
client.TxMiddleware = new TxMiddleware(new ITxMiddlewareHandler[] {
new NonceTxMiddleware {
PublicKey = this.identity.PublicKey,
Client = client
},
new SignedTxMiddleware(this.identity.PrivateKey)
});
// There is only one contract address at the moment...
var contractAddr = Address.FromHexString("0xe288d6eec7150D6a22FDE33F0AA2d81E06591C4d");
var callerAddr = this.identity.ToAddress("default");
this.contract = new Contract(client, contractAddr, callerAddr);
//call create account, if it's a new user, an account will be created for Etherboy
if (PlayerPrefs.GetInt("hasAccount") == 0)
{
CreateAccount();
}
}
