public void GetDepositAddresses()
{
var provider = Networks.I.Providers.OfType <BittrexProvider>().FirstProvider();
var ctx = new WalletAddressAssetContext("BTC".ToAsset(provider), UserContext.Current);
var ctxAll = new WalletAddressContext(UserContext.Current);
var addresses = AsyncContext.Run(() => provider.GetAddressesForAssetAsync(ctx));
var addressesAll = AsyncContext.Run(() => provider.GetAddressesAsync(ctxAll));
try
{
System.Console.WriteLine("Addresses for 1 asset");
foreach (var address in addresses)
{
System.Console.WriteLine($"{address.Asset} : {address.Address}");
}
System.Console.WriteLine("Addresses for all assets");
foreach (var address in addressesAll)
{
System.Console.WriteLine($"{address.Asset} : {address.Address}");
}
}
catch (Exception e)
{
System.Console.WriteLine(e);
throw;
}
}
public async Task <WalletAddressesResult> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
var api = ApiProvider.GetApi(context);
var body = CreatePoloniexBody(PoloniexBodyType.ReturnDepositAddresses);
var addresses = new WalletAddressesResult();
var rRaw = await api.GetDepositAddressesAsync(body).ConfigureAwait(false);
CheckResponseErrors(rRaw);
var r = rRaw.GetContent();
var assetBalances = r.Where(x => Equals(x.Key.ToAsset(this), context.Asset)).ToArray();
foreach (var balance in assetBalances)
{
if (string.IsNullOrWhiteSpace(balance.Value))
{
continue;
}
addresses.Add(new WalletAddress(this, balance.Key.ToAsset(this))
{
Address = balance.Value
});
}
return(addresses);
}
public override void TestGetAddressesForAsset()
{
// BUG: EFunding:Too many addresses. Should investigate that.
var context = new WalletAddressAssetContext("MLN".ToAssetRaw(), UserContext.Current);
base.TestGetAddressesForAsset(context);
}
public async Task <WalletAddresses> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
var api = ApiProvider.GetApi(context);
var body = CreatePoloniexBody(PoloniexBodyType.ReturnDepositAddresses);
var addresses = new WalletAddresses();
try
{
var r = await api.GetDepositAddressesAsync(body).ConfigureAwait(false);
var assetBalances = r.Where(x => Equals(x.Key.ToAsset(this), context.Asset)).ToArray();
foreach (var balance in assetBalances)
{
if (string.IsNullOrWhiteSpace(balance.Value))
{
continue;
}
addresses.Add(new WalletAddress(this, balance.Key.ToAsset(this))
{
Address = balance.Value
});
}
}
catch (Exception e)
{
// "Unable to get deposit addresses, please check that your account is verified"
throw new ApiResponseException(e, this);
}
return(addresses);
}
public async Task <WalletAddresses> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
var api = ApiProvider.GetApi(context);
var accid = "";
var accs = await api.GetAccountsAsync().ConfigureAwait(false);
var ast = context.Asset.ToRemoteCode(this);
var acc = accs.data.FirstOrDefault(x => string.Equals(x.currency, ast, StringComparison.OrdinalIgnoreCase));
if (acc == null)
{
return(null);
}
accid = acc.id;
if (accid == null)
{
return(null);
}
var r = await api.GetAddressesAsync(acc.id).ConfigureAwait(false);
// TODO: re-implement.
//if (r.data.Count == 0 && context.CanGenerateAddress)
//{
// var cr = await api.CreateAddressAsync(accid);
// if (cr != null)
// r.data.AddRange(cr.data);
//}
var addresses = new WalletAddresses();
foreach (var a in r.data)
{
if (string.IsNullOrWhiteSpace(a.address))
{
continue;
}
var forasset = FromNetwork(a.network);
if (!context.Asset.Equals(forasset))
{
continue;
}
addresses.Add(new WalletAddress(this, context.Asset)
{
Address = a.address
});
}
return(addresses);
}
public void TestGetAddressesForAsset(WalletAddressAssetContext context)
{
var p = IsType <IDepositProvider>();
if (p.Success)
{
GetAddressesForAsset(p.Provider, context);
}
}
public async Task <WalletAddressesResult> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
var api = ApiProvider.GetApi(context);
var fundingMethod = await GetFundingMethodAsync(context, context.Asset).ConfigureAwait(false);
if (fundingMethod == null)
{
throw new NullReferenceException("No funding method is found");
}
var addresses = await GetAddressesLocalAsync(api, fundingMethod, context.Asset).ConfigureAwait(false);
return(addresses);
}
public async Task <WalletAddresses> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetDepositAddressAsync(context.Asset.ShortCode).ConfigureAwait(false);
var walletAddresses = new WalletAddresses
{
new WalletAddress(this, context.Asset)
{
Address = r.address
}
};
return(walletAddresses);
}
private void GetAddressesForAsset(IDepositProvider provider, WalletAddressAssetContext context)
{
if (context == null)
{
return;
}
var r = AsyncContext.Run(() => provider.GetAddressesForAssetAsync(context));
Assert.IsTrue(r != null);
Trace.WriteLine($"Deposit addresses for {context.Asset}:");
foreach (var walletAddress in r)
{
Trace.WriteLine($"\"{walletAddress.Address}\"");
}
}
public async Task <WalletAddresses> GetAddressesAsync(WalletAddressContext context)
{
var addresses = new WalletAddresses();
var wac = new WalletAddressAssetContext("ETH".ToAsset(this), context.UserContext, context.L);
addresses.AddRange(await GetAddressesForAssetAsync(wac).ConfigureAwait(false));
wac.Asset = "BTC".ToAsset(this);
addresses.AddRange(await GetAddressesForAssetAsync(wac).ConfigureAwait(false));
wac.Asset = "XRP".ToAsset(this);
addresses.AddRange(await GetAddressesForAssetAsync(wac).ConfigureAwait(false));
wac.Asset = "LTC".ToAsset(this);
addresses.AddRange(await GetAddressesForAssetAsync(wac).ConfigureAwait(false));
return(addresses);
}
public async Task <WalletAddressesResult> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
var api = ApiProvider.GetApi(context);
var rRaw = await api.GetDepositAddressAsync(context.Asset.ShortCode).ConfigureAwait(false);
CheckResponseErrors(rRaw);
var r = rRaw.GetContent();
var walletAddresses = new WalletAddressesResult(new WalletAddress(this, context.Asset)
{
Address = r.address
}
);
return(walletAddresses);
}
private void PullWallet()
{
var wac = new WalletAddressAssetContext(Asset.Btc, UserContext.Current);
foreach (var network in Networks.I.DepositProviders)
{
var r = ApiCoordinator.GetDepositAddresses(network, wac);
if (r.IsNull)
{
continue;
}
foreach (var i in r.Response)
{
Addresses.Add(i);
}
}
}
public async Task <WalletAddressesResult> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
var api = ApiProvider.GetApi(context);
var currencyPath = GetCurrencyPath(context.Asset);
var r = await api.GetDepositAddressAsync(currencyPath).ConfigureAwait(false);
var processedAddress = ProcessAddressResponce(context.Asset, r);
//if (!this.ExchangeHas(context.Asset))
// return null;
var walletAddress = new WalletAddress(this, context.Asset)
{
Address = processedAddress
};
return(new WalletAddressesResult(walletAddress));
}
public async Task <WalletAddresses> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
var api = ApiProvider.GetApi(context);
var remoteAssetCode = context.Asset.ToRemoteCode(this);
var depositAddress = await api.GetUserDepositAddressAsync(remoteAssetCode).ConfigureAwait(false);
depositAddress = depositAddress.Trim('\"');
var addresses = new WalletAddresses();
var walletAddress = new WalletAddress(this, context.Asset)
{
Address = depositAddress
};
addresses.Add(walletAddress);
return(addresses);
}
public async Task <WalletAddressesResult> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
var api = ApiProvider.GetApi(context);
var rAccountId = await GetFirstAccountId(context).ConfigureAwait(false);
var r = await api.GetAddressesAsync(rAccountId.Result).ConfigureAwait(false);
//if (r.data.Count == 0 && context.CanGenerateAddress)
//{
// var cr = await api.CreateAddressAsync(accid);
// if (cr != null)
// r.data.AddRange(cr.data);
//}
var addresses = new WalletAddressesResult()
{
ApiHitsCount = rAccountId.ApiHitsCount + 1
};
foreach (var a in r.data)
{
if (string.IsNullOrWhiteSpace(a.address))
{
continue;
}
var forasset = FromNetwork(a.network);
if (!context.Asset.Equals(forasset))
{
continue;
}
addresses.Add(new WalletAddress(this, context.Asset)
{
Address = a.address
});
}
return(addresses);
}
public void GetDepositAddresses()
{
var provider = Networks.I.Providers.OfType <KrakenProvider>().FirstProvider();
var ctx = new WalletAddressAssetContext("BTC".ToAsset(provider), UserContext.Testing);
try
{
var addresses = AsyncContext.Run(() => provider.GetAddressesForAssetAsync(ctx));
foreach (var walletAddress in addresses.WalletAddresses)
{
System.Console.WriteLine($"{walletAddress.Asset} : {walletAddress.Address}");
}
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
throw;
}
}
public async Task <WalletAddresses> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
var api = ApiProvider.GetApi(context);
var r = await api.GetAllBalancesAsync().ConfigureAwait(false);
CheckResponseErrors(r);
var addresses = new WalletAddresses();
var address = r.result.FirstOrDefault(x => x.Currency.ToAsset(this).Equals(context.Asset));
if (address != null)
{
addresses.Add(new WalletAddress(this, context.Asset)
{
Address = address.CryptoAddress
});
}
return(addresses);
}
public void GetDepositAddresses()
{
var provider = Networks.I.Providers.OfType <BitMexProvider>().FirstProvider();
var asset = "BTC".ToAsset(provider);
var ctx = new WalletAddressAssetContext(asset, UserContext.Current);
try
{
var r = provider.GetAddressesForAssetAsync(ctx).Result;
Console.WriteLine("List of addresses: ");
foreach (var walletAddress in r)
{
Console.WriteLine($"{walletAddress.Asset}: {walletAddress.Address}");
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public Task <WalletAddressesResult> GetAddressesForAssetAsync(WalletAddressAssetContext context)
{
return(Task.FromResult <WalletAddressesResult>(null));
}
public override void TestGetAddressesForAsset()
{
var context = new WalletAddressAssetContext(Asset.Btc, UserContext.Testing);
base.PretestGetAddressesForAsset(context);
}
public Task <bool> CreateAddressForAssetAsync(WalletAddressAssetContext context)
{
throw new NotImplementedException();
}
public override void TestGetAddressesForAsset()
{
var context = new WalletAddressAssetContext("BTC".ToAssetRaw(), UserContext.Current);
base.TestGetAddressesForAsset(context);
}
