lukechilds
/
SuperNET
mirror of https://github.com/lukechilds/SuperNET.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Add "decimals" field for ERC20 tokens without decimals function.

pass-iguana-arg
Artem Pikulin 7 years ago
parent
fe8592b932
commit
18873c4502
7 changed files with 188 additions and 49 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      etomic_build/coins
  2. 3
      iguana/exchanges/LP_coins.c
  3. 55
      iguana/exchanges/LP_etomic.c
  4. 2
      iguana/exchanges/LP_include.h
  5. 2
      iguana/exchanges/LP_transaction.c
  6. 144
      iguana/exchanges/etomicswap/etomiclib.cpp
  7. 29
      iguana/exchanges/etomicswap/etomiclib.h

2
etomic_build/coins
View File

File diff suppressed because one or more lines are too long

3
iguana/exchanges/LP_coins.c
View File

@ -496,6 +496,7 @@ struct iguana_info *LP_coinfind(char *symbol)
struct iguana_info *LP_coincreate(cJSON *item) struct iguana_info *LP_coincreate(cJSON *item)
{ {
struct iguana_info cdata,*coin=0; int32_t isPoS,longestchain = 1; uint16_t port; uint64_t txfee; double estimatedrate; uint8_t pubtype,p2shtype,wiftype; char *name=0,*symbol,*assetname=0; struct iguana_info cdata,*coin=0; int32_t isPoS,longestchain = 1; uint16_t port; uint64_t txfee; double estimatedrate; uint8_t pubtype,p2shtype,wiftype; char *name=0,*symbol,*assetname=0;
if ( (symbol= jstr(item,"coin")) != 0 && symbol[0] != 0 && strlen(symbol) < 16 && LP_coinfind(symbol) == 0 && (port= juint(item,"rpcport")) != 0 ) if ( (symbol= jstr(item,"coin")) != 0 && symbol[0] != 0 && strlen(symbol) < 16 && LP_coinfind(symbol) == 0 && (port= juint(item,"rpcport")) != 0 )
{ {
isPoS = jint(item,"isPoS"); isPoS = jint(item,"isPoS");
@ -514,6 +515,8 @@ struct iguana_info *LP_coincreate(cJSON *item)
} }
else if ( (name= jstr(item,"name")) == 0 ) else if ( (name= jstr(item,"name")) == 0 )
name = symbol; name = symbol;
cdata.decimals = juint(item,"decimals");
if ( LP_coininit(&cdata,symbol,name,assetname==0?"":assetname,isPoS,port,pubtype,p2shtype,wiftype,txfee,estimatedrate,longestchain,juint(item,"wiftaddr"),juint(item,"taddr"),LP_busport(port),jstr(item,"confpath")) < 0 ) if ( LP_coininit(&cdata,symbol,name,assetname==0?"":assetname,isPoS,port,pubtype,p2shtype,wiftype,txfee,estimatedrate,longestchain,juint(item,"wiftaddr"),juint(item,"taddr"),LP_busport(port),jstr(item,"confpath")) < 0 )
{ {
coin = LP_coinadd(&cdata); coin = LP_coinadd(&cdata);

55
iguana/exchanges/LP_etomic.c
View File

@ -44,7 +44,9 @@ char *LP_etomicalice_send_fee(struct basilisk_swap *swap)
if (strcmp(swap->I.alicestr,"ETH") == 0 ) { if (strcmp(swap->I.alicestr,"ETH") == 0 ) {
return(sendEth(dexaddr, amount, secretKey, 1, 0, 0, 1)); return(sendEth(dexaddr, amount, secretKey, 1, 0, 0, 1));
} else { } else {
return(sendErc20(swap->I.alicetomic, dexaddr, amount, secretKey, 1, 0, 0, 1)); struct iguana_info *alicecoin = LP_coinfind(swap->I.alicestr);
return(sendErc20(swap->I.alicetomic, dexaddr, amount, secretKey, 1, 0, 0, 1, alicecoin->decimals));
} }
} }
@ -74,13 +76,15 @@ uint8_t LP_etomic_verify_alice_fee(struct basilisk_swap *swap)
} }
return(1); return(1);
} else { } else {
struct iguana_info *alicecoin = LP_coinfind(swap->I.alicestr);
if (strcmp(data.to, swap->I.alicetomic) != 0) { if (strcmp(data.to, swap->I.alicetomic) != 0) {
printf("Alice ERC20 fee %s token address %s is not equal to expected %s\n", swap->otherfee.I.ethTxid, data.to, swap->I.alicetomic); printf("Alice ERC20 fee %s token address %s is not equal to expected %s\n", swap->otherfee.I.ethTxid, data.to, swap->I.alicetomic);
return(0); return(0);
} }
char weiAmount[70]; char weiAmount[70];
satoshisToWei(weiAmount, swap->otherfee.I.amount); satoshisToWei(weiAmount, swap->otherfee.I.amount);
return(verifyAliceErc20FeeData(swap->I.alicetomic, dexaddr, weiAmount, data.input)); return(verifyAliceErc20FeeData(swap->I.alicetomic, dexaddr, weiAmount, data.input, alicecoin->decimals));
} }
} }
@ -107,6 +111,8 @@ char *LP_etomicalice_send_payment(struct basilisk_swap *swap)
} }
else else
{ {
struct iguana_info *alicecoin = LP_coinfind(swap->I.alicestr);
memset(&input20,0,sizeof(input20)); memset(&input20,0,sizeof(input20));
strcpy(input20.bobAddress, swap->I.etomicsrc); strcpy(input20.bobAddress, swap->I.etomicsrc);
uint8arrayToHex(input20.bobHash, swap->I.secretBn, 20); uint8arrayToHex(input20.bobHash, swap->I.secretBn, 20);
@ -114,13 +120,14 @@ char *LP_etomicalice_send_payment(struct basilisk_swap *swap)
uint8arrayToHex(input20.dealId, swap->alicepayment.I.actualtxid.bytes, 32); uint8arrayToHex(input20.dealId, swap->alicepayment.I.actualtxid.bytes, 32);
strcpy(input20.tokenAddress, swap->I.alicetomic); strcpy(input20.tokenAddress, swap->I.alicetomic);
satoshisToWei(input20.amount, swap->I.alicesatoshis); satoshisToWei(input20.amount, swap->I.alicesatoshis);
input20.decimals = alicecoin->decimals;
strcpy(txData.from, swap->I.etomicdest); strcpy(txData.from, swap->I.etomicdest);
strcpy(txData.to, ETOMIC_ALICECONTRACT); strcpy(txData.to, ETOMIC_ALICECONTRACT);
strcpy(txData.amount, "0"); strcpy(txData.amount, "0");
uint8arrayToHex(txData.secretKey, swap->persistent_privkey.bytes, 32); uint8arrayToHex(txData.secretKey, swap->persistent_privkey.bytes, 32);
uint64_t allowance = getErc20Allowance(swap->I.etomicdest, ETOMIC_ALICECONTRACT, swap->I.alicetomic); uint64_t allowance = getErc20Allowance(swap->I.etomicdest, ETOMIC_ALICECONTRACT, swap->I.alicetomic, alicecoin->decimals);
if (allowance < swap->I.alicesatoshis) { if (allowance < swap->I.alicesatoshis) {
printf("Alice token allowance is too low, setting new allowance\n"); printf("Alice token allowance is too low, setting new allowance\n");
ApproveErc20Input approveErc20Input; ApproveErc20Input approveErc20Input;
@ -173,6 +180,8 @@ uint8_t LP_etomic_verify_alice_payment(struct basilisk_swap *swap, char *txId)
return(verifyAliceEthPaymentData(input, data.input)); return(verifyAliceEthPaymentData(input, data.input));
} else { } else {
struct iguana_info *alicecoin = LP_coinfind(swap->I.alicestr);
memset(&input20,0,sizeof(input20)); memset(&input20,0,sizeof(input20));
strcpy(input20.bobAddress, swap->I.etomicsrc); strcpy(input20.bobAddress, swap->I.etomicsrc);
uint8arrayToHex(input20.bobHash, swap->I.secretBn, 20); uint8arrayToHex(input20.bobHash, swap->I.secretBn, 20);
@ -180,6 +189,7 @@ uint8_t LP_etomic_verify_alice_payment(struct basilisk_swap *swap, char *txId)
uint8arrayToHex(input20.dealId, swap->alicepayment.I.actualtxid.bytes, 32); uint8arrayToHex(input20.dealId, swap->alicepayment.I.actualtxid.bytes, 32);
strcpy(input20.tokenAddress, swap->I.alicetomic); strcpy(input20.tokenAddress, swap->I.alicetomic);
satoshisToWei(input20.amount, swap->I.alicesatoshis); satoshisToWei(input20.amount, swap->I.alicesatoshis);
input20.decimals = alicecoin->decimals;
return(verifyAliceErc20PaymentData(input20, data.input)); return(verifyAliceErc20PaymentData(input20, data.input));
} }
@ -223,6 +233,9 @@ char *LP_etomicalice_reclaims_payment(struct LP_swap_remember *swap)
} }
uint8arrayToHex(input.bobSecret, invertedSecret.bytes, 32); uint8arrayToHex(input.bobSecret, invertedSecret.bytes, 32);
struct iguana_info *alice_coin = LP_coinfind(swap->alicecoin);
input.decimals = alice_coin->decimals;
strcpy(txData.from, swap->etomicdest); strcpy(txData.from, swap->etomicdest);
strcpy(txData.to, ETOMIC_ALICECONTRACT); strcpy(txData.to, ETOMIC_ALICECONTRACT);
strcpy(txData.amount, "0"); strcpy(txData.amount, "0");
@ -268,6 +281,8 @@ char *LP_etomicbob_spends_alice_payment(struct LP_swap_remember *swap)
} }
uint8arrayToHex(input.aliceSecret, invertedSecret.bytes, 32); uint8arrayToHex(input.aliceSecret, invertedSecret.bytes, 32);
uint8arrayToHex(input.bobHash, swap->secretBn, 20); uint8arrayToHex(input.bobHash, swap->secretBn, 20);
struct iguana_info *alice_coin = LP_coinfind(swap->alicecoin);
input.decimals = alice_coin->decimals;
strcpy(txData.from, swap->etomicsrc); strcpy(txData.from, swap->etomicsrc);
strcpy(txData.to, ETOMIC_ALICECONTRACT); strcpy(txData.to, ETOMIC_ALICECONTRACT);
@ -296,19 +311,22 @@ char *LP_etomicbob_sends_deposit(struct basilisk_swap *swap)
uint8arrayToHex(txData.secretKey, swap->persistent_privkey.bytes, 32); uint8arrayToHex(txData.secretKey, swap->persistent_privkey.bytes, 32);
return bobSendsEthDeposit(input, txData); return bobSendsEthDeposit(input, txData);
} else { } else {
struct iguana_info *bobcoin = LP_coinfind(swap->I.bobstr);
uint8arrayToHex(input20.depositId, swap->bobdeposit.I.actualtxid.bytes, 32); uint8arrayToHex(input20.depositId, swap->bobdeposit.I.actualtxid.bytes, 32);
strcpy(input20.aliceAddress, swap->I.etomicdest); strcpy(input20.aliceAddress, swap->I.etomicdest);
uint8arrayToHex(input20.bobHash, swap->I.secretBn, 20); uint8arrayToHex(input20.bobHash, swap->I.secretBn, 20);
satoshisToWei(input20.amount, swap->bobdeposit.I.amount); satoshisToWei(input20.amount, swap->bobdeposit.I.amount);
strcpy(input20.tokenAddress, swap->I.bobtomic); strcpy(input20.tokenAddress, swap->I.bobtomic);
input20.lockTime = swap->bobdeposit.I.locktime; input20.lockTime = swap->bobdeposit.I.locktime;
input20.decimals = bobcoin->decimals;
strcpy(txData.from, swap->I.etomicsrc); strcpy(txData.from, swap->I.etomicsrc);
strcpy(txData.to, ETOMIC_BOBCONTRACT); strcpy(txData.to, ETOMIC_BOBCONTRACT);
strcpy(txData.amount, "0"); strcpy(txData.amount, "0");
uint8arrayToHex(txData.secretKey, swap->persistent_privkey.bytes, 32); uint8arrayToHex(txData.secretKey, swap->persistent_privkey.bytes, 32);
uint64_t allowance = getErc20Allowance(swap->I.etomicsrc, ETOMIC_BOBCONTRACT, swap->I.bobtomic); uint64_t allowance = getErc20Allowance(swap->I.etomicsrc, ETOMIC_BOBCONTRACT, swap->I.bobtomic, bobcoin->decimals);
if (allowance < swap->bobdeposit.I.amount) { if (allowance < swap->bobdeposit.I.amount) {
printf("Bob token allowance is too low, setting new allowance\n"); printf("Bob token allowance is too low, setting new allowance\n");
ApproveErc20Input approveErc20Input; ApproveErc20Input approveErc20Input;
@ -362,12 +380,15 @@ uint8_t LP_etomic_verify_bob_deposit(struct basilisk_swap *swap, char *txId)
return verifyBobEthDepositData(input, data.input); return verifyBobEthDepositData(input, data.input);
} else { } else {
struct iguana_info *bobcoin = LP_coinfind(swap->I.bobstr);
uint8arrayToHex(input20.depositId, swap->bobdeposit.I.actualtxid.bytes, 32); uint8arrayToHex(input20.depositId, swap->bobdeposit.I.actualtxid.bytes, 32);
strcpy(input20.aliceAddress, swap->I.etomicdest); strcpy(input20.aliceAddress, swap->I.etomicdest);
uint8arrayToHex(input20.bobHash, swap->I.secretBn, 20); uint8arrayToHex(input20.bobHash, swap->I.secretBn, 20);
satoshisToWei(input20.amount, swap->bobdeposit.I.amount); satoshisToWei(input20.amount, swap->bobdeposit.I.amount);
strcpy(input20.tokenAddress, swap->I.bobtomic); strcpy(input20.tokenAddress, swap->I.bobtomic);
input20.lockTime = swap->bobdeposit.I.locktime; input20.lockTime = swap->bobdeposit.I.locktime;
input20.decimals = bobcoin->decimals;
return verifyBobErc20DepositData(input20, data.input); return verifyBobErc20DepositData(input20, data.input);
} }
@ -384,9 +405,10 @@ char *LP_etomicbob_refunds_deposit(struct LP_swap_remember *swap)
memset(&txData,0,sizeof(txData)); memset(&txData,0,sizeof(txData));
memset(&input,0,sizeof(input)); memset(&input,0,sizeof(input));
struct iguana_info *ecoin; struct iguana_info *ecoin, *bobcoin;
bits256 privkey; bits256 privkey;
ecoin = LP_coinfind("ETOMIC"); ecoin = LP_coinfind("ETOMIC");
bobcoin = LP_coinfind(swap->bobcoin);
privkey = LP_privkey(ecoin->symbol, ecoin->smartaddr, ecoin->taddr); privkey = LP_privkey(ecoin->symbol, ecoin->smartaddr, ecoin->taddr);
EthTxReceipt receipt = getEthTxReceipt(swap->bobDepositEthTx); EthTxReceipt receipt = getEthTxReceipt(swap->bobDepositEthTx);
@ -410,6 +432,7 @@ char *LP_etomicbob_refunds_deposit(struct LP_swap_remember *swap)
strcpy(input.tokenAddress, "0x0000000000000000000000000000000000000000"); strcpy(input.tokenAddress, "0x0000000000000000000000000000000000000000");
} }
satoshisToWei(input.amount, swap->values[BASILISK_BOBDEPOSIT]); satoshisToWei(input.amount, swap->values[BASILISK_BOBDEPOSIT]);
input.decimals = bobcoin->decimals;
strcpy(txData.from, swap->etomicsrc); strcpy(txData.from, swap->etomicsrc);
strcpy(txData.to, ETOMIC_BOBCONTRACT); strcpy(txData.to, ETOMIC_BOBCONTRACT);
@ -439,19 +462,22 @@ char *LP_etomicbob_sends_payment(struct basilisk_swap *swap)
uint8arrayToHex(txData.secretKey, swap->persistent_privkey.bytes, 32); uint8arrayToHex(txData.secretKey, swap->persistent_privkey.bytes, 32);
return bobSendsEthPayment(input, txData); return bobSendsEthPayment(input, txData);
} else { } else {
struct iguana_info *bobcoin = LP_coinfind(swap->I.bobstr);
uint8arrayToHex(input20.paymentId, swap->bobpayment.I.actualtxid.bytes, 32); uint8arrayToHex(input20.paymentId, swap->bobpayment.I.actualtxid.bytes, 32);
strcpy(input20.aliceAddress, swap->I.etomicdest); strcpy(input20.aliceAddress, swap->I.etomicdest);
uint8arrayToHex(input20.aliceHash, swap->I.secretAm, 20); uint8arrayToHex(input20.aliceHash, swap->I.secretAm, 20);
satoshisToWei(input20.amount, swap->bobpayment.I.amount); satoshisToWei(input20.amount, swap->bobpayment.I.amount);
strcpy(input20.tokenAddress, swap->I.bobtomic); strcpy(input20.tokenAddress, swap->I.bobtomic);
input20.lockTime = swap->bobpayment.I.locktime; input20.lockTime = swap->bobpayment.I.locktime;
input20.decimals = bobcoin->decimals;
strcpy(txData.from, swap->I.etomicsrc); strcpy(txData.from, swap->I.etomicsrc);
strcpy(txData.to, ETOMIC_BOBCONTRACT); strcpy(txData.to, ETOMIC_BOBCONTRACT);
strcpy(txData.amount, "0"); strcpy(txData.amount, "0");
uint8arrayToHex(txData.secretKey, swap->persistent_privkey.bytes, 32); uint8arrayToHex(txData.secretKey, swap->persistent_privkey.bytes, 32);
uint64_t allowance = getErc20Allowance(swap->I.etomicsrc, ETOMIC_BOBCONTRACT, swap->I.bobtomic); uint64_t allowance = getErc20Allowance(swap->I.etomicsrc, ETOMIC_BOBCONTRACT, swap->I.bobtomic, bobcoin->decimals);
if (allowance < swap->bobpayment.I.amount) { if (allowance < swap->bobpayment.I.amount) {
printf("Bob token allowance is too low, setting new allowance\n"); printf("Bob token allowance is too low, setting new allowance\n");
ApproveErc20Input approveErc20Input; ApproveErc20Input approveErc20Input;
@ -504,12 +530,15 @@ uint8_t LP_etomic_verify_bob_payment(struct basilisk_swap *swap, char *txId)
return verifyBobEthPaymentData(input, data.input); return verifyBobEthPaymentData(input, data.input);
} else { } else {
struct iguana_info *bobcoin = LP_coinfind(swap->I.bobstr);
uint8arrayToHex(input20.paymentId, swap->bobpayment.I.actualtxid.bytes, 32); uint8arrayToHex(input20.paymentId, swap->bobpayment.I.actualtxid.bytes, 32);
strcpy(input20.aliceAddress, swap->I.etomicdest); strcpy(input20.aliceAddress, swap->I.etomicdest);
uint8arrayToHex(input20.aliceHash, swap->I.secretAm, 20); uint8arrayToHex(input20.aliceHash, swap->I.secretAm, 20);
satoshisToWei(input20.amount, swap->bobpayment.I.amount); satoshisToWei(input20.amount, swap->bobpayment.I.amount);
strcpy(input20.tokenAddress, swap->I.bobtomic); strcpy(input20.tokenAddress, swap->I.bobtomic);
input20.lockTime = swap->bobpayment.I.locktime; input20.lockTime = swap->bobpayment.I.locktime;
input20.decimals = bobcoin->decimals;
return verifyBobErc20PaymentData(input20, data.input); return verifyBobErc20PaymentData(input20, data.input);
} }
@ -526,9 +555,10 @@ char *LP_etomicbob_reclaims_payment(struct LP_swap_remember *swap)
memset(&txData,0,sizeof(txData)); memset(&txData,0,sizeof(txData));
memset(&input,0,sizeof(input)); memset(&input,0,sizeof(input));
struct iguana_info *ecoin; struct iguana_info *ecoin, *bobcoin;
bits256 privkey; bits256 privkey;
ecoin = LP_coinfind("ETOMIC"); ecoin = LP_coinfind("ETOMIC");
bobcoin = LP_coinfind(swap->bobcoin);
privkey = LP_privkey(ecoin->symbol, ecoin->smartaddr, ecoin->taddr); privkey = LP_privkey(ecoin->symbol, ecoin->smartaddr, ecoin->taddr);
EthTxReceipt receipt = getEthTxReceipt(swap->bobPaymentEthTx); EthTxReceipt receipt = getEthTxReceipt(swap->bobPaymentEthTx);
@ -546,6 +576,7 @@ char *LP_etomicbob_reclaims_payment(struct LP_swap_remember *swap)
strcpy(input.tokenAddress, "0x0000000000000000000000000000000000000000"); strcpy(input.tokenAddress, "0x0000000000000000000000000000000000000000");
} }
satoshisToWei(input.amount, swap->values[BASILISK_BOBPAYMENT]); satoshisToWei(input.amount, swap->values[BASILISK_BOBPAYMENT]);
input.decimals = bobcoin->decimals;
strcpy(txData.from, swap->etomicsrc); strcpy(txData.from, swap->etomicsrc);
strcpy(txData.to, ETOMIC_BOBCONTRACT); strcpy(txData.to, ETOMIC_BOBCONTRACT);
@ -570,9 +601,10 @@ char *LP_etomicalice_spends_bob_payment(struct LP_swap_remember *swap)
printf("Bob payment %s receipt status failed, can't spend\n", swap->bobPaymentEthTx); printf("Bob payment %s receipt status failed, can't spend\n", swap->bobPaymentEthTx);
return NULL; return NULL;
} }
struct iguana_info *ecoin; struct iguana_info *ecoin, *bobcoin;
bits256 privkey; bits256 privkey;
ecoin = LP_coinfind("ETOMIC"); ecoin = LP_coinfind("ETOMIC");
bobcoin = LP_coinfind(swap->bobcoin);
privkey = LP_privkey(ecoin->symbol, ecoin->smartaddr, ecoin->taddr); privkey = LP_privkey(ecoin->symbol, ecoin->smartaddr, ecoin->taddr);
uint8arrayToHex(input.paymentId, swap->txids[BASILISK_BOBPAYMENT].bytes, 32); uint8arrayToHex(input.paymentId, swap->txids[BASILISK_BOBPAYMENT].bytes, 32);
@ -591,6 +623,7 @@ char *LP_etomicalice_spends_bob_payment(struct LP_swap_remember *swap)
invertedSecret.bytes[i] = swap->privAm.bytes[31 - i]; invertedSecret.bytes[i] = swap->privAm.bytes[31 - i];
} }
uint8arrayToHex(input.aliceSecret, invertedSecret.bytes, 32); uint8arrayToHex(input.aliceSecret, invertedSecret.bytes, 32);
input.decimals = bobcoin->decimals;
strcpy(txData.from, swap->etomicdest); strcpy(txData.from, swap->etomicdest);
strcpy(txData.to, ETOMIC_BOBCONTRACT); strcpy(txData.to, ETOMIC_BOBCONTRACT);
@ -616,9 +649,10 @@ char *LP_etomicalice_claims_bob_deposit(struct LP_swap_remember *swap)
return NULL; return NULL;
} }
struct iguana_info *ecoin; struct iguana_info *ecoin, *bobcoin;
bits256 privkey; bits256 privkey;
ecoin = LP_coinfind("ETOMIC"); ecoin = LP_coinfind("ETOMIC");
bobcoin = LP_coinfind(swap->bobcoin);
privkey = LP_privkey(ecoin->symbol, ecoin->smartaddr, ecoin->taddr); privkey = LP_privkey(ecoin->symbol, ecoin->smartaddr, ecoin->taddr);
uint8arrayToHex(input.depositId, swap->txids[BASILISK_BOBDEPOSIT].bytes, 32); uint8arrayToHex(input.depositId, swap->txids[BASILISK_BOBDEPOSIT].bytes, 32);
@ -632,6 +666,7 @@ char *LP_etomicalice_claims_bob_deposit(struct LP_swap_remember *swap)
strcpy(input.bobAddress, swap->etomicsrc); strcpy(input.bobAddress, swap->etomicsrc);
uint8arrayToHex(input.bobHash, swap->secretBn, 20); uint8arrayToHex(input.bobHash, swap->secretBn, 20);
input.decimals = bobcoin->decimals;
strcpy(txData.from, swap->etomicdest); strcpy(txData.from, swap->etomicdest);
strcpy(txData.to, ETOMIC_BOBCONTRACT); strcpy(txData.to, ETOMIC_BOBCONTRACT);
@ -718,6 +753,6 @@ uint64_t LP_etomic_get_balance(struct iguana_info *coin, char *coinaddr)
if (strcmp(coin->symbol, "ETH") == 0) { if (strcmp(coin->symbol, "ETH") == 0) {
return getEthBalance(coinaddr); return getEthBalance(coinaddr);
} else { } else {
return getErc20BalanceSatoshi(coinaddr, coin->etomic); return getErc20BalanceSatoshi(coinaddr, coin->etomic, coin->decimals);
} }
} }

2
iguana/exchanges/LP_include.h
View File

@ -312,7 +312,7 @@ struct iguana_info
double price_kmd,force,perc,goal,goalperc,relvolume,rate; double price_kmd,force,perc,goal,goalperc,relvolume,rate;
void *electrum; void *ctx; void *electrum; void *ctx;
uint64_t maxamount,kmd_equiv,balanceA,balanceB,valuesumA,valuesumB; uint64_t maxamount,kmd_equiv,balanceA,balanceB,valuesumA,valuesumB;
uint8_t pubkey33[33],zcash; uint8_t pubkey33[33],zcash,decimals;
int32_t privkeydepth; int32_t privkeydepth;
bits256 cachedtxid,notarizationtxid; uint8_t *cachedtxiddata; int32_t cachedtxidlen; bits256 cachedtxid,notarizationtxid; uint8_t *cachedtxiddata; int32_t cachedtxidlen;
bits256 cachedmerkle,notarizedhash; int32_t cachedmerkleheight; bits256 cachedmerkle,notarizedhash; int32_t cachedmerkleheight;

2
iguana/exchanges/LP_transaction.c
View File

@ -1987,7 +1987,7 @@ char *LP_eth_withdraw(struct iguana_info *coin,cJSON *argjson)
if (strcmp(coin->symbol, "ETH") == 0) { if (strcmp(coin->symbol, "ETH") == 0) {
tx_id = sendEth(dest_addr, amount_str, privkey_str, 0, gas, gas_price, 0); tx_id = sendEth(dest_addr, amount_str, privkey_str, 0, gas, gas_price, 0);
} else { } else {
tx_id = sendErc20(coin->etomic, dest_addr, amount_str, privkey_str, 0, gas, gas_price, 0); tx_id = sendErc20(coin->etomic, dest_addr, amount_str, privkey_str, 0, gas, gas_price, 0, coin->decimals);
} }
if (tx_id != NULL) { if (tx_id != NULL) {
jaddstr(retjson, "tx_id", tx_id); jaddstr(retjson, "tx_id", tx_id);

144
iguana/exchanges/etomicswap/etomiclib.cpp
View File

@ -34,11 +34,11 @@ TransactionSkeleton txDataToSkeleton(BasicTxData txData)
char *signTx(TransactionSkeleton& tx, char* secret) char *signTx(TransactionSkeleton& tx, char* secret)
{ {
Secret& secretKey = *(new Secret(secret)); Secret secretKey(secret);
auto baseTx = new TransactionBase(tx, secretKey); TransactionBase baseTx(tx, secretKey);
RLPStream& rlpStream = *(new RLPStream()); RLPStream rlpStream;
baseTx->streamRLP(rlpStream); baseTx.streamRLP(rlpStream);
std::stringstream& ss = *(new std::stringstream); std::stringstream ss;
ss << rlpStream.out(); ss << rlpStream.out();
return stringStreamToChar(ss); return stringStreamToChar(ss);
} }
@ -101,7 +101,12 @@ uint8_t verifyAliceEthPaymentData(AliceSendsEthPaymentInput input, char *data)
std::stringstream aliceSendsErc20PaymentData(AliceSendsErc20PaymentInput input) std::stringstream aliceSendsErc20PaymentData(AliceSendsErc20PaymentInput input)
{ {
uint8_t decimals = getErc20Decimals(input.tokenAddress); uint8_t decimals;
if (input.decimals > 0) {
decimals = input.decimals;
} else {
decimals = getErc20Decimals(input.tokenAddress);
}
u256 amount = jsToU256(input.amount); u256 amount = jsToU256(input.amount);
if (decimals < 18) { if (decimals < 18) {
amount /= boost::multiprecision::pow(u256(10), 18 - decimals); amount /= boost::multiprecision::pow(u256(10), 18 - decimals);
@ -148,12 +153,20 @@ char* aliceReclaimsAlicePayment(AliceReclaimsAlicePaymentInput input, BasicTxDat
std::stringstream ss; std::stringstream ss;
u256 amount = jsToU256(input.amount); u256 amount = jsToU256(input.amount);
dev::Address tokenAddress = jsToAddress(input.tokenAddress); dev::Address tokenAddress = jsToAddress(input.tokenAddress);
if (tokenAddress != ZeroAddress) { if (tokenAddress != ZeroAddress) {
uint8_t decimals = getErc20Decimals(input.tokenAddress); uint8_t decimals;
if (input.decimals > 0) {
decimals = input.decimals;
} else {
decimals = getErc20Decimals(input.tokenAddress);
}
if (decimals < 18) { if (decimals < 18) {
amount /= boost::multiprecision::pow(u256(10), 18 - decimals); amount /= boost::multiprecision::pow(u256(10), 18 - decimals);
} }
} }
ss << "0x8b9a167a" ss << "0x8b9a167a"
<< toHex(jsToBytes(input.dealId)) << toHex(jsToBytes(input.dealId))
<< toHex(toBigEndian(amount)) << toHex(toBigEndian(amount))
@ -179,12 +192,20 @@ char* bobSpendsAlicePayment(BobSpendsAlicePaymentInput input, BasicTxData txData
std::stringstream ss; std::stringstream ss;
u256 amount = jsToU256(input.amount); u256 amount = jsToU256(input.amount);
dev::Address tokenAddress = jsToAddress(input.tokenAddress); dev::Address tokenAddress = jsToAddress(input.tokenAddress);
if (tokenAddress != ZeroAddress) { if (tokenAddress != ZeroAddress) {
uint8_t decimals = getErc20Decimals(input.tokenAddress); uint8_t decimals;
if (input.decimals > 0) {
decimals = input.decimals;
} else {
decimals = getErc20Decimals(input.tokenAddress);
}
if (decimals < 18) { if (decimals < 18) {
amount /= boost::multiprecision::pow(u256(10), 18 - decimals); amount /= boost::multiprecision::pow(u256(10), 18 - decimals);
} }
} }
ss << "0x392ec66b" ss << "0x392ec66b"
<< toHex(jsToBytes(input.dealId)) << toHex(jsToBytes(input.dealId))
<< toHex(toBigEndian(amount)) << toHex(toBigEndian(amount))
@ -241,7 +262,13 @@ uint8_t verifyBobEthDepositData(BobSendsEthDepositInput input, char *data)
std::stringstream bobSendsErc20DepositData(BobSendsErc20DepositInput input) std::stringstream bobSendsErc20DepositData(BobSendsErc20DepositInput input)
{ {
uint8_t decimals = getErc20Decimals(input.tokenAddress); uint8_t decimals;
if (input.decimals > 0) {
decimals = input.decimals;
} else {
decimals = getErc20Decimals(input.tokenAddress);
}
u256 amount = jsToU256(input.amount); u256 amount = jsToU256(input.amount);
u256 lockTime = input.lockTime; u256 lockTime = input.lockTime;
if (decimals < 18) { if (decimals < 18) {
@ -289,7 +316,13 @@ char* bobRefundsDeposit(BobRefundsDepositInput input, BasicTxData txData)
u256 amount = jsToU256(input.amount); u256 amount = jsToU256(input.amount);
dev::Address tokenAddress = jsToAddress(input.tokenAddress); dev::Address tokenAddress = jsToAddress(input.tokenAddress);
if (tokenAddress != ZeroAddress) { if (tokenAddress != ZeroAddress) {
uint8_t decimals = getErc20Decimals(input.tokenAddress); uint8_t decimals;
if (input.decimals > 0) {
decimals = input.decimals;
} else {
decimals = getErc20Decimals(input.tokenAddress);
}
if (decimals < 18) { if (decimals < 18) {
amount /= boost::multiprecision::pow(u256(10), 18 - decimals); amount /= boost::multiprecision::pow(u256(10), 18 - decimals);
} }
@ -316,7 +349,13 @@ char* aliceClaimsBobDeposit(AliceClaimsBobDepositInput input, BasicTxData txData
u256 amount = jsToU256(input.amount); u256 amount = jsToU256(input.amount);
dev::Address tokenAddress = jsToAddress(input.tokenAddress); dev::Address tokenAddress = jsToAddress(input.tokenAddress);
if (tokenAddress != ZeroAddress) { if (tokenAddress != ZeroAddress) {
uint8_t decimals = getErc20Decimals(input.tokenAddress); uint8_t decimals;
if (input.decimals > 0) {
decimals = input.decimals;
} else {
decimals = getErc20Decimals(input.tokenAddress);
}
if (decimals < 18) { if (decimals < 18) {
amount /= boost::multiprecision::pow(u256(10), 18 - decimals); amount /= boost::multiprecision::pow(u256(10), 18 - decimals);
} }
@ -374,9 +413,15 @@ uint8_t verifyBobEthPaymentData(BobSendsEthPaymentInput input, char *data)
std::stringstream bobSendsErc20PaymentData(BobSendsErc20PaymentInput input) std::stringstream bobSendsErc20PaymentData(BobSendsErc20PaymentInput input)
{ {
uint8_t decimals = getErc20Decimals(input.tokenAddress);
u256 amount = jsToU256(input.amount); u256 amount = jsToU256(input.amount);
u256 lockTime = input.lockTime; u256 lockTime = input.lockTime;
uint8_t decimals;
if (input.decimals > 0) {
decimals = input.decimals;
} else {
decimals = getErc20Decimals(input.tokenAddress);
}
if (decimals < 18) { if (decimals < 18) {
amount /= boost::multiprecision::pow(u256(10), 18 - decimals); amount /= boost::multiprecision::pow(u256(10), 18 - decimals);
} }
@ -422,7 +467,13 @@ char* bobReclaimsBobPayment(BobReclaimsBobPaymentInput input, BasicTxData txData
u256 amount = jsToU256(input.amount); u256 amount = jsToU256(input.amount);
dev::Address tokenAddress = jsToAddress(input.tokenAddress); dev::Address tokenAddress = jsToAddress(input.tokenAddress);
if (tokenAddress != ZeroAddress) { if (tokenAddress != ZeroAddress) {
uint8_t decimals = getErc20Decimals(input.tokenAddress); uint8_t decimals;
if (input.decimals > 0) {
decimals = input.decimals;
} else {
decimals = getErc20Decimals(input.tokenAddress);
}
if (decimals < 18) { if (decimals < 18) {
amount /= boost::multiprecision::pow(u256(10), 18 - decimals); amount /= boost::multiprecision::pow(u256(10), 18 - decimals);
} }
@ -450,7 +501,13 @@ char* aliceSpendsBobPayment(AliceSpendsBobPaymentInput input, BasicTxData txData
u256 amount = jsToU256(input.amount); u256 amount = jsToU256(input.amount);
dev::Address tokenAddress = jsToAddress(input.tokenAddress); dev::Address tokenAddress = jsToAddress(input.tokenAddress);
if (tokenAddress != ZeroAddress) { if (tokenAddress != ZeroAddress) {
uint8_t decimals = getErc20Decimals(input.tokenAddress); uint8_t decimals;
if (input.decimals > 0) {
decimals = input.decimals;
} else {
decimals = getErc20Decimals(input.tokenAddress);
}
if (decimals < 18) { if (decimals < 18) {
amount /= boost::multiprecision::pow(u256(10), 18 - decimals); amount /= boost::multiprecision::pow(u256(10), 18 - decimals);
} }
@ -472,24 +529,24 @@ char* aliceSpendsBobPayment(AliceSpendsBobPaymentInput input, BasicTxData txData
char* privKey2Addr(char* privKey) char* privKey2Addr(char* privKey)
{ {
Secret& secretKey = *(new Secret(privKey)); Secret secretKey(privKey);
std::stringstream& ss = *(new std::stringstream); std::stringstream ss;
ss << "0x" << toAddress(secretKey); ss << "0x" << toAddress(secretKey);
return stringStreamToChar(ss); return stringStreamToChar(ss);
}; };
char* pubKey2Addr(char* pubKey) char* pubKey2Addr(char* pubKey)
{ {
Public& publicKey = *(new Public(pubKey)); Public publicKey(pubKey);
std::stringstream& ss = *(new std::stringstream); std::stringstream ss;
ss << "0x" << toAddress(publicKey); ss << "0x" << toAddress(publicKey);
return stringStreamToChar(ss); return stringStreamToChar(ss);
}; };
char* getPubKeyFromPriv(char* privKey) char* getPubKeyFromPriv(char* privKey)
{ {
Public publicKey = toPublic(*(new Secret(privKey))); Public publicKey = toPublic(Secret(privKey));
std::stringstream& ss = *(new std::stringstream); std::stringstream ss;
ss << "0x" << publicKey; ss << "0x" << publicKey;
return stringStreamToChar(ss); return stringStreamToChar(ss);
} }
@ -503,16 +560,21 @@ uint64_t getEthBalance(char* address)
return static_cast<uint64_t>(balance); return static_cast<uint64_t>(balance);
} }
uint64_t getErc20BalanceSatoshi(char *address, char *tokenAddress) uint64_t getErc20BalanceSatoshi(char *address, char *tokenAddress, uint8_t setDecimals)
{ {
std::stringstream ss; std::stringstream ss;
ss << "0x70a08231" ss << "0x70a08231"
<< "000000000000000000000000" << "000000000000000000000000"
<< toHex(jsToAddress(address)); << toHex(jsToAddress(address));
std::stringstream& resultStream = *(new std::stringstream);
char* hexBalance = ethCall(tokenAddress, ss.str().c_str()); char* hexBalance = ethCall(tokenAddress, ss.str().c_str());
// convert wei to satoshi // convert wei to satoshi
uint8_t decimals = getErc20Decimals(tokenAddress); uint8_t decimals;
if (setDecimals > 0) {
decimals = setDecimals;
} else {
decimals = getErc20Decimals(tokenAddress);
}
u256 balance = jsToU256(hexBalance); u256 balance = jsToU256(hexBalance);
if (decimals < 18) { if (decimals < 18) {
balance *= boost::multiprecision::pow(u256(10), 18 - decimals); balance *= boost::multiprecision::pow(u256(10), 18 - decimals);
@ -532,7 +594,7 @@ char *getErc20BalanceHexWei(char *address, char *tokenAddress)
return hexBalance; return hexBalance;
} }
uint64_t getErc20Allowance(char *owner, char *spender, char *tokenAddress) uint64_t getErc20Allowance(char *owner, char *spender, char *tokenAddress, uint8_t set_decimals)
{ {
std::stringstream ss; std::stringstream ss;
ss << "0xdd62ed3e" ss << "0xdd62ed3e"
@ -541,7 +603,12 @@ uint64_t getErc20Allowance(char *owner, char *spender, char *tokenAddress)
<< "000000000000000000000000" << "000000000000000000000000"
<< toHex(jsToAddress(spender)); << toHex(jsToAddress(spender));
char* hexAllowance = ethCall(tokenAddress, ss.str().c_str()); char* hexAllowance = ethCall(tokenAddress, ss.str().c_str());
uint8_t decimals = getErc20Decimals(tokenAddress); uint8_t decimals;
if (set_decimals > 0) {
decimals = set_decimals;
} else {
decimals = getErc20Decimals(tokenAddress);
}
u256 allowance = jsToU256(hexAllowance); u256 allowance = jsToU256(hexAllowance);
if (decimals < 18) { if (decimals < 18) {
allowance *= boost::multiprecision::pow(u256(10), 18 - decimals); allowance *= boost::multiprecision::pow(u256(10), 18 - decimals);
@ -616,10 +683,15 @@ char *sendEth(char *to, char *amount, char *privKey, uint8_t waitConfirm, int64_
return result; return result;
} }
std::stringstream getErc20TransferData(char *tokenAddress, char *to, char *amount) std::stringstream getErc20TransferData(char *tokenAddress, char *to, char *amount, uint8_t setDecimals)
{ {
u256 amountWei = jsToU256(amount); u256 amountWei = jsToU256(amount);
uint8_t decimals = getErc20Decimals(tokenAddress); uint8_t decimals;
if (setDecimals > 0) {
decimals = setDecimals;
} else {
decimals = getErc20Decimals(tokenAddress);
}
if (decimals < 18) { if (decimals < 18) {
amountWei /= boost::multiprecision::pow(u256(10), 18 - decimals); amountWei /= boost::multiprecision::pow(u256(10), 18 - decimals);
} }
@ -632,11 +704,21 @@ std::stringstream getErc20TransferData(char *tokenAddress, char *to, char *amoun
return ss; return ss;
} }
char *sendErc20(char *tokenAddress, char *to, char *amount, char *privKey, uint8_t waitConfirm, int64_t gas, int64_t gasPrice, uint8_t defaultGasOnErr) char *sendErc20(
char *tokenAddress,
char *to,
char *amount,
char *privKey,
uint8_t waitConfirm,
int64_t gas,
int64_t gasPrice,
uint8_t defaultGasOnErr,
uint8_t decimals
)
{ {
TransactionSkeleton tx; TransactionSkeleton tx;
char *from = privKey2Addr(privKey), *result; char *from = privKey2Addr(privKey), *result;
std::stringstream ss = getErc20TransferData(tokenAddress, to, amount); std::stringstream ss = getErc20TransferData(tokenAddress, to, amount, decimals);
tx.from = jsToAddress(from); tx.from = jsToAddress(from);
tx.to = jsToAddress(tokenAddress); tx.to = jsToAddress(tokenAddress);
@ -676,9 +758,9 @@ char *sendErc20(char *tokenAddress, char *to, char *amount, char *privKey, uint8
return result; return result;
} }
uint8_t verifyAliceErc20FeeData(char* tokenAddress, char *to, char *amount, char *data) uint8_t verifyAliceErc20FeeData(char* tokenAddress, char *to, char *amount, char *data, uint8_t decimals)
{ {
std::stringstream ss = getErc20TransferData(tokenAddress, to, amount); std::stringstream ss = getErc20TransferData(tokenAddress, to, amount, decimals);
if (strcmp(ss.str().c_str(), data) != 0) { if (strcmp(ss.str().c_str(), data) != 0) {
printf("Alice ERC20 fee data %s is not equal to expected %s\n", data, ss.str().c_str()); printf("Alice ERC20 fee data %s is not equal to expected %s\n", data, ss.str().c_str());
return 0; return 0;

29
iguana/exchanges/etomicswap/etomiclib.h
View File

@ -38,6 +38,7 @@ typedef struct {
char bobAddress[65]; char bobAddress[65];
char aliceHash[65]; char aliceHash[65];
char bobHash[65]; char bobHash[65];
uint8_t decimals;
} AliceSendsErc20PaymentInput; } AliceSendsErc20PaymentInput;
typedef struct { typedef struct {
@ -47,6 +48,7 @@ typedef struct {
char bobAddress[65]; char bobAddress[65];
char aliceHash[65]; char aliceHash[65];
char bobSecret[70]; char bobSecret[70];
uint8_t decimals;
} AliceReclaimsAlicePaymentInput; } AliceReclaimsAlicePaymentInput;
typedef struct { typedef struct {
@ -56,6 +58,7 @@ typedef struct {
char aliceAddress[65]; char aliceAddress[65];
char aliceSecret[70]; char aliceSecret[70];
char bobHash[65]; char bobHash[65];
uint8_t decimals;
} BobSpendsAlicePaymentInput; } BobSpendsAlicePaymentInput;
typedef struct { typedef struct {
@ -72,6 +75,7 @@ typedef struct {
char aliceAddress[65]; char aliceAddress[65];
char bobHash[65]; char bobHash[65];
uint64_t lockTime; uint64_t lockTime;
uint8_t decimals;
} BobSendsErc20DepositInput; } BobSendsErc20DepositInput;
typedef struct { typedef struct {
@ -80,6 +84,7 @@ typedef struct {
char tokenAddress[65]; char tokenAddress[65];
char aliceAddress[65]; char aliceAddress[65];
char bobSecret[70]; char bobSecret[70];
uint8_t decimals;
} BobRefundsDepositInput; } BobRefundsDepositInput;
typedef struct { typedef struct {
@ -88,6 +93,7 @@ typedef struct {
char tokenAddress[65]; char tokenAddress[65];
char bobAddress[65]; char bobAddress[65];
char bobHash[65]; char bobHash[65];
uint8_t decimals;
} AliceClaimsBobDepositInput; } AliceClaimsBobDepositInput;
typedef struct { typedef struct {
@ -104,6 +110,7 @@ typedef struct {
char aliceAddress[65]; char aliceAddress[65];
char aliceHash[65]; char aliceHash[65];
uint64_t lockTime; uint64_t lockTime;
uint8_t decimals;
} BobSendsErc20PaymentInput; } BobSendsErc20PaymentInput;
typedef struct { typedef struct {
@ -112,6 +119,7 @@ typedef struct {
char tokenAddress[65]; char tokenAddress[65];
char aliceAddress[65]; char aliceAddress[65];
char aliceHash[65]; char aliceHash[65];
uint8_t decimals;
} BobReclaimsBobPaymentInput; } BobReclaimsBobPaymentInput;
typedef struct { typedef struct {
@ -120,6 +128,7 @@ typedef struct {
char tokenAddress[65]; char tokenAddress[65];
char aliceSecret[70]; char aliceSecret[70];
char bobAddress[65]; char bobAddress[65];
uint8_t decimals;
} AliceSpendsBobPaymentInput; } AliceSpendsBobPaymentInput;
typedef struct { typedef struct {
@ -165,22 +174,32 @@ char* getPubKeyFromPriv(char* privKey);
// returns satoshis, not wei! // returns satoshis, not wei!
uint64_t getEthBalance(char* address); uint64_t getEthBalance(char* address);
uint64_t getErc20BalanceSatoshi(char* address, char tokenAddress[65]); uint64_t getErc20BalanceSatoshi(char *address, char *tokenAddress, uint8_t setDecimals);
char *getErc20BalanceHexWei(char* address, char tokenAddress[65]); char *getErc20BalanceHexWei(char* address, char tokenAddress[65]);
uint8_t getErc20Decimals(char *tokenAddress); uint8_t getErc20Decimals(char *tokenAddress);
// returns satoshis, not wei! // returns satoshis, not wei!
uint64_t getErc20Allowance(char *owner, char *spender, char *tokenAddress); uint64_t getErc20Allowance(char *owner, char *spender, char *tokenAddress, uint8_t set_decimals);
void uint8arrayToHex(char *dest, uint8_t *input, int len); void uint8arrayToHex(char *dest, uint8_t *input, int len);
void satoshisToWei(char *dest, uint64_t input); void satoshisToWei(char *dest, uint64_t input);
uint64_t weiToSatoshi(char *wei); uint64_t weiToSatoshi(char *wei);
char *sendEth(char *to, char *amount, char *privKey, uint8_t waitConfirm, int64_t gas, int64_t gasPrice, uint8_t defaultGasOnErr); char *sendEth(char *to, char *amount, char *privKey, uint8_t waitConfirm, int64_t gas, int64_t gasPrice, uint8_t defaultGasOnErr);
char *sendErc20(char *tokenAddress, char *to, char *amount, char *privKey, uint8_t waitConfirm, int64_t gas, int64_t gasPrice, uint8_t defaultGasOnErr); char *sendErc20(
char *tokenAddress,
uint8_t verifyAliceErc20FeeData(char* tokenAddress, char *to, char *amount, char *data); char *to,
char *amount,
char *privKey,
uint8_t waitConfirm,
int64_t gas,
int64_t gasPrice,
uint8_t defaultGasOnErr,
uint8_t decimals
);
uint8_t verifyAliceErc20FeeData(char* tokenAddress, char *to, char *amount, char *data, uint8_t decimals);
// Your prototype or Definition // Your prototype or Definition
#ifdef __cplusplus #ifdef __cplusplus
} }

Write Preview
Loading…
Cancel
Save