public void TestRequestAccountOffers()
{
var deferred = new Task(() => { });
_remote = new Remote(ServerUrl);
MessageResult <AccountOffersResponse> response = null;
_remote.Connect(r =>
{
var options = new AccountOffersOptions();
options.Limit = 1;
options.Account = "j9FGhAW9dSzL3RjbXkyW6Z6bHGxFk8cmB1";
var req = _remote.RequestAccountOffers(options);
req.Submit(r1 =>
{
response = r1;
deferred.Start();
});
});
Assert.IsTrue(deferred.Wait(DeferredWaitingTime));
Assert.IsNotNull(response);
var result = response.Result;
Assert.IsNotNull(result);
Assert.AreEqual("j9FGhAW9dSzL3RjbXkyW6Z6bHGxFk8cmB1", result.Account);
Assert.IsNotNull(result.Offers);
}
public void TestRequestAccountOffers_Invalid()
{
var deferred = new Task(() => { });
MessageResult <AccountOffersResponse> response = null;
var options = new AccountOffersOptions();
options.Account = "abcxyz";
_remote.RequestAccountOffers(options).Submit(r =>
{
response = r;
deferred.Start();
});
Assert.IsTrue(deferred.Wait(DeferredWaitingTime));
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response.Exception, typeof(InvalidAddressException));
deferred = new Task(() => { });
response = null;
options = new AccountOffersOptions();
options.Ledger = new LedgerSettings();
options.Ledger.LedgerHash = "abcxyz";
_remote.RequestAccountOffers(options).Submit(r =>
{
response = r;
deferred.Start();
});
Assert.IsTrue(deferred.Wait(DeferredWaitingTime));
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response.Exception, typeof(InvalidHashException));
}
private void InitRequestAccountOffersOptions()
{
var options = new AccountOffersOptions();
options.Account = "j9FGhAW9dSzL3RjbXkyW6Z6bHGxFk8cmB1";
options.Ledger = new LedgerSettings();
pgRequestAccountOffersOptions.SelectedObject = options;
}
public void TestRequestAccountOffersResponse()
{
var remote = new Remote("");
remote.SetMockServer(new MockServer(remote, "RequestAccountOffers.json"));
MessageResult <AccountOffersResponse> response = null;
var deferred = new Task(() => { });
var options = new AccountOffersOptions();
options.Account = "jMw3xrkX2ySwdQiEorymyuTLUSSa85wvSr";
remote.RequestAccountOffers(options).Submit(r =>
{
response = r;
deferred.Start();
});
Assert.IsTrue(deferred.Wait(DeferredWaitingTime));
Assert.IsNotNull(response);
var result = response.Result;
Assert.IsNotNull(result);
Assert.AreEqual("85D1BA494D44582FBDA5F3D51BCB8C55435FF764E23292074A9F7493DD7E0FE9", result.Marker);
Assert.AreEqual("jMw3xrkX2ySwdQiEorymyuTLUSSa85wvSr", result.Account);
Assert.AreEqual("39210701654A5DCDA1B01EF636B0A4FFA5159342B75F082B81B58E92DDCB24B1", result.LedgerHash);
Assert.AreEqual((uint)9646438, result.LedgerIndex);
Assert.IsNotNull(result.Offers);
Assert.AreEqual(1, result.Offers.Length);
var offer0 = result.Offers[0];
Assert.AreEqual(131072, offer0.Flags);
Assert.AreEqual(16, offer0.Seq);
Assert.AreEqual(new Amount {
Currency = "SWT", Issuer = "", Value = "0.01"
}, offer0.TakerGets);
Assert.AreEqual(new Amount {
Currency = "CNY", Issuer = "jGa9J9TkqtBcUoHe2zqhVFFbgUVED6o9or", Value = "1"
}, offer0.TakerPays);
Assert.IsTrue(offer0.IsSell);
}
public static Task GetBalance(Remote remote, Options options, MessageCallback <Response> callback = null)
{
Func <Exception, Task> onException = (ex =>
{
callback(new MessageResult <Response>(null, ex));
return(Task.FromResult(0));
});
if (remote == null || !remote.IsConnected)
{
return(onException(new ArgumentException("Remote is disconnected.")));
}
if (options == null)
{
return(onException(new ArgumentNullException("options")));
}
if (!Utils.IsValidAddress(options.Account))
{
return(onException(new Exception("Invalid account address.")));
}
var condition = new Amount();
if (options.Currency != null)
{
if (!Utils.IsValidCurrency(options.Currency))
{
return(onException(new Exception("Invalid currency.")));
}
condition.Currency = options.Currency;
}
if (options.Issuer != null)
{
if (!Utils.IsValidAddress(options.Issuer))
{
return(onException(new Exception("Invalid issuer address.")));
}
condition.Issuer = options.Issuer;
}
var results = new Results();
var opt1 = new AccountInfoOptions();
opt1.Account = options.Account;
var t1 = remote.RequestAccountInfo(opt1).SubmitAsync(r1 =>
{
if (r1.Exception != null)
{
results.Exception = r1.Exception;
}
results.Native = r1.Result;
});
var opt2 = new AccountRelationsOptions();
opt2.Account = options.Account;
opt2.Type = RelationType.Trust;
var t2 = remote.RequestAccountRelations(opt2).SubmitAsync(r2 =>
{
if (r2.Exception != null)
{
results.Exception = r2.Exception;
}
results.Lines = r2.Result;
});
var opt3 = new AccountRelationsOptions();
opt3.Account = options.Account;
opt3.Type = RelationType.Freeze;
var t3 = remote.RequestAccountRelations(opt3).SubmitAsync(r3 =>
{
if (r3.Exception != null)
{
results.Exception = r3.Exception;
}
results.Lines2 = r3.Result;
});
var opt4 = new AccountOffersOptions();
opt4.Account = options.Account;
Func <Task> getOffers = null;
getOffers = () =>
{
var t4 = remote.RequestAccountOffers(opt4).SubmitAsync(r4 =>
{
if (r4.Exception != null)
{
results.Exception = r4.Exception;
}
else
{
if (r4.Result.Offers != null)
{
results.Offers = r4.Result.Offers.Concat(results.Offers ?? new Offer[0]).ToArray();
}
if (r4.Result.Marker != null)
{
opt4.Marker = r4.Result.Marker;
var childTask = getOffers();
childTask.Wait();
}
}
});
return(t4);
};
var t5 = getOffers();
var task = new Task(() =>
{
if (!Task.WaitAll(new Task[] { t1, t2, t3, t5 }, Global.Timeout))
{
onException(new Exception("Time out."));
return;
}
if (results.Exception != null)
{
onException(results.Exception);
return;
}
var balances = ProcessBalance(results, condition);
var response = new Response {
Balances = balances, Sequence = results.Native.AccountData.Sequence
};
callback(new MessageResult <Response>(null, null, response));
return;
});
task.Start();
return(task);
}
