+
@@ -527,7 +546,7 @@
-
+
@@ -542,7 +561,7 @@
- Convert assets
Requests
No requests to process
+
-
+
-
-
+
-
+
No requests to process
@@ -551,7 +570,7 @@
+
@@ -584,7 +603,7 @@
Applied filters
No transactions
-
+
@@ -614,7 +633,7 @@
Pending
@@ -688,7 +707,7 @@
Tap on saved IDs to see transaction history
-
+
-
+
-
Payment
@@ -716,7 +735,7 @@
-
+
@@ -729,7 +748,7 @@
Pending requests
+
-
+
-
-
Settings
@@ -795,7 +814,7 @@
+
-
+
-
+
-
+
-
Select UPI ID to receive money
@@ -1190,7 +1209,7 @@ onclick="withdrawMoneyFromWallet()" type="submit">Withdraw
+
-
Sent transfer to bank request
This may take upto 30 mins to complete
- Check transaction on + Check transaction on blockchain
+
-
+
-
+
-
-
+
+
@@ -1467,7 +1486,7 @@
Other
-
Select reason
+
OP_CHECKLOCKTIMEVERIFY OP_DROP OP_CHECKSIG ^
+ r = {}
+ r.pubkey = Crypto.util.bytesToHex(s.chunks[3]);
+ r.checklocktimeverify = coinjs.bytesToNum(s.chunks[0].slice());
+ r.address = coinjs.simpleHodlAddress(r.pubkey, r.checklocktimeverify).address;
+ var rs = Crypto.util.bytesToHex(s.buffer);
+ r.redeemscript = rs;
+ r.type = "hodl__";
+ }
+ } catch (e) {
+ // console.log(e);
+ r = false;
+ }
+ return r;
+ }
+
+ /* create output script to spend */
+ r.spendToScript = function(address) {
+ var addr = coinjs.addressDecode(address);
+ var s = coinjs.script();
+ if (addr.type == "bech32") {
+ s.writeOp(0);
+ s.writeBytes(Crypto.util.hexToBytes(addr.redeemscript));
+ } else if (addr.version == coinjs.multisig) { // multisig address
+ s.writeOp(169); //OP_HASH160
+ s.writeBytes(addr.bytes);
+ s.writeOp(135); //OP_EQUAL
+ } else { // regular address
+ s.writeOp(118); //OP_DUP
+ s.writeOp(169); //OP_HASH160
+ s.writeBytes(addr.bytes);
+ s.writeOp(136); //OP_EQUALVERIFY
+ s.writeOp(172); //OP_CHECKSIG
+ }
+ return s;
+ }
+
+ /* geneate a (script) pubkey hash of the address - used for when signing */
+ r.pubkeyHash = function(address) {
+ var addr = coinjs.addressDecode(address);
+ var s = coinjs.script();
+ s.writeOp(118); //OP_DUP
+ s.writeOp(169); //OP_HASH160
+ s.writeBytes(addr.bytes);
+ s.writeOp(136); //OP_EQUALVERIFY
+ s.writeOp(172); //OP_CHECKSIG
+ return s;
+ }
+
+ /* write to buffer */
+ r.writeOp = function(op) {
+ this.buffer.push(op);
+ this.chunks.push(op);
+ return true;
+ }
+
+ /* write bytes to buffer */
+ r.writeBytes = function(data) {
+ if (data.length < 76) { //OP_PUSHDATA1
+ this.buffer.push(data.length);
+ } else if (data.length <= 0xff) {
+ this.buffer.push(76); //OP_PUSHDATA1
+ this.buffer.push(data.length);
+ } else if (data.length <= 0xffff) {
+ this.buffer.push(77); //OP_PUSHDATA2
+ this.buffer.push(data.length & 0xff);
+ this.buffer.push((data.length >>> 8) & 0xff);
+ } else {
+ this.buffer.push(78); //OP_PUSHDATA4
+ this.buffer.push(data.length & 0xff);
+ this.buffer.push((data.length >>> 8) & 0xff);
+ this.buffer.push((data.length >>> 16) & 0xff);
+ this.buffer.push((data.length >>> 24) & 0xff);
+ }
+ this.buffer = this.buffer.concat(data);
+ this.chunks.push(data);
+ return true;
+ }
+
+ r.parse();
+ return r;
+ }
+
+ /* start of transaction functions */
+
+ /* create a new transaction object */
+ coinjs.transaction = function() {
+
+ var r = {};
+ r.version = 1;
+ r.lock_time = 0;
+ r.ins = [];
+ r.outs = [];
+ r.witness = false;
+ r.timestamp = null;
+ r.block = null;
+
+ /* add an input to a transaction */
+ r.addinput = function(txid, index, script, sequence) {
+ var o = {};
+ o.outpoint = {
+ 'hash': txid,
+ 'index': index
+ };
+ o.script = coinjs.script(script || []);
+ o.sequence = sequence || ((r.lock_time == 0) ? 4294967295 : 0);
+ return this.ins.push(o);
+ }
+
+ /* add an output to a transaction */
+ r.addoutput = function(address, value) {
+ var o = {};
+ o.value = new BigInteger('' + Math.round((value * 1) * 1e8), 10);
+ var s = coinjs.script();
+ o.script = s.spendToScript(address);
+
+ return this.outs.push(o);
+ }
+
+ /* add two outputs for stealth addresses to a transaction */
+ r.addstealth = function(stealth, value) {
+ var ephemeralKeyBigInt = BigInteger.fromByteArrayUnsigned(Crypto.util.hexToBytes(coinjs.newPrivkey()));
+ var curve = EllipticCurve.getSECCurveByName("secp256k1");
+
+ var p = EllipticCurve.fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
+ var a = BigInteger.ZERO;
+ var b = EllipticCurve.fromHex("7");
+ var calccurve = new EllipticCurve.CurveFp(p, a, b);
+
+ var ephemeralPt = curve.getG().multiply(ephemeralKeyBigInt);
+ var scanPt = calccurve.decodePointHex(stealth.scankey);
+ var sharedPt = scanPt.multiply(ephemeralKeyBigInt);
+ var stealthindexKeyBigInt = BigInteger.fromByteArrayUnsigned(Crypto.SHA256(sharedPt.getEncoded(true), {
+ asBytes: true
+ }));
+
+ var stealthindexPt = curve.getG().multiply(stealthindexKeyBigInt);
+ var spendPt = calccurve.decodePointHex(stealth.spendkey);
+ var addressPt = spendPt.add(stealthindexPt);
+
+ var sendaddress = coinjs.pubkey2address(Crypto.util.bytesToHex(addressPt.getEncoded(true)));
+
+
+ var OPRETBytes = [6].concat(Crypto.util.randomBytes(4)).concat(ephemeralPt.getEncoded(true)); // ephemkey data
+ var q = coinjs.script();
+ q.writeOp(106); // OP_RETURN
+ q.writeBytes(OPRETBytes);
+ v = {};
+ v.value = 0;
+ v.script = q;
+
+ this.outs.push(v);
+
+ var o = {};
+ o.value = new BigInteger('' + Math.round((value * 1) * 1e8), 10);
+ var s = coinjs.script();
+ o.script = s.spendToScript(sendaddress);
+
+ return this.outs.push(o);
+ }
+
+ /* add data to a transaction */
+ r.adddata = function(data) {
+ var r = false;
+ if (((data.match(/^[a-f0-9]+$/gi)) && data.length < 160) && (data.length % 2) == 0) {
+ var s = coinjs.script();
+ s.writeOp(106); // OP_RETURN
+ s.writeBytes(Crypto.util.hexToBytes(data));
+ o = {};
+ o.value = 0;
+ o.script = s;
+ return this.outs.push(o);
+ }
+ return r;
+ }
+
+ /* list unspent transactions */
+ r.listUnspent = function(address, callback) {
+ coinjs.ajax(coinjs.host + '?uid=' + coinjs.uid + '&key=' + coinjs.key + '&setmodule=addresses&request=unspent&address=' + address + '&r=' + Math.random(), callback, "GET");
+ }
+
+ /* list transaction data */
+ r.getTransaction = function(txid, callback) {
+ coinjs.ajax(coinjs.host + '?uid=' + coinjs.uid + '&key=' + coinjs.key + '&setmodule=bitcoin&request=gettransaction&txid=' + txid + '&r=' + Math.random(), callback, "GET");
+ }
+
+ /* add unspent to transaction */
+ r.addUnspent = function(address, callback, script, segwit, sequence) {
+ var self = this;
+ this.listUnspent(address, function(data) {
+ var s = coinjs.script();
+ var value = 0;
+ var total = 0;
+ var x = {};
+
+ if (GLOBAL.DOMParser) {
+ parser = new DOMParser();
+ xmlDoc = parser.parseFromString(data, "text/xml");
+ } else {
+ xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
+ xmlDoc.async = false;
+ xmlDoc.loadXML(data);
+ }
+
+ var unspent = xmlDoc.getElementsByTagName("unspent")[0];
+
+ if (unspent) {
+ for (i = 1; i <= unspent.childElementCount; i++) {
+ var u = xmlDoc.getElementsByTagName("unspent_" + i)[0]
+ var txhash = (u.getElementsByTagName("tx_hash")[0].childNodes[0].nodeValue).match(/.{1,2}/g).reverse().join("") + '';
+ var n = u.getElementsByTagName("tx_output_n")[0].childNodes[0].nodeValue;
+ var scr = script || u.getElementsByTagName("script")[0].childNodes[0].nodeValue;
+
+ if (segwit) {
+ /* this is a small hack to include the value with the redeemscript to make the signing procedure smoother.
+ It is not standard and removed during the signing procedure. */
+
+ s = coinjs.script();
+ s.writeBytes(Crypto.util.hexToBytes(script));
+ s.writeOp(0);
+ s.writeBytes(coinjs.numToBytes(u.getElementsByTagName("value")[0].childNodes[0].nodeValue * 1, 8));
+ scr = Crypto.util.bytesToHex(s.buffer);
+ }
+
+ var seq = sequence || false;
+ self.addinput(txhash, n, scr, seq);
+ value += u.getElementsByTagName("value")[0].childNodes[0].nodeValue * 1;
+ total++;
+ }
+ }
+
+ x.result = xmlDoc.getElementsByTagName("result")[0].childNodes[0].nodeValue;
+ x.unspent = unspent;
+ x.value = value;
+ x.total = total;
+ x.response = xmlDoc.getElementsByTagName("response")[0].childNodes[0].nodeValue;
+
+ return callback(x);
+ });
+ }
+
+ /* add unspent and sign */
+ r.addUnspentAndSign = function(wif, callback) {
+ var self = this;
+ var address = coinjs.wif2address(wif);
+ self.addUnspent(address['address'], function(data) {
+ self.sign(wif);
+ return callback(data);
+ });
+ }
+
+ /* broadcast a transaction */
+ r.broadcast = function(callback, txhex) {
+ var tx = txhex || this.serialize();
+ coinjs.ajax(coinjs.host + '?uid=' + coinjs.uid + '&key=' + coinjs.key + '&setmodule=bitcoin&request=sendrawtransaction', callback, "POST", ["rawtx=" + tx]);
+ }
+
+ /* generate the transaction hash to sign from a transaction input */
+ r.transactionHash = function(index, sigHashType) {
+
+ var clone = coinjs.clone(this);
+ var shType = sigHashType || 1;
+
+ /* black out all other ins, except this one */
+ for (var i = 0; i < clone.ins.length; i++) {
+ if (index != i) {
+ clone.ins[i].script = coinjs.script();
+ }
+ }
+
+ var extract = this.extractScriptKey(index);
+ clone.ins[index].script = coinjs.script(extract['script']);
+
+ if ((clone.ins) && clone.ins[index]) {
+
+ /* SIGHASH : For more info on sig hashs see https://en.bitcoin.it/wiki/OP_CHECKSIG
+ and https://bitcoin.org/en/developer-guide#signature-hash-type */
+
+ if (shType == 1) {
+ //SIGHASH_ALL 0x01
+
+ } else if (shType == 2) {
+ //SIGHASH_NONE 0x02
+ clone.outs = [];
+ for (var i = 0; i < clone.ins.length; i++) {
+ if (index != i) {
+ clone.ins[i].sequence = 0;
+ }
+ }
+
+ } else if (shType == 3) {
+
+ //SIGHASH_SINGLE 0x03
+ clone.outs.length = index + 1;
+
+ for (var i = 0; i < index; i++) {
+ clone.outs[i].value = -1;
+ clone.outs[i].script.buffer = [];
+ }
+
+ for (var i = 0; i < clone.ins.length; i++) {
+ if (index != i) {
+ clone.ins[i].sequence = 0;
+ }
+ }
+
+ } else if (shType >= 128) {
+ //SIGHASH_ANYONECANPAY 0x80
+ clone.ins = [clone.ins[index]];
+
+ if (shType == 129) {
+ // SIGHASH_ALL + SIGHASH_ANYONECANPAY
+
+ } else if (shType == 130) {
+ // SIGHASH_NONE + SIGHASH_ANYONECANPAY
+ clone.outs = [];
+
+ } else if (shType == 131) {
+ // SIGHASH_SINGLE + SIGHASH_ANYONECANPAY
+ clone.outs.length = index + 1;
+ for (var i = 0; i < index; i++) {
+ clone.outs[i].value = -1;
+ clone.outs[i].script.buffer = [];
+ }
+ }
+ }
+
+ var buffer = Crypto.util.hexToBytes(clone.serialize());
+ buffer = buffer.concat(coinjs.numToBytes(parseInt(shType), 4));
+ var hash = Crypto.SHA256(buffer, {
+ asBytes: true
+ });
+ var r = Crypto.util.bytesToHex(Crypto.SHA256(hash, {
+ asBytes: true
+ }));
+ return r;
+ } else {
+ return false;
+ }
+ }
+
+ /* generate a segwit transaction hash to sign from a transaction input */
+ r.transactionHashSegWitV0 = function(index, sigHashType) {
+ /*
+ Notice: coinb.in by default, deals with segwit transactions in a non-standard way.
+ Segwit transactions require that input values are included in the transaction hash.
+ To save wasting resources and potentially slowing down this service, we include the amount with the
+ redeem script to generate the transaction hash and remove it after its signed.
+ */
+
+ // start redeem script check
+ var extract = this.extractScriptKey(index);
+ if (extract['type'] != 'segwit') {
+ return {
+ 'result': 0,
+ 'fail': 'redeemscript',
+ 'response': 'redeemscript missing or not valid for segwit'
+ };
+ }
+
+ if (extract['value'] == -1) {
+ return {
+ 'result': 0,
+ 'fail': 'value',
+ 'response': 'unable to generate a valid segwit hash without a value'
+ };
+ }
+
+ var scriptcode = Crypto.util.hexToBytes(extract['script']);
+
+ // end of redeem script check
+
+ /* P2WPKH */
+ if (scriptcode.length == 20) {
+ scriptcode = [0x00, 0x14].concat(scriptcode);
+ }
+
+ if (scriptcode.length == 22) {
+ scriptcode = scriptcode.slice(1);
+ scriptcode.unshift(25, 118, 169);
+ scriptcode.push(136, 172);
+ }
+
+ var value = coinjs.numToBytes(extract['value'], 8);
+
+ // start
+
+ var zero = coinjs.numToBytes(0, 32);
+ var version = coinjs.numToBytes(parseInt(this.version), 4);
+
+ var bufferTmp = [];
+ if (!(sigHashType >= 80)) { // not sighash anyonecanpay
+ for (var i = 0; i < this.ins.length; i++) {
+ bufferTmp = bufferTmp.concat(Crypto.util.hexToBytes(this.ins[i].outpoint.hash).reverse());
+ bufferTmp = bufferTmp.concat(coinjs.numToBytes(this.ins[i].outpoint.index, 4));
+ }
+ }
+ var hashPrevouts = bufferTmp.length >= 1 ? Crypto.SHA256(Crypto.SHA256(bufferTmp, {
+ asBytes: true
+ }), {
+ asBytes: true
+ }) : zero;
+
+ var bufferTmp = [];
+ if (!(sigHashType >= 80) && sigHashType != 2 && sigHashType != 3) { // not sighash anyonecanpay & single & none
+ for (var i = 0; i < this.ins.length; i++) {
+ bufferTmp = bufferTmp.concat(coinjs.numToBytes(this.ins[i].sequence, 4));
+ }
+ }
+ var hashSequence = bufferTmp.length >= 1 ? Crypto.SHA256(Crypto.SHA256(bufferTmp, {
+ asBytes: true
+ }), {
+ asBytes: true
+ }) : zero;
+
+ var outpoint = Crypto.util.hexToBytes(this.ins[index].outpoint.hash).reverse();
+ outpoint = outpoint.concat(coinjs.numToBytes(this.ins[index].outpoint.index, 4));
+
+ var nsequence = coinjs.numToBytes(this.ins[index].sequence, 4);
+ var hashOutputs = zero;
+ var bufferTmp = [];
+ if (sigHashType != 2 && sigHashType != 3) { // not sighash single & none
+ for (var i = 0; i < this.outs.length; i++) {
+ bufferTmp = bufferTmp.concat(coinjs.numToBytes(this.outs[i].value, 8));
+ bufferTmp = bufferTmp.concat(coinjs.numToVarInt(this.outs[i].script.buffer.length));
+ bufferTmp = bufferTmp.concat(this.outs[i].script.buffer);
+ }
+ hashOutputs = Crypto.SHA256(Crypto.SHA256(bufferTmp, {
+ asBytes: true
+ }), {
+ asBytes: true
+ });
+
+ } else if ((sigHashType == 2) && index < this.outs.length) { // is sighash single
+ bufferTmp = bufferTmp.concat(coinjs.numToBytes(this.outs[index].value, 8));
+ bufferTmp = bufferTmp.concat(coinjs.numToVarInt(this.outs[i].script.buffer.length));
+ bufferTmp = bufferTmp.concat(this.outs[index].script.buffer);
+ hashOutputs = Crypto.SHA256(Crypto.SHA256(bufferTmp, {
+ asBytes: true
+ }), {
+ asBytes: true
+ });
+ }
+
+ var locktime = coinjs.numToBytes(this.lock_time, 4);
+ var sighash = coinjs.numToBytes(sigHashType, 4);
+
+ var buffer = [];
+ buffer = buffer.concat(version);
+ buffer = buffer.concat(hashPrevouts);
+ buffer = buffer.concat(hashSequence);
+ buffer = buffer.concat(outpoint);
+ buffer = buffer.concat(scriptcode);
+ buffer = buffer.concat(value);
+ buffer = buffer.concat(nsequence);
+ buffer = buffer.concat(hashOutputs);
+ buffer = buffer.concat(locktime);
+ buffer = buffer.concat(sighash);
+
+ var hash = Crypto.SHA256(buffer, {
+ asBytes: true
+ });
+ return {
+ 'result': 1,
+ 'hash': Crypto.util.bytesToHex(Crypto.SHA256(hash, {
+ asBytes: true
+ })),
+ 'response': 'hash generated'
+ };
+ }
+
+ /* extract the scriptSig, used in the transactionHash() function */
+ r.extractScriptKey = function(index) {
+ if (this.ins[index]) {
+ if ((this.ins[index].script.chunks.length == 5) && this.ins[index].script.chunks[4] == 172 && coinjs.isArray(this.ins[index].script.chunks[2])) { //OP_CHECKSIG
+ // regular scriptPubkey (not signed)
+ return {
+ 'type': 'scriptpubkey',
+ 'signed': 'false',
+ 'signatures': 0,
+ 'script': Crypto.util.bytesToHex(this.ins[index].script.buffer)
+ };
+ } else if ((this.ins[index].script.chunks.length == 2) && this.ins[index].script.chunks[0][0] == 48 && this.ins[index].script.chunks[1].length == 5 && this.ins[index].script.chunks[1][1] == 177) { //OP_CHECKLOCKTIMEVERIFY
+ // hodl script (signed)
+ return {
+ 'type': 'hodl',
+ 'signed': 'true',
+ 'signatures': 1,
+ 'script': Crypto.util.bytesToHex(this.ins[index].script.buffer)
+ };
+ } else if ((this.ins[index].script.chunks.length == 2) && this.ins[index].script.chunks[0][0] == 48) {
+ // regular scriptPubkey (probably signed)
+ return {
+ 'type': 'scriptpubkey',
+ 'signed': 'true',
+ 'signatures': 1,
+ 'script': Crypto.util.bytesToHex(this.ins[index].script.buffer)
+ };
+ } else if (this.ins[index].script.chunks.length == 5 && this.ins[index].script.chunks[1] == 177) { //OP_CHECKLOCKTIMEVERIFY
+ // hodl script (not signed)
+ return {
+ 'type': 'hodl',
+ 'signed': 'false',
+ 'signatures': 0,
+ 'script': Crypto.util.bytesToHex(this.ins[index].script.buffer)
+ };
+ } else if ((this.ins[index].script.chunks.length <= 3 && this.ins[index].script.chunks.length > 0) && ((this.ins[index].script.chunks[0].length == 22 && this.ins[index].script.chunks[0][0] == 0) || (this.ins[index].script.chunks[0].length == 20 && this.ins[index].script.chunks[1] == 0))) {
+ var signed = ((this.witness[index]) && this.witness[index].length == 2) ? 'true' : 'false';
+ var sigs = (signed == 'true') ? 1 : 0;
+ var value = -1; // no value found
+ if ((this.ins[index].script.chunks[2]) && this.ins[index].script.chunks[2].length == 8) {
+ value = coinjs.bytesToNum(this.ins[index].script.chunks[2]); // value found encoded in transaction (THIS IS NON STANDARD)
+ }
+ return {
+ 'type': 'segwit',
+ 'signed': signed,
+ 'signatures': sigs,
+ 'script': Crypto.util.bytesToHex(this.ins[index].script.chunks[0]),
+ 'value': value
+ };
+ } else if (this.ins[index].script.chunks[0] == 0 && this.ins[index].script.chunks[this.ins[index].script.chunks.length - 1][this.ins[index].script.chunks[this.ins[index].script.chunks.length - 1].length - 1] == 174) { // OP_CHECKMULTISIG
+ // multisig script, with signature(s) included
+ var sigcount = 0;
+ for (i = 1; i < this.ins[index].script.chunks.length - 1; i++) {
+ if (this.ins[index].script.chunks[i] != 0) {
+ sigcount++;
+ }
+ }
+
+ return {
+ 'type': 'multisig',
+ 'signed': 'true',
+ 'signatures': sigcount,
+ 'script': Crypto.util.bytesToHex(this.ins[index].script.chunks[this.ins[index].script.chunks.length - 1])
+ };
+ } else if (this.ins[index].script.chunks[0] >= 80 && this.ins[index].script.chunks[this.ins[index].script.chunks.length - 1] == 174) { // OP_CHECKMULTISIG
+ // multisig script, without signature!
+ return {
+ 'type': 'multisig',
+ 'signed': 'false',
+ 'signatures': 0,
+ 'script': Crypto.util.bytesToHex(this.ins[index].script.buffer)
+ };
+ } else if (this.ins[index].script.chunks.length == 0) {
+ // empty
+ //bech32 witness check
+ var signed = ((this.witness[index]) && this.witness[index].length == 2) ? 'true' : 'false';
+ var sigs = (signed == 'true') ? 1 : 0;
+ return {
+ 'type': 'empty',
+ 'signed': signed,
+ 'signatures': sigs,
+ 'script': ''
+ };
+ } else {
+ // something else
+ return {
+ 'type': 'unknown',
+ 'signed': 'false',
+ 'signatures': 0,
+ 'script': Crypto.util.bytesToHex(this.ins[index].script.buffer)
+ };
+ }
+ } else {
+ return false;
+ }
+ }
+
+ /* generate a signature from a transaction hash */
+ r.transactionSig = function(index, wif, sigHashType, txhash) {
+
+ function serializeSig(r, s) {
+ var rBa = r.toByteArraySigned();
+ var sBa = s.toByteArraySigned();
+
+ var sequence = [];
+ sequence.push(0x02); // INTEGER
+ sequence.push(rBa.length);
+ sequence = sequence.concat(rBa);
+
+ sequence.push(0x02); // INTEGER
+ sequence.push(sBa.length);
+ sequence = sequence.concat(sBa);
+
+ sequence.unshift(sequence.length);
+ sequence.unshift(0x30); // SEQUENCE
+
+ return sequence;
+ }
+
+ var shType = sigHashType || 1;
+ var hash = txhash || Crypto.util.hexToBytes(this.transactionHash(index, shType));
+
+ if (hash) {
+ var curve = EllipticCurve.getSECCurveByName("secp256k1");
+ var key = coinjs.wif2privkey(wif);
+ var priv = BigInteger.fromByteArrayUnsigned(Crypto.util.hexToBytes(key['privkey']));
+ var n = curve.getN();
+ var e = BigInteger.fromByteArrayUnsigned(hash);
+ var badrs = 0
+ do {
+ var k = this.deterministicK(wif, hash, badrs);
+ var G = curve.getG();
+ var Q = G.multiply(k);
+ var r = Q.getX().toBigInteger().mod(n);
+ var s = k.modInverse(n).multiply(e.add(priv.multiply(r))).mod(n);
+ badrs++
+ } while (r.compareTo(BigInteger.ZERO) <= 0 || s.compareTo(BigInteger.ZERO) <= 0);
+
+ // Force lower s values per BIP62
+ var halfn = n.shiftRight(1);
+ if (s.compareTo(halfn) > 0) {
+ s = n.subtract(s);
+ };
+
+ var sig = serializeSig(r, s);
+ sig.push(parseInt(shType, 10));
+
+ return Crypto.util.bytesToHex(sig);
+ } else {
+ return false;
+ }
+ }
+
+ // https://tools.ietf.org/html/rfc6979#section-3.2
+ r.deterministicK = function(wif, hash, badrs) {
+ // if r or s were invalid when this function was used in signing,
+ // we do not want to actually compute r, s here for efficiency, so,
+ // we can increment badrs. explained at end of RFC 6979 section 3.2
+
+ // wif is b58check encoded wif privkey.
+ // hash is byte array of transaction digest.
+ // badrs is used only if the k resulted in bad r or s.
+
+ // some necessary things out of the way for clarity.
+ badrs = badrs || 0;
+ var key = coinjs.wif2privkey(wif);
+ var x = Crypto.util.hexToBytes(key['privkey'])
+ var curve = EllipticCurve.getSECCurveByName("secp256k1");
+ var N = curve.getN();
+
+ // Step: a
+ // hash is a byteArray of the message digest. so h1 == hash in our case
+
+ // Step: b
+ var v = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+
+ // Step: c
+ var k = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+ // Step: d
+ k = Crypto.HMAC(Crypto.SHA256, v.concat([0]).concat(x).concat(hash), k, {
+ asBytes: true
+ });
+
+ // Step: e
+ v = Crypto.HMAC(Crypto.SHA256, v, k, {
+ asBytes: true
+ });
+
+ // Step: f
+ k = Crypto.HMAC(Crypto.SHA256, v.concat([1]).concat(x).concat(hash), k, {
+ asBytes: true
+ });
+
+ // Step: g
+ v = Crypto.HMAC(Crypto.SHA256, v, k, {
+ asBytes: true
+ });
+
+ // Step: h1
+ var T = [];
+
+ // Step: h2 (since we know tlen = qlen, just copy v to T.)
+ v = Crypto.HMAC(Crypto.SHA256, v, k, {
+ asBytes: true
+ });
+ T = v;
+
+ // Step: h3
+ var KBigInt = BigInteger.fromByteArrayUnsigned(T);
+
+ // loop if KBigInt is not in the range of [1, N-1] or if badrs needs incrementing.
+ var i = 0
+ while (KBigInt.compareTo(N) >= 0 || KBigInt.compareTo(BigInteger.ZERO) <= 0 || i < badrs) {
+ k = Crypto.HMAC(Crypto.SHA256, v.concat([0]), k, {
+ asBytes: true
+ });
+ v = Crypto.HMAC(Crypto.SHA256, v, k, {
+ asBytes: true
+ });
+ v = Crypto.HMAC(Crypto.SHA256, v, k, {
+ asBytes: true
+ });
+ T = v;
+ KBigInt = BigInteger.fromByteArrayUnsigned(T);
+ i++
+ };
+
+ return KBigInt;
+ };
+
+ /* sign a "standard" input */
+ r.signinput = function(index, wif, sigHashType) {
+ var key = coinjs.wif2pubkey(wif);
+ var shType = sigHashType || 1;
+ var signature = this.transactionSig(index, wif, shType);
+ var s = coinjs.script();
+ s.writeBytes(Crypto.util.hexToBytes(signature));
+ s.writeBytes(Crypto.util.hexToBytes(key['pubkey']));
+ this.ins[index].script = s;
+ return true;
+ }
+
+ /* signs a time locked / hodl input */
+ r.signhodl = function(index, wif, sigHashType) {
+ var shType = sigHashType || 1;
+ var signature = this.transactionSig(index, wif, shType);
+ var redeemScript = this.ins[index].script.buffer
+ var s = coinjs.script();
+ s.writeBytes(Crypto.util.hexToBytes(signature));
+ s.writeBytes(redeemScript);
+ this.ins[index].script = s;
+ return true;
+ }
+
+ /* sign a multisig input */
+ r.signmultisig = function(index, wif, sigHashType) {
+
+ function scriptListPubkey(redeemScript) {
+ var r = {};
+ for (var i = 1; i < redeemScript.chunks.length - 2; i++) {
+ r[i] = Crypto.util.hexToBytes(coinjs.pubkeydecompress(Crypto.util.bytesToHex(redeemScript.chunks[i])));
+ }
+ return r;
+ }
+
+ function scriptListSigs(scriptSig) {
+ var r = {};
+ var c = 0;
+ if (scriptSig.chunks[0] == 0 && scriptSig.chunks[scriptSig.chunks.length - 1][scriptSig.chunks[scriptSig.chunks.length - 1].length - 1] == 174) {
+ for (var i = 1; i < scriptSig.chunks.length - 1; i++) {
+ if (scriptSig.chunks[i] != 0) {
+ c++;
+ r[c] = scriptSig.chunks[i];
+ }
+ }
+ }
+ return r;
+ }
+
+ var redeemScript = (this.ins[index].script.chunks[this.ins[index].script.chunks.length - 1] == 174) ? this.ins[index].script.buffer : this.ins[index].script.chunks[this.ins[index].script.chunks.length - 1];
+
+ var pubkeyList = scriptListPubkey(coinjs.script(redeemScript));
+ var sigsList = scriptListSigs(this.ins[index].script);
+
+ var shType = sigHashType || 1;
+ var sighash = Crypto.util.hexToBytes(this.transactionHash(index, shType));
+ var signature = Crypto.util.hexToBytes(this.transactionSig(index, wif, shType));
+
+ sigsList[coinjs.countObject(sigsList) + 1] = signature;
+
+ var s = coinjs.script();
+
+ s.writeOp(0);
+
+ for (x in pubkeyList) {
+ for (y in sigsList) {
+ this.ins[index].script.buffer = redeemScript;
+ sighash = Crypto.util.hexToBytes(this.transactionHash(index, sigsList[y].slice(-1)[0] * 1));
+ if (coinjs.verifySignature(sighash, sigsList[y], pubkeyList[x])) {
+ s.writeBytes(sigsList[y]);
+ }
+ }
+ }
+
+ s.writeBytes(redeemScript);
+ this.ins[index].script = s;
+ return true;
+ }
+
+ /* sign segwit input */
+ r.signsegwit = function(index, wif, sigHashType) {
+ var shType = sigHashType || 1;
+
+ var wif2 = coinjs.wif2pubkey(wif);
+ var segwit = coinjs.segwitAddress(wif2['pubkey']);
+ var bech32 = coinjs.bech32Address(wif2['pubkey']);
+
+ if ((segwit['redeemscript'] == Crypto.util.bytesToHex(this.ins[index].script.chunks[0])) || (bech32['redeemscript'] == Crypto.util.bytesToHex(this.ins[index].script.chunks[0]))) {
+ var txhash = this.transactionHashSegWitV0(index, shType);
+
+ if (txhash.result == 1) {
+
+ var segwitHash = Crypto.util.hexToBytes(txhash.hash);
+ var signature = this.transactionSig(index, wif, shType, segwitHash);
+
+ // remove any non standard data we store, i.e. input value
+ var script = coinjs.script();
+ script.writeBytes(this.ins[index].script.chunks[0]);
+ this.ins[index].script = script;
+
+ if (!coinjs.isArray(this.witness)) {
+ this.witness = new Array(this.ins.length);
+ this.witness.fill([]);
+ }
+
+ this.witness[index] = ([signature, wif2['pubkey']]);
+
+ // bech32, empty redeemscript
+ if (bech32['redeemscript'] == Crypto.util.bytesToHex(this.ins[index].script.chunks[0])) {
+ this.ins[index].script = coinjs.script();
+ }
+
+ /* attempt to reorder witness data as best as we can.
+ data can't be easily validated at this stage as
+ we dont have access to the inputs value and
+ making a web call will be too slow. */
+
+ /*
+ var witness_order = [];
+ var witness_used = [];
+ for (var i = 0; i < this.ins.length; i++) {
+ for (var y = 0; y < this.witness.length; y++) {
+ if (!witness_used.includes(y)) {
+ var sw = coinjs.segwitAddress(this.witness[y][1]);
+ var b32 = coinjs.bech32Address(this.witness[y][1]);
+ var rs = '';
+
+ if (this.ins[i].script.chunks.length >= 1) {
+ rs = Crypto.util.bytesToHex(this.ins[i].script.chunks[0]);
+ } else if (this.ins[i].script.chunks.length == 0) {
+ rs = b32['redeemscript'];
+ }
+
+ if ((sw['redeemscript'] == rs) || (b32['redeemscript'] == rs)) {
+ witness_order.push(this.witness[y]);
+ witness_used.push(y);
+
+ // bech32, empty redeemscript
+ if (b32['redeemscript'] == rs) {
+ this.ins[index].script = coinjs.script();
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ this.witness = witness_order;
+ */
+ }
+ }
+ return true;
+ }
+
+ /* sign inputs */
+ r.sign = function(wif, sigHashType) {
+ var shType = sigHashType || 1;
+ for (var i = 0; i < this.ins.length; i++) {
+ var d = this.extractScriptKey(i);
+
+ var w2a = coinjs.wif2address(wif);
+ var script = coinjs.script();
+ var pubkeyHash = script.pubkeyHash(w2a['address']);
+
+ if (((d['type'] == 'scriptpubkey' && d['script'] == Crypto.util.bytesToHex(pubkeyHash.buffer)) || d['type'] == 'empty') && d['signed'] == "false") {
+ this.signinput(i, wif, shType);
+
+ } else if (d['type'] == 'hodl' && d['signed'] == "false") {
+ this.signhodl(i, wif, shType);
+
+ } else if (d['type'] == 'multisig') {
+ this.signmultisig(i, wif, shType);
+
+ } else if (d['type'] == 'segwit') {
+ this.signsegwit(i, wif, shType);
+
+ } else {
+ // could not sign
+ }
+ }
+ return this.serialize();
+ }
+
+ /* serialize a transaction */
+ r.serialize = function() {
+ var buffer = [];
+ buffer = buffer.concat(coinjs.numToBytes(parseInt(this.version), 4));
+
+ if (coinjs.isArray(this.witness)) {
+ buffer = buffer.concat([0x00, 0x01]);
+ }
+
+ buffer = buffer.concat(coinjs.numToVarInt(this.ins.length));
+ for (var i = 0; i < this.ins.length; i++) {
+ var txin = this.ins[i];
+ buffer = buffer.concat(Crypto.util.hexToBytes(txin.outpoint.hash).reverse());
+ buffer = buffer.concat(coinjs.numToBytes(parseInt(txin.outpoint.index), 4));
+ var scriptBytes = txin.script.buffer;
+ buffer = buffer.concat(coinjs.numToVarInt(scriptBytes.length));
+ buffer = buffer.concat(scriptBytes);
+ buffer = buffer.concat(coinjs.numToBytes(parseInt(txin.sequence), 4));
+ }
+ buffer = buffer.concat(coinjs.numToVarInt(this.outs.length));
+
+ for (var i = 0; i < this.outs.length; i++) {
+ var txout = this.outs[i];
+ buffer = buffer.concat(coinjs.numToBytes(txout.value, 8));
+ var scriptBytes = txout.script.buffer;
+ buffer = buffer.concat(coinjs.numToVarInt(scriptBytes.length));
+ buffer = buffer.concat(scriptBytes);
+ }
+
+ if ((coinjs.isArray(this.witness)) && this.witness.length >= 1) {
+ for (var i = 0; i < this.witness.length; i++) {
+ buffer = buffer.concat(coinjs.numToVarInt(this.witness[i].length));
+ for (var x = 0; x < this.witness[i].length; x++) {
+ buffer = buffer.concat(coinjs.numToVarInt(Crypto.util.hexToBytes(this.witness[i][x]).length));
+ buffer = buffer.concat(Crypto.util.hexToBytes(this.witness[i][x]));
+ }
+ }
+ }
+
+ buffer = buffer.concat(coinjs.numToBytes(parseInt(this.lock_time), 4));
+ return Crypto.util.bytesToHex(buffer);
+ }
+
+ /* deserialize a transaction */
+ r.deserialize = function(buffer) {
+ if (typeof buffer == "string") {
+ buffer = Crypto.util.hexToBytes(buffer)
+ }
+
+ var pos = 0;
+ var witness = false;
+
+ var readAsInt = function(bytes) {
+ if (bytes == 0) return 0;
+ pos++;
+ return buffer[pos - 1] + readAsInt(bytes - 1) * 256;
+ }
+
+ var readVarInt = function() {
+ pos++;
+ if (buffer[pos - 1] < 253) {
+ return buffer[pos - 1];
+ }
+ return readAsInt(buffer[pos - 1] - 251);
+ }
+
+ var readBytes = function(bytes) {
+ pos += bytes;
+ return buffer.slice(pos - bytes, pos);
+ }
+
+ var readVarString = function() {
+ var size = readVarInt();
+ return readBytes(size);
+ }
+
+ var obj = new coinjs.transaction();
+ obj.version = readAsInt(4);
+
+ if (buffer[pos] == 0x00 && buffer[pos + 1] == 0x01) {
+ // segwit transaction
+ witness = true;
+ obj.witness = [];
+ pos += 2;
+ }
+
+ var ins = readVarInt();
+ for (var i = 0; i < ins; i++) {
+ obj.ins.push({
+ outpoint: {
+ hash: Crypto.util.bytesToHex(readBytes(32).reverse()),
+ index: readAsInt(4)
+ },
+ script: coinjs.script(readVarString()),
+ sequence: readAsInt(4)
+ });
+ }
+
+ var outs = readVarInt();
+ for (var i = 0; i < outs; i++) {
+ obj.outs.push({
+ value: coinjs.bytesToNum(readBytes(8)),
+ script: coinjs.script(readVarString())
+ });
+ }
+
+ if (witness == true) {
+ for (i = 0; i < ins; ++i) {
+ var count = readVarInt();
+ var vector = [];
+ if (!coinjs.isArray(obj.witness[i])) {
+ obj.witness[i] = [];
+ }
+ for (var y = 0; y < count; y++) {
+ var slice = readVarInt();
+ pos += slice;
+ obj.witness[i].push(Crypto.util.bytesToHex(buffer.slice(pos - slice, pos)));
+ }
+ }
+ }
+
+ obj.lock_time = readAsInt(4);
+ return obj;
+ }
+
+ r.size = function() {
+ return ((this.serialize()).length / 2).toFixed(0);
+ }
+
+ return r;
+ }
+
+ /* start of signature vertification functions */
+
+ coinjs.verifySignature = function(hash, sig, pubkey) {
+
+ function parseSig(sig) {
+ var cursor;
+ if (sig[0] != 0x30)
+ throw new Error("Signature not a valid DERSequence");
+
+ cursor = 2;
+ if (sig[cursor] != 0x02)
+ throw new Error("First element in signature must be a DERInteger");;
+
+ var rBa = sig.slice(cursor + 2, cursor + 2 + sig[cursor + 1]);
+
+ cursor += 2 + sig[cursor + 1];
+ if (sig[cursor] != 0x02)
+ throw new Error("Second element in signature must be a DERInteger");
+
+ var sBa = sig.slice(cursor + 2, cursor + 2 + sig[cursor + 1]);
+
+ cursor += 2 + sig[cursor + 1];
+
+ var r = BigInteger.fromByteArrayUnsigned(rBa);
+ var s = BigInteger.fromByteArrayUnsigned(sBa);
+
+ return {
+ r: r,
+ s: s
+ };
+ }
+
+ var r, s;
+
+ if (coinjs.isArray(sig)) {
+ var obj = parseSig(sig);
+ r = obj.r;
+ s = obj.s;
+ } else if ("object" === typeof sig && sig.r && sig.s) {
+ r = sig.r;
+ s = sig.s;
+ } else {
+ throw "Invalid value for signature";
+ }
+
+ var Q;
+ if (coinjs.isArray(pubkey)) {
+ var ecparams = EllipticCurve.getSECCurveByName("secp256k1");
+ Q = EllipticCurve.PointFp.decodeFrom(ecparams.getCurve(), pubkey);
+ } else {
+ throw "Invalid format for pubkey value, must be byte array";
+ }
+ var e = BigInteger.fromByteArrayUnsigned(hash);
+
+ return coinjs.verifySignatureRaw(e, r, s, Q);
+ }
+
+ coinjs.verifySignatureRaw = function(e, r, s, Q) {
+ var ecparams = EllipticCurve.getSECCurveByName("secp256k1");
+ var n = ecparams.getN();
+ var G = ecparams.getG();
+
+ if (r.compareTo(BigInteger.ONE) < 0 || r.compareTo(n) >= 0)
+ return false;
+
+ if (s.compareTo(BigInteger.ONE) < 0 || s.compareTo(n) >= 0)
+ return false;
+
+ var c = s.modInverse(n);
+
+ var u1 = e.multiply(c).mod(n);
+ var u2 = r.multiply(c).mod(n);
+
+ var point = G.multiply(u1).add(Q.multiply(u2));
+
+ var v = point.getX().toBigInteger().mod(n);
+
+ return v.equals(r);
+ }
+
+ /* start of privates functions */
+
+ /* base58 encode function */
+ coinjs.base58encode = function(buffer) {
+ var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+ var base = BigInteger.valueOf(58);
+
+ var bi = BigInteger.fromByteArrayUnsigned(buffer);
+ var chars = [];
+
+ while (bi.compareTo(base) >= 0) {
+ var mod = bi.mod(base);
+ chars.unshift(alphabet[mod.intValue()]);
+ bi = bi.subtract(mod).divide(base);
+ }
+
+ chars.unshift(alphabet[bi.intValue()]);
+ for (var i = 0; i < buffer.length; i++) {
+ if (buffer[i] == 0x00) {
+ chars.unshift(alphabet[0]);
+ } else break;
+ }
+ return chars.join('');
+ }
+
+ /* base58 decode function */
+ coinjs.base58decode = function(buffer) {
+ var alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+ var base = BigInteger.valueOf(58);
+ var validRegex = /^[1-9A-HJ-NP-Za-km-z]+$/;
+
+ var bi = BigInteger.valueOf(0);
+ var leadingZerosNum = 0;
+ for (var i = buffer.length - 1; i >= 0; i--) {
+ var alphaIndex = alphabet.indexOf(buffer[i]);
+ if (alphaIndex < 0) {
+ throw "Invalid character";
+ }
+ bi = bi.add(BigInteger.valueOf(alphaIndex).multiply(base.pow(buffer.length - 1 - i)));
+
+ if (buffer[i] == "1") leadingZerosNum++;
+ else leadingZerosNum = 0;
+ }
+
+ var bytes = bi.toByteArrayUnsigned();
+ while (leadingZerosNum-- > 0) bytes.unshift(0);
+ return bytes;
+ }
+
+ /* raw ajax function to avoid needing bigger frame works like jquery, mootools etc */
+ coinjs.ajax = function(u, f, m, a) {
+ var x = false;
+ try {
+ x = new ActiveXObject('Msxml2.XMLHTTP')
+ } catch (e) {
+ try {
+ x = new ActiveXObject('Microsoft.XMLHTTP')
+ } catch (e) {
+ x = new XMLHttpRequest()
+ }
+ }
+
+ if (x == false) {
+ return false;
+ }
+
+ x.open(m, u, true);
+ x.onreadystatechange = function() {
+ if ((x.readyState == 4) && f)
+ f(x.responseText);
+ };
+
+ if (m == 'POST') {
+ x.setRequestHeader('Content-type', 'application/x-www-form-urlencoded');
+ }
+
+ x.send(a);
+ }
+
+ /* clone an object */
+ coinjs.clone = function(obj) {
+ if (obj == null || typeof(obj) != 'object') return obj;
+ var temp = new obj.constructor();
+
+ for (var key in obj) {
+ if (obj.hasOwnProperty(key)) {
+ temp[key] = coinjs.clone(obj[key]);
+ }
+ }
+ return temp;
+ }
+
+ coinjs.numToBytes = function(num, bytes) {
+ if (typeof bytes === "undefined") bytes = 8;
+ if (bytes == 0) {
+ return [];
+ } else if (num == -1) {
+ return Crypto.util.hexToBytes("ffffffffffffffff");
+ } else {
+ return [num % 256].concat(coinjs.numToBytes(Math.floor(num / 256), bytes - 1));
+ }
+ }
+
+ function scriptNumSize(i) {
+ return i > 0x7fffffff ? 5 :
+ i > 0x7fffff ? 4 :
+ i > 0x7fff ? 3 :
+ i > 0x7f ? 2 :
+ i > 0x00 ? 1 :
+ 0;
+ }
+
+ coinjs.numToScriptNumBytes = function(_number) {
+ var value = Math.abs(_number);
+ var size = scriptNumSize(value);
+ var result = [];
+ for (var i = 0; i < size; ++i) {
+ result.push(0);
+ }
+ var negative = _number < 0;
+ for (i = 0; i < size; ++i) {
+ result[i] = value & 0xff;
+ value = Math.floor(value / 256);
+ }
+ if (negative) {
+ result[size - 1] |= 0x80;
+ }
+ return result;
+ }
+
+ coinjs.numToVarInt = function(num) {
+ if (num < 253) {
+ return [num];
+ } else if (num < 65536) {
+ return [253].concat(coinjs.numToBytes(num, 2));
+ } else if (num < 4294967296) {
+ return [254].concat(coinjs.numToBytes(num, 4));
+ } else {
+ return [255].concat(coinjs.numToBytes(num, 8));
+ }
+ }
+
+ coinjs.bytesToNum = function(bytes) {
+ if (bytes.length == 0) return 0;
+ else return bytes[0] + 256 * coinjs.bytesToNum(bytes.slice(1));
+ }
+
+ coinjs.uint = function(f, size) {
+ if (f.length < size)
+ throw new Error("not enough data");
+ var n = 0;
+ for (var i = 0; i < size; i++) {
+ n *= 256;
+ n += f[i];
+ }
+ return n;
+ }
+
+ coinjs.isArray = function(o) {
+ return Object.prototype.toString.call(o) === '[object Array]';
+ }
+
+ coinjs.countObject = function(obj) {
+ var count = 0;
+ var i;
+ for (i in obj) {
+ if (obj.hasOwnProperty(i)) {
+ count++;
+ }
+ }
+ return count;
+ }
+
+ coinjs.random = function(length) {
+ var r = "";
+ var l = length || 25;
+ var chars = "!$%^&*()_+{}:@~?><|\./;'#][=-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
+ for (let x = 0; x < l; x++) {
+ r += chars.charAt(Math.floor(Math.random() * 62));
+ }
+ return r;
+ }
+
+ })();
+
//secrets.js
(function() {
//Shamir Secret Share by Alexander Stetsyuk - released under MIT License
@@ -6783,5 +9342,4 @@
}
})();
-
})(typeof global !== "undefined" ? global : window);
\ No newline at end of file
diff --git a/scripts/std_ui.js b/scripts/std_ui.js
index 1024524..64b1608 100644
--- a/scripts/std_ui.js
+++ b/scripts/std_ui.js
@@ -109,7 +109,7 @@ document.addEventListener('popupopened', async e => {
if (hasSavedIds) {
const clone = frag.cloneNode(true)
getRef('select_withdraw_upi_id').append(clone)
- getRef('select_withdraw_upi_id').parentNode.classList.remove('hide')
+ getRef('select_withdraw_upi_id').parentNode.classList.remove('hidden')
}
break;
case 'send_btc_popup':
@@ -128,7 +128,7 @@ document.addEventListener('popupclosed', e => {
showChildElement('topup_wallet_process', 0)
break;
case 'withdraw_wallet_popup':
- getRef('select_withdraw_upi_id').parentNode.classList.add('hide')
+ getRef('select_withdraw_upi_id').parentNode.classList.add('hidden')
getRef('select_withdraw_upi_id').innerHTML = ''
showChildElement('withdraw_wallet_process', 0)
break;
@@ -292,7 +292,7 @@ window.addEventListener("load", () => {
} else {
notify('Browser is not fully compatible, some features may not work. for best experience please use Chrome, Edge, Firefox or Safari', 'error')
}
- document.body.classList.remove('hide')
+ document.body.classList.remove('hidden')
document.querySelectorAll('sm-input[data-flo-id]').forEach(input => input.customValidation = floCrypto.validateAddr)
document.addEventListener('keyup', (e) => {
if (e.key === 'Escape') {
@@ -356,10 +356,11 @@ async function showPage(targetPage, options = {}) {
let params = {}
let searchParams
if (targetPage === '') {
- if (typeof myFloID === "undefined") {
+ try {
+ if(floDapps.user.id)
+ pageId = 'home'
+ }catch(e){
pageId = 'sign_in'
- } else {
- pageId = 'home'
}
} else {
if (targetPage.includes('/')) {
@@ -378,10 +379,13 @@ async function showPage(targetPage, options = {}) {
pageId = targetPage
}
}
- if (typeof myFloID === "undefined" && !(['sign_up', 'sign_in', 'loading', 'landing'].includes(pageId))) return
- else if (typeof myFloID !== "undefined" && (['sign_up', 'sign_in', 'loading', 'landing'].includes(pageId))) {
- history.replaceState(null, null, '#/home');
- pageId = 'home'
+ try {
+ if (floDapps.user.id && (['sign_up', 'sign_in', 'loading', 'landing'].includes(pageId))) {
+ history.replaceState(null, null, '#/home');
+ pageId = 'home'
+ }
+ }catch(e){
+ if ( !(['sign_up', 'sign_in', 'loading', 'landing'].includes(pageId))) return
}
if (searchParams) {
const urlSearchParams = new URLSearchParams('?' + searchParams);
@@ -400,7 +404,6 @@ async function showPage(targetPage, options = {}) {
break;
case 'home':
getExchangeRate().then(rate => {
- console.log(rate)
getRef('conversion_rate').textContent = `1BTC = ${formatAmount(rate.inr)}`;
})
break;
@@ -408,8 +411,8 @@ async function showPage(targetPage, options = {}) {
getRef('contact__title').textContent = getFloIdTitle(params.floId)
getRef('contact__transactions').innerHTML = '
Describe reason