Update index.html

-- UI/UX improvements

FLO_horizontal_text.svg

@@ -1,146 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Generator: Adobe Illustrator 15.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   version="1.1"
-   id="Layer_1"
-   x="0px"
-   y="0px"
-   width="469.89999"
-   height="212.84599"
-   viewBox="0 0 469.89999 212.84599"
-   enable-background="new 0 0 512 512"
-   xml:space="preserve"
-   sodipodi:docname="FLO_horizontal_text.svg"
-   inkscape:version="0.92.4 (unknown)"><metadata
-     id="metadata4665"><rdf:RDF><cc:Work
-         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
-     id="defs4663" /><sodipodi:namedview
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="1366"
-     inkscape:window-height="732"
-     id="namedview4661"
-     showgrid="false"
-     inkscape:zoom="1.3027344"
-     inkscape:cx="219.90846"
-     inkscape:cy="85.00108"
-     inkscape:window-x="0"
-     inkscape:window-y="0"
-     inkscape:window-maximized="1"
-     inkscape:current-layer="Layer_1"
-     fit-margin-top="-0.1"
-     fit-margin-left="0"
-     fit-margin-right="0"
-     fit-margin-bottom="0" /><linearGradient
-     id="SVGID_1_"
-     gradientUnits="userSpaceOnUse"
-     x1="337.43359"
-     y1="263.58591"
-     x2="394.418"
-     y2="263.58591"><stop
-       offset="0"
-       style="stop-color:#2583A6"
-       id="stop4615" /><stop
-       offset="0.5"
-       style="stop-color:#257EA3"
-       id="stop4617" /><stop
-       offset="1"
-       style="stop-color:#237AA0"
-       id="stop4619" /></linearGradient><polygon
-     points="394.418,304.29 337.434,304.29 337.434,222.882 351.623,222.882 351.623,291.387 394.418,291.387 "
-     id="polygon4622"
-     style="fill:url(#SVGID_1_)"
-     transform="translate(-21.05,-128.155)" /><linearGradient
-     id="SVGID_2_"
-     gradientUnits="userSpaceOnUse"
-     x1="405.81641"
-     y1="263.58591"
-     x2="490.94919"
-     y2="263.58591"
-     gradientTransform="translate(-21.05,-128.155)"><stop
-       offset="0"
-       style="stop-color:#2583A6"
-       id="stop4624" /><stop
-       offset="0.5"
-       style="stop-color:#257EA3"
-       id="stop4626" /><stop
-       offset="1"
-       style="stop-color:#237AA0"
-       id="stop4628" /></linearGradient><path
-     d="m 427.217,177.532 c -6.278,0 -12.015,-1.107 -17.215,-3.312 -5.189,-2.209 -9.647,-5.215 -13.372,-9.017 -3.723,-3.797 -6.629,-8.232 -8.72,-13.318 -2.098,-5.078 -3.144,-10.482 -3.144,-16.224 v -0.232 c 0,-5.744 1.046,-11.143 3.144,-16.226 2.091,-5.083 5.036,-9.53 8.834,-13.373 3.802,-3.836 8.299,-6.884 13.497,-9.134 5.192,-2.238 10.929,-3.367 17.211,-3.367 6.276,0 12.017,1.106 17.209,3.312 5.197,2.211 9.653,5.217 13.374,9.018 3.724,3.799 6.632,8.233 8.724,13.311 2.094,5.081 3.141,10.489 3.141,16.228 v 0.233 c 0,5.733 -1.047,11.143 -3.141,16.218 -2.093,5.082 -5.038,9.544 -8.838,13.382 -3.8,3.842 -8.295,6.882 -13.49,9.12 -5.195,2.255 -10.932,3.381 -17.214,3.381 m 0.235,-13.142 c 4.013,0 7.694,-0.757 11.065,-2.272 3.354,-1.506 6.222,-3.564 8.627,-6.162 2.383,-2.595 4.269,-5.641 5.603,-9.126 1.356,-3.491 2.036,-7.213 2.036,-11.168 v -0.232 c 0,-3.952 -0.68,-7.692 -2.036,-11.222 -1.333,-3.529 -3.237,-6.593 -5.663,-9.19 -2.44,-2.591 -5.352,-4.673 -8.743,-6.224 -3.406,-1.55 -7.107,-2.323 -11.124,-2.323 -4.013,0 -7.691,0.752 -11.063,2.269 -3.356,1.509 -6.226,3.563 -8.627,6.159 -2.388,2.601 -4.268,5.649 -5.602,9.141 -1.355,3.486 -2.036,7.206 -2.036,11.16 v 0.233 c 0,3.956 0.679,7.69 2.036,11.222 1.334,3.527 3.232,6.594 5.658,9.188 2.444,2.598 5.352,4.672 8.743,6.218 3.411,1.553 7.109,2.329 11.126,2.329 z"
-     id="path4631"
-     inkscape:connector-curvature="0"
-     style="fill:url(#SVGID_2_)" /><linearGradient
-     id="SVGID_3_"
-     gradientUnits="userSpaceOnUse"
-     x1="261.1416"
-     y1="281.26169"
-     x2="316.3848"
-     y2="281.26169"><stop
-       offset="0"
-       style="stop-color:#2583A6"
-       id="stop4633" /><stop
-       offset="0.5"
-       style="stop-color:#257EA3"
-       id="stop4635" /><stop
-       offset="1"
-       style="stop-color:#237AA0"
-       id="stop4637" /></linearGradient><polygon
-     points="261.142,258.232 261.142,304.29 275.331,304.29 275.331,271.142 316.385,271.142 316.385,258.232 275.331,258.232 "
-     id="polygon4640"
-     style="fill:url(#SVGID_3_)"
-     transform="translate(-21.05,-128.155)" /><linearGradient
-     id="SVGID_4_"
-     gradientUnits="userSpaceOnUse"
-     x1="291.3779"
-     y1="235.7881"
-     x2="291.3779"
-     y2="222.88181"><stop
-       offset="0"
-       style="stop-color:#2583A6"
-       id="stop4642" /><stop
-       offset="0.5"
-       style="stop-color:#257EA3"
-       id="stop4644" /><stop
-       offset="1"
-       style="stop-color:#237AA0"
-       id="stop4646" /></linearGradient><polygon
-     points="261.142,222.882 261.142,235.788 275.331,235.788 321.614,235.788 321.614,222.882 "
-     id="polygon4649"
-     style="fill:url(#SVGID_4_)"
-     transform="translate(-21.05,-128.155)" /><linearGradient
-     id="SVGID_5_"
-     gradientUnits="userSpaceOnUse"
-     x1="125.481"
-     y1="341.00101"
-     x2="125.4809"
-     y2="128.05569"
-     gradientTransform="translate(-21.05,-128.155)"><stop
-       offset="0"
-       style="stop-color:#2583A6"
-       id="stop4651" /><stop
-       offset="0.5"
-       style="stop-color:#257EA3"
-       id="stop4653" /><stop
-       offset="1"
-       style="stop-color:#237AA0"
-       id="stop4655" /></linearGradient><path
-     d="m 104.43,151.572 c -12.005,15.862 -12.005,31.461 0,46.797 12.01,-15.336 12.009,-30.935 0,-46.797 m 0,-129.492 c -27.559,34.767 -27.559,70.133 0,106.11 27.566,-35.977 27.564,-71.344 0,-106.11 z M 42.006,177.043 C 52.166,153.951 73.451,142.555 97.22,142.842 67.063,111.547 40.869,98.934 18.64,105.024 21.594,122.279 33.596,136.941 54.639,149.021 30.427,141.376 12.211,122.884 0,93.543 36.328,87.372 64.932,96.328 85.813,120.389 66.772,79.675 72.972,39.513 104.428,-0.1 c 31.459,39.613 37.663,79.774 18.622,120.489 20.883,-24.062 49.485,-33.018 85.812,-26.846 -12.211,29.341 -30.423,47.834 -54.637,55.478 21.044,-12.08 33.042,-26.742 35.999,-43.997 -22.23,-6.089 -48.425,6.524 -78.581,37.818 23.77,-0.287 45.053,11.11 55.215,34.201 -17.962,4.017 -32.733,1.268 -44.307,-8.254 12.642,6.396 23.558,7.348 32.737,2.861 -4.021,-12.157 -21.792,-20.554 -44.521,-25.198 12.966,22.459 10.855,44.594 -6.338,66.394 -17.188,-21.8 -19.298,-43.935 -6.334,-66.394 -22.727,4.645 -40.5,13.041 -44.519,25.198 9.179,4.485 20.091,3.535 32.737,-2.861 -11.575,9.522 -26.345,12.271 -44.307,8.254 z"
-     id="path4658"
-     inkscape:connector-curvature="0"
-     style="fill:url(#SVGID_5_)" /></svg>

FLO_horizontal_text1.svg

@@ -1,37 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="59pt" height="27pt" viewBox="0 0 59 27" version="1.1">
-<defs>
-<linearGradient id="linear0" gradientUnits="userSpaceOnUse" x1="337.43359" y1="263.58591" x2="394.418" y2="263.58591" gradientTransform="matrix(0.125532,0,0,0.126761,-2.642447,-16.245)">
-<stop offset="0" style="stop-color:rgb(14.509804%,51.372549%,65.098039%);stop-opacity:1;"/>
-<stop offset="0.5" style="stop-color:rgb(14.509804%,49.411765%,63.921569%);stop-opacity:1;"/>
-<stop offset="1" style="stop-color:rgb(13.72549%,47.843137%,62.745098%);stop-opacity:1;"/>
-</linearGradient>
-<linearGradient id="linear1" gradientUnits="userSpaceOnUse" x1="405.81641" y1="263.58591" x2="490.94919" y2="263.58591" gradientTransform="matrix(0.125532,0,0,0.126761,-2.642447,-16.245)">
-<stop offset="0" style="stop-color:rgb(14.509804%,51.372549%,65.098039%);stop-opacity:1;"/>
-<stop offset="0.5" style="stop-color:rgb(14.509804%,49.411765%,63.921569%);stop-opacity:1;"/>
-<stop offset="1" style="stop-color:rgb(13.72549%,47.843137%,62.745098%);stop-opacity:1;"/>
-</linearGradient>
-<linearGradient id="linear2" gradientUnits="userSpaceOnUse" x1="261.1416" y1="281.26169" x2="316.3848" y2="281.26169" gradientTransform="matrix(0.125532,0,0,0.126761,-2.642447,-16.245)">
-<stop offset="0" style="stop-color:rgb(14.509804%,51.372549%,65.098039%);stop-opacity:1;"/>
-<stop offset="0.5" style="stop-color:rgb(14.509804%,49.411765%,63.921569%);stop-opacity:1;"/>
-<stop offset="1" style="stop-color:rgb(13.72549%,47.843137%,62.745098%);stop-opacity:1;"/>
-</linearGradient>
-<linearGradient id="linear3" gradientUnits="userSpaceOnUse" x1="291.3779" y1="235.7881" x2="291.3779" y2="222.88181" gradientTransform="matrix(0.125532,0,0,0.126761,-2.642447,-16.245)">
-<stop offset="0" style="stop-color:rgb(14.509804%,51.372549%,65.098039%);stop-opacity:1;"/>
-<stop offset="0.5" style="stop-color:rgb(14.509804%,49.411765%,63.921569%);stop-opacity:1;"/>
-<stop offset="1" style="stop-color:rgb(13.72549%,47.843137%,62.745098%);stop-opacity:1;"/>
-</linearGradient>
-<linearGradient id="linear4" gradientUnits="userSpaceOnUse" x1="125.481" y1="341.00101" x2="125.4809" y2="128.05569" gradientTransform="matrix(0.125532,0,0,0.126761,-2.642447,-16.245)">
-<stop offset="0" style="stop-color:rgb(14.509804%,51.372549%,65.098039%);stop-opacity:1;"/>
-<stop offset="0.5" style="stop-color:rgb(14.509804%,49.411765%,63.921569%);stop-opacity:1;"/>
-<stop offset="1" style="stop-color:rgb(13.72549%,47.843137%,62.745098%);stop-opacity:1;"/>
-</linearGradient>
-</defs>
-<g id="surface1">
-<path style=" stroke:none;fill-rule:nonzero;fill:url(#linear0);" d="M 46.871094 22.328125 L 39.714844 22.328125 L 39.714844 12.007812 L 41.496094 12.007812 L 41.496094 20.691406 L 46.871094 20.691406 Z M 46.871094 22.328125 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:url(#linear1);" d="M 53.628906 22.503906 C 52.839844 22.503906 52.121094 22.363281 51.46875 22.085938 C 50.816406 21.804688 50.257812 21.421875 49.789062 20.941406 C 49.324219 20.460938 48.957031 19.898438 48.695312 19.253906 C 48.433594 18.609375 48.300781 17.925781 48.300781 17.195312 L 48.300781 17.167969 C 48.300781 16.4375 48.433594 15.753906 48.695312 15.109375 C 48.957031 14.464844 49.328125 13.902344 49.804688 13.414062 C 50.28125 12.929688 50.847656 12.542969 51.5 12.257812 C 52.148438 11.972656 52.871094 11.832031 53.660156 11.832031 C 54.445312 11.832031 55.167969 11.96875 55.820312 12.25 C 56.472656 12.53125 57.03125 12.910156 57.496094 13.394531 C 57.964844 13.875 58.332031 14.4375 58.59375 15.082031 C 58.855469 15.726562 58.988281 16.410156 58.988281 17.136719 L 58.988281 17.167969 C 58.988281 17.894531 58.855469 18.578125 58.59375 19.222656 C 58.332031 19.867188 57.960938 20.433594 57.484375 20.917969 C 57.007812 21.40625 56.441406 21.792969 55.789062 22.074219 C 55.136719 22.359375 54.417969 22.503906 53.628906 22.503906 M 53.660156 20.839844 C 54.164062 20.839844 54.625 20.742188 55.046875 20.550781 C 55.46875 20.359375 55.828125 20.097656 56.128906 19.769531 C 56.429688 19.441406 56.667969 19.054688 56.835938 18.613281 C 57.003906 18.167969 57.089844 17.699219 57.089844 17.195312 L 57.089844 17.167969 C 57.089844 16.667969 57.003906 16.191406 56.835938 15.746094 C 56.667969 15.296875 56.429688 14.910156 56.125 14.578125 C 55.816406 14.25 55.453125 13.988281 55.027344 13.789062 C 54.597656 13.59375 54.132812 13.496094 53.628906 13.496094 C 53.125 13.496094 52.664062 13.589844 52.242188 13.785156 C 51.820312 13.976562 51.460938 14.234375 51.15625 14.566406 C 50.859375 14.894531 50.621094 15.28125 50.453125 15.722656 C 50.285156 16.164062 50.199219 16.636719 50.199219 17.136719 L 50.199219 17.167969 C 50.199219 17.667969 50.285156 18.140625 50.453125 18.589844 C 50.621094 19.039062 50.859375 19.425781 51.164062 19.753906 C 51.472656 20.085938 51.835938 20.347656 52.261719 20.542969 C 52.691406 20.738281 53.15625 20.839844 53.660156 20.839844 Z M 53.660156 20.839844 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:url(#linear2);" d="M 30.140625 16.488281 L 30.140625 22.328125 L 31.921875 22.328125 L 31.921875 18.125 L 37.074219 18.125 L 37.074219 16.488281 Z M 30.140625 16.488281 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:url(#linear3);" d="M 30.140625 12.007812 L 30.140625 13.644531 L 37.730469 13.644531 L 37.730469 12.007812 Z M 30.140625 12.007812 "/>
-<path style=" stroke:none;fill-rule:nonzero;fill:url(#linear4);" d="M 13.109375 19.214844 C 11.601562 21.222656 11.601562 23.203125 13.109375 25.144531 C 14.617188 23.203125 14.617188 21.222656 13.109375 19.214844 M 13.109375 2.800781 C 9.648438 7.207031 9.648438 11.6875 13.109375 16.25 C 16.570312 11.6875 16.570312 7.207031 13.109375 2.800781 Z M 5.273438 22.441406 C 6.546875 19.515625 9.21875 18.070312 12.203125 18.105469 C 8.417969 14.140625 5.128906 12.539062 2.339844 13.3125 C 2.710938 15.5 4.21875 17.359375 6.859375 18.890625 C 3.820312 17.921875 1.53125 15.578125 0 11.859375 C 4.558594 11.074219 8.152344 12.210938 10.773438 15.261719 C 8.382812 10.101562 9.160156 5.007812 13.109375 -0.0117188 C 17.058594 5.007812 17.835938 10.097656 15.445312 15.261719 C 18.066406 12.210938 21.660156 11.074219 26.21875 11.859375 C 24.6875 15.578125 22.398438 17.921875 19.359375 18.890625 C 22 17.359375 23.507812 15.5 23.878906 13.3125 C 21.089844 12.542969 17.800781 14.140625 14.015625 18.105469 C 17 18.070312 19.671875 19.515625 20.945312 22.441406 C 18.691406 22.953125 16.835938 22.601562 15.382812 21.394531 C 16.972656 22.207031 18.339844 22.328125 19.492188 21.757812 C 18.988281 20.21875 16.757812 19.152344 13.90625 18.5625 C 15.53125 21.410156 15.265625 24.21875 13.109375 26.980469 C 10.953125 24.21875 10.6875 21.410156 12.3125 18.5625 C 9.460938 19.152344 7.230469 20.21875 6.726562 21.757812 C 7.878906 22.328125 9.246094 22.207031 10.835938 21.394531 C 9.382812 22.601562 7.527344 22.953125 5.273438 22.441406 Z M 5.273438 22.441406 "/>
-</g>
-</svg>

README.md

@@ -1,2 +1,42 @@
-# flo scout
+# FLO Scout 
+
+FLO Scout is RanchiMall's token and smart contract explorer.
+All tokens, smart contracts, and their transactions (created on FLO blockchain) can be accessed on FLO Scout.  
+
+### Live URL for FLO Scout:
+*https://ranchimall.github.io/floscout/*
+
+## How to use
+#### Search by address
+i) On the homepage of FLO Scout, enter the FLO address/FLO ID and press Enter  
+ii) On the top it shows the FLO balance and the tokens and their respective balances of the FLO ID  
+iii) Next it shows the token transfers, amount of token transferred, or smart contract transactions of the FLO address  
+
+#### Search by transaction
+i) Enter the transaction ID of a FLO blockchain token transfer in the search box  
+ii) This will give the token transfer detail of that transaction, including sender and receiver address, FLO data, amount of token transfer, and timestamp of the transaction  
+
+#### Search by token name
+i) Enter the token name in the search box  
+ii) This will give the incorporation address of the token (an incorporation address is the creator address of the token), the total supply of the token, all token transactions, and the details of token holders  
+
+#### Search by smart contract
+i) Enter the smart contract name in the search box  
+ii) This will give the following details of the smart contract:  
+       a) Smart contract type (continuous, or one-time event)  
+       b) Smart contract subtype (tokenswap)  
+       c) Contract address (the FLO address that created the smart contract)  
+       d) Other statistics (no. of deposits, no. of participants, oracle address, total output, and total balance)  
+       e) Both off-chain and on-chain data  
+       f) Off-chain data is sub-transactions inside the smart contract  
+
+#### Search by block
+i) Enter the block number in the search box  
+ii) This will give the following details of the block:  
+       a) Relevant Transactions (no. of transactions inside the block)  
+       b) No. of confirmations  
+       c) Reward  
+       d) Block Hash  
+       e) Difficulty  
+       f) Transactions (token transfer details)
  

floscout.svg

@@ -0,0 +1,11 @@
+<svg width="128" height="128" viewBox="0 0 128 128" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_3_34)">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M50.5679 101.136C78.4958 101.136 101.136 78.4958 101.136 50.5679C101.136 47.0696 100.781 43.6543 100.104 40.3561C104.75 47.3575 107.457 55.7578 107.457 64.7901C107.457 89.227 87.6468 109.037 63.2099 109.037C52.318 109.037 42.3453 105.102 34.6362 98.575C39.6451 100.236 45.0015 101.136 50.5679 101.136ZM34.6362 98.575C14.5144 91.9008 0 72.9293 0 50.5679C0 22.64 22.64 0 50.5679 0C74.9975 0 95.381 17.3234 100.104 40.3561C92.1803 28.4153 78.6144 20.5432 63.2099 20.5432C38.773 20.5432 18.963 40.3532 18.963 64.7901C18.963 78.3351 25.0492 90.4586 34.6362 98.575Z" fill="#4F56FF"/>
+<circle cx="113.333" cy="113.333" r="14.6667" fill="#4F56FF"/>
+</g>
+<defs>
+<clipPath id="clip0_3_34">
+<rect width="128" height="128" fill="white"/>
+</clipPath>
+</defs>
+</svg>

scripts/flexsearch.light.js

@@ -0,0 +1,44 @@
+/**!
+ * FlexSearch.js v0.7.31 (Light)
+ * Copyright 2018-2022 Nextapps GmbH
+ * Author: Thomas Wilkerling
+ * Licence: Apache-2.0
+ * https://github.com/nextapps-de/flexsearch
+ */
+(function (self) {
+    'use strict'; function t(a) { return "undefined" !== typeof a ? a : !0 } function v(a) { const c = Array(a); for (let b = 0; b < a; b++)c[b] = y(); return c } function y() { return Object.create(null) } function z(a, c) { return c.length - a.length }; const A = /[\p{Z}\p{S}\p{P}\p{C}]+/u; function B(a, c) { const b = Object.keys(a), d = b.length, e = []; let h = "", f = 0; for (let g = 0, l, n; g < d; g++)l = b[g], (n = a[l]) ? (e[f++] = new RegExp(c ? "(?!\\b)" + l + "(\\b|_)" : l, "g"), e[f++] = n) : h += (h ? "|" : "") + l; h && (e[f++] = new RegExp(c ? "(?!\\b)(" + h + ")(\\b|_)" : "(" + h + ")", "g"), e[f] = ""); return e } function C(a, c) { for (let b = 0, d = c.length; b < d && (a = a.replace(c[b], c[b + 1]), a); b += 2); return a }; function D(a) { if (a = ("" + a).toLowerCase()) if (this.o && (a = C(a, this.o)), this.A && 1 < a.length && (a = C(a, this.A)), A || "" === A) if (a = a.split(A), this.filter) { var c = this.filter; const b = a.length, d = []; for (let e = 0, h = 0; e < b; e++) { const f = a[e]; f && !c[f] && (d[h++] = f) } a = d } return a }; const F = {}, G = {}; function H(a, c, b, d) {
+        const e = a.length; let h = [], f, g, l = 0; d && (d = []); for (let n = e - 1; 0 <= n; n--) { const m = a[n], r = m.length, p = y(); let q = !f; for (let k = 0; k < r; k++) { const u = m[k], M = u.length; if (M) for (let E = 0, x, w; E < M; E++)if (w = u[E], f) { if (f[w]) { if (!n) if (b) b--; else if (h[l++] = w, l === c) return h; if (n || d) p[w] = 1; q = !0 } if (d && (x = (g[w] || 0) + 1, g[w] = x, x < e)) { const N = d[x - 2] || (d[x - 2] = []); N[N.length] = w } } else p[w] = 1 } if (d) f || (g = p); else if (!q) return []; f = p } if (d) for (let n = d.length - 1, m, r; 0 <= n; n--) {
+            m = d[n]; r = m.length; for (let p = 0, q; p < r; p++)if (q =
+                m[p], !f[q]) { if (b) b--; else if (h[l++] = q, l === c) return h; f[q] = 1 }
+        } return h
+    }; function I(a, c) {
+        if (!(this instanceof I)) return new I(a); let b; if (a) { var d = a.charset; b = a.lang; "string" === typeof d && (-1 === d.indexOf(":") && (d += ":default"), d = G[d]); "string" === typeof b && (b = F[b]) } else a = {}; let e, h, f = a.context || {}; this.encode = a.encode || d && d.encode || D; this.register = c || y(); this.s = e = a.resolution || 9; this.B = c = d && d.B || a.tokenize || "strict"; this.i = "strict" === c && f.depth; this.j = t(f.bidirectional); this.g = h = t(a.optimize); this.m = t(a.fastupdate); this.h = a.minlength || 1; this.C = a.boost; this.map = h ? v(e) : y();
+        this.v = e = f.resolution || 1; this.l = h ? v(e) : y(); this.u = d && d.u || a.rtl; this.o = (c = a.matcher || b && b.o) && B(c, !1); this.A = (c = a.stemmer || b && b.A) && B(c, !0); if (a = c = a.filter || b && b.filter) { a = c; d = y(); for (let g = 0, l = a.length; g < l; g++)d[a[g]] = 1; a = d } this.filter = a
+    } I.prototype.append = function (a, c) { return this.add(a, c, !0) };
+    I.prototype.add = function (a, c, b, d) {
+        if (c && (a || 0 === a)) {
+            if (!d && !b && this.register[a]) return this.update(a, c); c = this.encode(c); if (d = c.length) {
+                const n = y(), m = y(), r = this.i, p = this.s; for (let q = 0; q < d; q++) {
+                    let k = c[this.u ? d - 1 - q : q]; var e = k.length; if (k && e >= this.h && (r || !m[k])) {
+                        var h = J(p, d, q), f = ""; switch (this.B) {
+                            case "full": if (2 < e) { for (h = 0; h < e; h++)for (var g = e; g > h; g--)if (g - h >= this.h) { var l = J(p, d, q, e, h); f = k.substring(h, g); K(this, m, f, l, a, b) } break } case "reverse": if (1 < e) {
+                                for (g = e - 1; 0 < g; g--)f = k[g] + f, f.length >= this.h && K(this,
+                                    m, f, J(p, d, q, e, g), a, b); f = ""
+                            } case "forward": if (1 < e) { for (g = 0; g < e; g++)f += k[g], f.length >= this.h && K(this, m, f, h, a, b); break } default: if (this.C && (h = Math.min(h / this.C(c, k, q) | 0, p - 1)), K(this, m, k, h, a, b), r && 1 < d && q < d - 1) for (e = y(), f = this.v, h = k, g = Math.min(r + 1, d - q), e[h] = 1, l = 1; l < g; l++)if ((k = c[this.u ? d - 1 - q - l : q + l]) && k.length >= this.h && !e[k]) { e[k] = 1; const u = this.j && k > h; K(this, n, u ? h : k, J(f + (d / 2 > f ? 0 : 1), d, q, g - 1, l - 1), a, b, u ? k : h) }
+                        }
+                    }
+                } this.m || (this.register[a] = 1)
+            }
+        } return this
+    };
+    function J(a, c, b, d, e) { return b && 1 < a ? c + (d || 0) <= a ? b + (e || 0) : (a - 1) / (c + (d || 0)) * (b + (e || 0)) + 1 | 0 : 0 } function K(a, c, b, d, e, h, f) { let g = f ? a.l : a.map; if (!c[b] || f && !c[b][f]) a.g && (g = g[d]), f ? (c = c[b] || (c[b] = y()), c[f] = 1, g = g[f] || (g[f] = y())) : c[b] = 1, g = g[b] || (g[b] = []), a.g || (g = g[d] || (g[d] = [])), h && g.includes(e) || (g[g.length] = e, a.m && (a = a.register[e] || (a.register[e] = []), a[a.length] = g)) }
+    I.prototype.search = function (a, c, b) {
+        b || (c || "object" !== typeof a ? "object" === typeof c && (b = c) : (b = a, a = b.query)); let d = [], e; let h, f = 0; if (b) { a = b.query || a; c = b.limit; f = b.offset || 0; var g = b.context; h = !1 } if (a && (a = this.encode("" + a), e = a.length, 1 < e)) { b = y(); var l = []; for (let m = 0, r = 0, p; m < e; m++)if ((p = a[m]) && p.length >= this.h && !b[p]) if (this.g || h || this.map[p]) l[r++] = p, b[p] = 1; else return d; a = l; e = a.length } if (!e) return d; c || (c = 100); g = this.i && 1 < e && !1 !== g; b = 0; let n; g ? (n = a[0], b = 1) : 1 < e && a.sort(z); for (let m, r; b < e; b++) {
+            r = a[b]; g ?
+                (m = L(this, d, h, c, f, 2 === e, r, n), h && !1 === m && d.length || (n = r)) : m = L(this, d, h, c, f, 1 === e, r); if (m) return m; if (h && b === e - 1) { l = d.length; if (!l) { if (g) { g = 0; b = -1; continue } return d } if (1 === l) return O(d[0], c, f) }
+        } return H(d, c, f, h)
+    };
+    function L(a, c, b, d, e, h, f, g) { let l = [], n = g ? a.l : a.map; a.g || (n = P(n, f, g, a.j)); if (n) { let m = 0; const r = Math.min(n.length, g ? a.v : a.s); for (let p = 0, q = 0, k, u; p < r; p++)if (k = n[p]) if (a.g && (k = P(k, f, g, a.j)), e && k && h && (u = k.length, u <= e ? (e -= u, k = null) : (k = k.slice(e), e = 0)), k && (l[m++] = k, h && (q += k.length, q >= d))) break; if (m) { if (h) return O(l, d, 0); c[c.length] = l; return } } return !b && l } function O(a, c, b) { a = 1 === a.length ? a[0] : [].concat.apply([], a); return b || a.length > c ? a.slice(b, b + c) : a }
+    function P(a, c, b, d) { b ? (d = d && c > b, a = (a = a[d ? c : b]) && a[d ? b : c]) : a = a[c]; return a } I.prototype.contain = function (a) { return !!this.register[a] }; I.prototype.update = function (a, c) { return this.remove(a).add(a, c) }; I.prototype.remove = function (a, c) { const b = this.register[a]; if (b) { if (this.m) for (let d = 0, e; d < b.length; d++)e = b[d], e.splice(e.indexOf(a), 1); else Q(this.map, a, this.s, this.g), this.i && Q(this.l, a, this.v, this.g); c || delete this.register[a] } return this };
+    function Q(a, c, b, d, e) { let h = 0; if (a.constructor === Array) if (e) c = a.indexOf(c), -1 !== c ? 1 < a.length && (a.splice(c, 1), h++) : h++; else { e = Math.min(a.length, b); for (let f = 0, g; f < e; f++)if (g = a[f]) h = Q(g, c, b, d, e), d || h || delete a[f] } else for (let f in a) (h = Q(a[f], c, b, d, e)) || delete a[f]; return h }; const R = self; let S; const T = { Index: I, Document: null, Worker: null, registerCharset: function (a, c) { G[a] = c }, registerLanguage: function (a, c) { F[a] = c } }; (S = R.define) && S.amd ? S([], function () { return T }) : R.exports ? R.exports = T : R.FlexSearch = T;
+}(this));

scripts/floCrypto.js

@@ -0,0 +1,530 @@
+(function (EXPORTS) { //floCrypto v2.3.6a
+    /* FLO Crypto Operators */
+    'use strict';
+    const floCrypto = EXPORTS;
+
+    const p = BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16);
+    const ecparams = EllipticCurve.getSECCurveByName("secp256k1");
+    const ascii_alternatives = `‘ '\n’ '\n“ "\n” "\n– --\n— ---\n≥ >=\n≤ <=\n≠ !=\n× *\n÷ /\n← <-\n→ ->\n↔ <->\n⇒ =>\n⇐ <=\n⇔ <=>`;
+    const exponent1 = () => p.add(BigInteger.ONE).divide(BigInteger("4"));
+    coinjs.compressed = true; //defaulting coinjs compressed to true;
+
+    function calculateY(x) {
+        let exp = exponent1();
+        // x is x value of public key in BigInteger format without 02 or 03 or 04 prefix
+        return x.modPow(BigInteger("3"), p).add(BigInteger("7")).mod(p).modPow(exp, p)
+    }
+
+    function getUncompressedPublicKey(compressedPublicKey) {
+        // Fetch x from compressedPublicKey
+        let pubKeyBytes = Crypto.util.hexToBytes(compressedPublicKey);
+        const prefix = pubKeyBytes.shift() // remove prefix
+        let prefix_modulus = prefix % 2;
+        pubKeyBytes.unshift(0) // add prefix 0
+        let x = new BigInteger(pubKeyBytes)
+        let xDecimalValue = x.toString()
+        // Fetch y
+        let y = calculateY(x);
+        let yDecimalValue = y.toString();
+        // verify y value
+        let resultBigInt = y.mod(BigInteger("2"));
+        let check = resultBigInt.toString() % 2;
+        if (prefix_modulus !== check)
+            yDecimalValue = y.negate().mod(p).toString();
+        return {
+            x: xDecimalValue,
+            y: yDecimalValue
+        };
+    }
+
+    function getSenderPublicKeyString() {
+        let privateKey = ellipticCurveEncryption.senderRandom();
+        var senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
+        return {
+            privateKey: privateKey,
+            senderPublicKeyString: senderPublicKeyString
+        }
+    }
+
+    function deriveSharedKeySender(receiverPublicKeyHex, senderPrivateKey) {
+        let receiverPublicKeyString = getUncompressedPublicKey(receiverPublicKeyHex);
+        var senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
+            receiverPublicKeyString.x, receiverPublicKeyString.y, senderPrivateKey);
+        return senderDerivedKey;
+    }
+
+    function deriveSharedKeyReceiver(senderPublicKeyString, receiverPrivateKey) {
+        return ellipticCurveEncryption.receiverSharedKeyDerivation(
+            senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
+    }
+
+    function getReceiverPublicKeyString(privateKey) {
+        return ellipticCurveEncryption.receiverPublicString(privateKey);
+    }
+
+    function wifToDecimal(pk_wif, isPubKeyCompressed = false) {
+        let pk = Bitcoin.Base58.decode(pk_wif)
+        pk.shift()
+        pk.splice(-4, 4)
+        //If the private key corresponded to a compressed public key, also drop the last byte (it should be 0x01).
+        if (isPubKeyCompressed == true) pk.pop()
+        pk.unshift(0)
+        let privateKeyDecimal = BigInteger(pk).toString()
+        let privateKeyHex = Crypto.util.bytesToHex(pk)
+        return {
+            privateKeyDecimal: privateKeyDecimal,
+            privateKeyHex: privateKeyHex
+        }
+    }
+
+    //generate a random Interger within range
+    floCrypto.randInt = function (min, max) {
+        min = Math.ceil(min);
+        max = Math.floor(max);
+        return Math.floor(securedMathRandom() * (max - min + 1)) + min;
+    }
+
+    //generate a random String within length (options : alphaNumeric chars only)
+    floCrypto.randString = function (length, alphaNumeric = true) {
+        var result = '';
+        var characters = alphaNumeric ? 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' :
+            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_+-./*?@#&$<>=[]{}():';
+        for (var i = 0; i < length; i++)
+            result += characters.charAt(Math.floor(securedMathRandom() * characters.length));
+        return result;
+    }
+
+    //Encrypt Data using public-key
+    floCrypto.encryptData = function (data, receiverPublicKeyHex) {
+        var senderECKeyData = getSenderPublicKeyString();
+        var senderDerivedKey = deriveSharedKeySender(receiverPublicKeyHex, senderECKeyData.privateKey);
+        let senderKey = senderDerivedKey.XValue + senderDerivedKey.YValue;
+        let secret = Crypto.AES.encrypt(data, senderKey);
+        return {
+            secret: secret,
+            senderPublicKeyString: senderECKeyData.senderPublicKeyString
+        };
+    }
+
+    //Decrypt Data using private-key
+    floCrypto.decryptData = function (data, privateKeyHex) {
+        var receiverECKeyData = {};
+        if (typeof privateKeyHex !== "string") throw new Error("No private key found.");
+        let privateKey = wifToDecimal(privateKeyHex, true);
+        if (typeof privateKey.privateKeyDecimal !== "string") throw new Error("Failed to detremine your private key.");
+        receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
+        var receiverDerivedKey = deriveSharedKeyReceiver(data.senderPublicKeyString, receiverECKeyData.privateKey);
+        let receiverKey = receiverDerivedKey.XValue + receiverDerivedKey.YValue;
+        let decryptMsg = Crypto.AES.decrypt(data.secret, receiverKey);
+        return decryptMsg;
+    }
+
+    //Sign data using private-key
+    floCrypto.signData = function (data, privateKeyHex) {
+        var key = new Bitcoin.ECKey(privateKeyHex);
+        var messageHash = Crypto.SHA256(data);
+        var messageSign = Bitcoin.ECDSA.sign(messageHash, key.priv);
+        var sighex = Crypto.util.bytesToHex(messageSign);
+        return sighex;
+    }
+
+    //Verify signatue of the data using public-key
+    floCrypto.verifySign = function (data, signatureHex, publicKeyHex) {
+        var msgHash = Crypto.SHA256(data);
+        var sigBytes = Crypto.util.hexToBytes(signatureHex);
+        var publicKeyPoint = ecparams.getCurve().decodePointHex(publicKeyHex);
+        var verify = Bitcoin.ECDSA.verify(msgHash, sigBytes, publicKeyPoint);
+        return verify;
+    }
+
+    //Generates a new flo ID and returns private-key, public-key and floID
+    const generateNewID = floCrypto.generateNewID = function () {
+        var key = new Bitcoin.ECKey(false);
+        key.setCompressed(true);
+        return {
+            floID: key.getBitcoinAddress(),
+            pubKey: key.getPubKeyHex(),
+            privKey: key.getBitcoinWalletImportFormat()
+        }
+    }
+
+    Object.defineProperties(floCrypto, {
+        newID: {
+            get: () => generateNewID()
+        },
+        hashID: {
+            value: (str) => {
+                let bytes = ripemd160(Crypto.SHA256(str, { asBytes: true }), { asBytes: true });
+                bytes.unshift(bitjs.pub);
+                var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
+                    asBytes: true
+                }), {
+                    asBytes: true
+                });
+                var checksum = hash.slice(0, 4);
+                return bitjs.Base58.encode(bytes.concat(checksum));
+            }
+        },
+        tmpID: {
+            get: () => {
+                let bytes = Crypto.util.randomBytes(20);
+                bytes.unshift(bitjs.pub);
+                var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
+                    asBytes: true
+                }), {
+                    asBytes: true
+                });
+                var checksum = hash.slice(0, 4);
+                return bitjs.Base58.encode(bytes.concat(checksum));
+            }
+        }
+    });
+
+    //Returns public-key from private-key
+    floCrypto.getPubKeyHex = function (privateKeyHex) {
+        if (!privateKeyHex)
+            return null;
+        var key = new Bitcoin.ECKey(privateKeyHex);
+        if (key.priv == null)
+            return null;
+        key.setCompressed(true);
+        return key.getPubKeyHex();
+    }
+
+    //Returns flo-ID from public-key or private-key
+    floCrypto.getFloID = function (keyHex) {
+        if (!keyHex)
+            return null;
+        try {
+            var key = new Bitcoin.ECKey(keyHex);
+            if (key.priv == null)
+                key.setPub(keyHex);
+            return key.getBitcoinAddress();
+        } catch {
+            return null;
+        }
+    }
+
+    floCrypto.getAddress = function (privateKeyHex, strict = false) {
+        if (!privateKeyHex)
+            return;
+        var key = new Bitcoin.ECKey(privateKeyHex);
+        if (key.priv == null)
+            return null;
+        key.setCompressed(true);
+        let pubKey = key.getPubKeyHex(),
+            version = bitjs.Base58.decode(privateKeyHex)[0];
+        switch (version) {
+            case coinjs.priv: //BTC
+                return coinjs.bech32Address(pubKey).address;
+            case bitjs.priv: //FLO
+                return bitjs.pubkey2address(pubKey);
+            default:
+                return strict ? false : bitjs.pubkey2address(pubKey); //default to FLO address (if strict=false)
+        }
+    }
+
+    //Verify the private-key for the given public-key or flo-ID
+    floCrypto.verifyPrivKey = function (privateKeyHex, pubKey_floID, isfloID = true) {
+        if (!privateKeyHex || !pubKey_floID)
+            return false;
+        try {
+            var key = new Bitcoin.ECKey(privateKeyHex);
+            if (key.priv == null)
+                return false;
+            key.setCompressed(true);
+            if (isfloID && pubKey_floID == key.getBitcoinAddress())
+                return true;
+            else if (!isfloID && pubKey_floID.toUpperCase() == key.getPubKeyHex().toUpperCase())
+                return true;
+            else
+                return false;
+        } catch {
+            return null;
+        }
+    }
+
+    floCrypto.getMultisigAddress = function (publicKeyList, requiredSignatures) {
+        if (!Array.isArray(publicKeyList) || !publicKeyList.length)
+            return null;
+        if (!Number.isInteger(requiredSignatures) || requiredSignatures < 1 || requiredSignatures > publicKeyList.length)
+            return null;
+        try {
+            var multisig = bitjs.pubkeys2multisig(publicKeyList, requiredSignatures);
+            return multisig;
+        } catch {
+            return null;
+        }
+    }
+
+    floCrypto.decodeRedeemScript = function (redeemScript) {
+        try {
+            var decoded = bitjs.transaction().decodeRedeemScript(redeemScript);
+            return decoded;
+        } catch {
+            return null;
+        }
+    }
+
+    //Check if the given flo-id is valid or not
+    floCrypto.validateFloID = function (floID, regularOnly = false) {
+        if (!floID)
+            return false;
+        try {
+            let addr = new Bitcoin.Address(floID);
+            if (regularOnly && addr.version != Bitcoin.Address.standardVersion)
+                return false;
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    //Check if the given address (any blockchain) is valid or not
+    floCrypto.validateAddr = function (address, std = true, bech = true) {
+        let raw = decodeAddress(address);
+        if (!raw)
+            return false;
+        if (typeof raw.version !== 'undefined') { //legacy or segwit
+            if (std == false)
+                return false;
+            else if (std === true || (!Array.isArray(std) && std === raw.version) || (Array.isArray(std) && std.includes(raw.version)))
+                return true;
+            else
+                return false;
+        } else if (typeof raw.bech_version !== 'undefined') { //bech32
+            if (bech === false)
+                return false;
+            else if (bech === true || (!Array.isArray(bech) && bech === raw.bech_version) || (Array.isArray(bech) && bech.includes(raw.bech_version)))
+                return true;
+            else
+                return false;
+        } else //unknown
+            return false;
+    }
+
+    //Check the public-key (or redeem-script) for the address (any blockchain)
+    floCrypto.verifyPubKey = function (pubKeyHex, address) {
+        let raw = decodeAddress(address);
+        if (!raw)
+            return;
+        let pub_hash = Crypto.util.bytesToHex(ripemd160(Crypto.SHA256(Crypto.util.hexToBytes(pubKeyHex), { asBytes: true })));
+        if (typeof raw.bech_version !== 'undefined' && raw.bytes.length == 32) //bech32-multisig
+            raw.hex = Crypto.util.bytesToHex(ripemd160(raw.bytes, { asBytes: true }));
+        return pub_hash === raw.hex;
+    }
+
+    //Convert the given address (any blockchain) to equivalent floID
+    floCrypto.toFloID = function (address, options = null) {
+        if (!address)
+            return;
+        let raw = decodeAddress(address);
+        if (!raw)
+            return;
+        else if (options) { //if (optional) version check is passed
+            if (typeof raw.version !== 'undefined' && (!options.std || !options.std.includes(raw.version)))
+                return;
+            if (typeof raw.bech_version !== 'undefined' && (!options.bech || !options.bech.includes(raw.bech_version)))
+                return;
+        }
+        raw.bytes.unshift(bitjs.pub);
+        let hash = Crypto.SHA256(Crypto.SHA256(raw.bytes, {
+            asBytes: true
+        }), {
+            asBytes: true
+        });
+        return bitjs.Base58.encode(raw.bytes.concat(hash.slice(0, 4)));
+    }
+
+    //Convert raw address bytes to floID
+    floCrypto.rawToFloID = function (raw_bytes) {
+        if (typeof raw_bytes === 'string')
+            raw_bytes = Crypto.util.hexToBytes(raw_bytes);
+        if (raw_bytes.length != 20)
+            return null;
+        raw_bytes.unshift(bitjs.pub);
+        let hash = Crypto.SHA256(Crypto.SHA256(raw_bytes, {
+            asBytes: true
+        }), {
+            asBytes: true
+        });
+        return bitjs.Base58.encode(raw_bytes.concat(hash.slice(0, 4)));
+    }
+
+    //Convert the given multisig address (any blockchain) to equivalent multisig floID
+    floCrypto.toMultisigFloID = function (address, options = null) {
+        if (!address)
+            return;
+        let raw = decodeAddress(address);
+        if (!raw)
+            return;
+        else if (options) { //if (optional) version check is passed
+            if (typeof raw.version !== 'undefined' && (!options.std || !options.std.includes(raw.version)))
+                return;
+            if (typeof raw.bech_version !== 'undefined' && (!options.bech || !options.bech.includes(raw.bech_version)))
+                return;
+        }
+        if (typeof raw.bech_version !== 'undefined') {
+            if (raw.bytes.length != 32) return; //multisig bech address have 32 bytes
+            //multisig-bech:hash=SHA256 whereas multisig:hash=r160(SHA265), thus ripemd160 the bytes from multisig-bech
+            raw.bytes = ripemd160(raw.bytes, {
+                asBytes: true
+            });
+        }
+        raw.bytes.unshift(bitjs.multisig);
+        let hash = Crypto.SHA256(Crypto.SHA256(raw.bytes, {
+            asBytes: true
+        }), {
+            asBytes: true
+        });
+        return bitjs.Base58.encode(raw.bytes.concat(hash.slice(0, 4)));
+    }
+
+    //Checks if the given addresses (any blockchain) are same (w.r.t keys)
+    floCrypto.isSameAddr = function (addr1, addr2) {
+        if (!addr1 || !addr2)
+            return;
+        let raw1 = decodeAddress(addr1),
+            raw2 = decodeAddress(addr2);
+        if (!raw1 || !raw2)
+            return false;
+        else {
+            if (typeof raw1.bech_version !== 'undefined' && raw1.bytes.length == 32) //bech32-multisig
+                raw1.hex = Crypto.util.bytesToHex(ripemd160(raw1.bytes, { asBytes: true }));
+            if (typeof raw2.bech_version !== 'undefined' && raw2.bytes.length == 32) //bech32-multisig
+                raw2.hex = Crypto.util.bytesToHex(ripemd160(raw2.bytes, { asBytes: true }));
+            return raw1.hex === raw2.hex;
+        }
+    }
+
+    const decodeAddress = floCrypto.decodeAddr = function (address) {
+        if (!address)
+            return;
+        else if (address.length == 33 || address.length == 34) { //legacy encoding
+            let decode = bitjs.Base58.decode(address);
+            let bytes = decode.slice(0, decode.length - 4);
+            let checksum = decode.slice(decode.length - 4),
+                hash = Crypto.SHA256(Crypto.SHA256(bytes, {
+                    asBytes: true
+                }), {
+                    asBytes: true
+                });
+            return (hash[0] != checksum[0] || hash[1] != checksum[1] || hash[2] != checksum[2] || hash[3] != checksum[3]) ? null : {
+                version: bytes.shift(),
+                hex: Crypto.util.bytesToHex(bytes),
+                bytes
+            }
+        } else if (address.length == 42 || address.length == 62) { //bech encoding
+            let decode = coinjs.bech32_decode(address);
+            if (decode) {
+                let bytes = decode.data;
+                let bech_version = bytes.shift();
+                bytes = coinjs.bech32_convert(bytes, 5, 8, false);
+                return {
+                    bech_version,
+                    hrp: decode.hrp,
+                    hex: Crypto.util.bytesToHex(bytes),
+                    bytes
+                }
+            } else
+                return null;
+        }
+    }
+
+    //Split the str using shamir's Secret and Returns the shares 
+    floCrypto.createShamirsSecretShares = function (str, total_shares, threshold_limit) {
+        try {
+            if (str.length > 0) {
+                var strHex = shamirSecretShare.str2hex(str);
+                var shares = shamirSecretShare.share(strHex, total_shares, threshold_limit);
+                return shares;
+            }
+            return false;
+        } catch {
+            return false
+        }
+    }
+
+    //Returns the retrived secret by combining the shamirs shares
+    const retrieveShamirSecret = floCrypto.retrieveShamirSecret = function (sharesArray) {
+        try {
+            if (sharesArray.length > 0) {
+                var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
+                comb = shamirSecretShare.hex2str(comb);
+                return comb;
+            }
+            return false;
+        } catch {
+            return false;
+        }
+    }
+
+    //Verifies the shares and str
+    floCrypto.verifyShamirsSecret = function (sharesArray, str) {
+        if (!str)
+            return null;
+        else if (retrieveShamirSecret(sharesArray) === str)
+            return true;
+        else
+            return false;
+    }
+
+    const validateASCII = floCrypto.validateASCII = function (string, bool = true) {
+        if (typeof string !== "string")
+            return null;
+        if (bool) {
+            let x;
+            for (let i = 0; i < string.length; i++) {
+                x = string.charCodeAt(i);
+                if (x < 32 || x > 127)
+                    return false;
+            }
+            return true;
+        } else {
+            let x, invalids = {};
+            for (let i = 0; i < string.length; i++) {
+                x = string.charCodeAt(i);
+                if (x < 32 || x > 127)
+                    if (x in invalids)
+                        invalids[string[i]].push(i)
+                    else
+                        invalids[string[i]] = [i];
+            }
+            if (Object.keys(invalids).length)
+                return invalids;
+            else
+                return true;
+        }
+    }
+
+    floCrypto.convertToASCII = function (string, mode = 'soft-remove') {
+        let chars = validateASCII(string, false);
+        if (chars === true)
+            return string;
+        else if (chars === null)
+            return null;
+        let convertor, result = string,
+            refAlt = {};
+        ascii_alternatives.split('\n').forEach(a => refAlt[a[0]] = a.slice(2));
+        mode = mode.toLowerCase();
+        if (mode === "hard-unicode")
+            convertor = (c) => `\\u${('000' + c.charCodeAt().toString(16)).slice(-4)}`;
+        else if (mode === "soft-unicode")
+            convertor = (c) => refAlt[c] || `\\u${('000' + c.charCodeAt().toString(16)).slice(-4)}`;
+        else if (mode === "hard-remove")
+            convertor = c => "";
+        else if (mode === "soft-remove")
+            convertor = c => refAlt[c] || "";
+        else
+            return null;
+        for (let c in chars)
+            result = result.replaceAll(c, convertor(c));
+        return result;
+    }
+
+    floCrypto.revertUnicode = function (string) {
+        return string.replace(/\\u[\dA-F]{4}/gi,
+            m => String.fromCharCode(parseInt(m.replace(/\\u/g, ''), 16)));
+    }
+
+})('object' === typeof module ? module.exports : window.floCrypto = {});

scripts/floTokenAPI.js

@@ -0,0 +1,166 @@
+(function (EXPORTS) { //floTokenAPI v1.0.4a
+    /* Token Operator to send/receive tokens via blockchain using API calls*/
+    'use strict';
+    const tokenAPI = EXPORTS;
+
+    const DEFAULT = {
+        apiURL: floGlobals.tokenURL || "https://ranchimallflo.duckdns.org/",
+        currency: floGlobals.currency || "rupee"
+    }
+
+    Object.defineProperties(tokenAPI, {
+        URL: {
+            get: () => DEFAULT.apiURL
+        },
+        currency: {
+            get: () => DEFAULT.currency,
+            set: currency => DEFAULT.currency = currency
+        }
+    });
+
+    if (floGlobals.currency) tokenAPI.currency = floGlobals.currency;
+
+    Object.defineProperties(floGlobals, {
+        currency: {
+            get: () => DEFAULT.currency,
+            set: currency => DEFAULT.currency = currency
+        }
+    });
+
+    const fetch_api = tokenAPI.fetch = function (apicall) {
+        return new Promise((resolve, reject) => {
+            console.debug(DEFAULT.apiURL + apicall);
+            fetch(DEFAULT.apiURL + apicall).then(response => {
+                if (response.ok)
+                    response.json().then(data => resolve(data));
+                else
+                    reject(response)
+            }).catch(error => reject(error))
+        })
+    }
+
+    const getBalance = tokenAPI.getBalance = function (floID, token = DEFAULT.currency) {
+        return new Promise((resolve, reject) => {
+            fetch_api(`api/v1.0/getFloAddressBalance?token=${token}&floAddress=${floID}`)
+                .then(result => resolve(result.balance || 0))
+                .catch(error => reject(error))
+        })
+    }
+
+    tokenAPI.getTx = function (txID) {
+        return new Promise((resolve, reject) => {
+            fetch_api(`api/v1.0/getTransactionDetails/${txID}`).then(res => {
+                if (res.result === "error")
+                    reject(res.description);
+                else if (!res.parsedFloData)
+                    reject("Data piece (parsedFloData) missing");
+                else if (!res.transactionDetails)
+                    reject("Data piece (transactionDetails) missing");
+                else
+                    resolve(res);
+            }).catch(error => reject(error))
+        })
+    }
+
+    tokenAPI.sendToken = function (privKey, amount, receiverID, message = "", token = DEFAULT.currency, options = {}) {
+        return new Promise((resolve, reject) => {
+            let senderID = floCrypto.getFloID(privKey);
+            if (typeof amount !== "number" || isNaN(amount) || amount <= 0)
+                return reject("Invalid amount");
+            getBalance(senderID, token).then(bal => {
+                if (amount > bal)
+                    return reject(`Insufficient ${token}# balance`);
+                floBlockchainAPI.writeData(senderID, `send ${amount} ${token}# ${message}`, privKey, receiverID, options)
+                    .then(txid => resolve(txid))
+                    .catch(error => reject(error))
+            }).catch(error => reject(error))
+        });
+    }
+
+    function sendTokens_raw(privKey, receiverID, token, amount, utxo, vout, scriptPubKey) {
+        return new Promise((resolve, reject) => {
+            var trx = bitjs.transaction();
+            trx.addinput(utxo, vout, scriptPubKey)
+            trx.addoutput(receiverID, floBlockchainAPI.sendAmt);
+            trx.addflodata(`send ${amount} ${token}#`);
+            var signedTxHash = trx.sign(privKey, 1);
+            floBlockchainAPI.broadcastTx(signedTxHash)
+                .then(txid => resolve([receiverID, txid]))
+                .catch(error => reject([receiverID, error]))
+        })
+    }
+
+    //bulk transfer tokens
+    tokenAPI.bulkTransferTokens = function (sender, privKey, token, receivers) {
+        return new Promise((resolve, reject) => {
+            if (typeof receivers !== 'object')
+                return reject("receivers must be object in format {receiver1: amount1, receiver2:amount2...}")
+
+            let receiver_list = Object.keys(receivers), amount_list = Object.values(receivers);
+            let invalidReceivers = receiver_list.filter(id => !floCrypto.validateFloID(id));
+            let invalidAmount = amount_list.filter(val => typeof val !== 'number' || val <= 0);
+            if (invalidReceivers.length)
+                return reject(`Invalid receivers: ${invalidReceivers}`);
+            else if (invalidAmount.length)
+                return reject(`Invalid amounts: ${invalidAmount}`);
+
+            if (receiver_list.length == 0)
+                return reject("Receivers cannot be empty");
+
+            if (receiver_list.length == 1) {
+                let receiver = receiver_list[0], amount = amount_list[0];
+                floTokenAPI.sendToken(privKey, amount, receiver, "", token)
+                    .then(txid => resolve({ success: { [receiver]: txid } }))
+                    .catch(error => reject(error))
+            } else {
+                //check for token balance
+                floTokenAPI.getBalance(sender, token).then(token_balance => {
+                    let total_token_amout = amount_list.reduce((a, e) => a + e, 0);
+                    if (total_token_amout > token_balance)
+                        return reject(`Insufficient ${token}# balance`);
+
+                    //split utxos
+                    floBlockchainAPI.splitUTXOs(sender, privKey, receiver_list.length).then(split_txid => {
+                        //wait for the split utxo to get confirmation
+                        floBlockchainAPI.waitForConfirmation(split_txid).then(split_tx => {
+                            //send tokens using the split-utxo
+                            var scriptPubKey = split_tx.vout[0].scriptPubKey.hex;
+                            let promises = [];
+                            for (let i in receiver_list)
+                                promises.push(sendTokens_raw(privKey, receiver_list[i], token, amount_list[i], split_txid, i, scriptPubKey));
+                            Promise.allSettled(promises).then(results => {
+                                let success = Object.fromEntries(results.filter(r => r.status == 'fulfilled').map(r => r.value));
+                                let failed = Object.fromEntries(results.filter(r => r.status == 'rejected').map(r => r.reason));
+                                resolve({ success, failed });
+                            })
+                        }).catch(error => reject(error))
+                    }).catch(error => reject(error))
+                }).catch(error => reject(error))
+            }
+
+        })
+    }
+
+    tokenAPI.getAllTxs = function (floID, token = DEFAULT.currency) {
+        return new Promise((resolve, reject) => {
+            fetch_api(`api/v1.0/getFloAddressTransactions?token=${token}&floAddress=${floID}`)
+                .then(result => resolve(result))
+                .catch(error => reject(error))
+        })
+    }
+
+    const util = tokenAPI.util = {};
+
+    util.parseTxData = function (txData) {
+        let parsedData = {};
+        for (let p in txData.parsedFloData)
+            parsedData[p] = txData.parsedFloData[p];
+        parsedData.sender = txData.transactionDetails.vin[0].addr;
+        for (let vout of txData.transactionDetails.vout)
+            if (vout.scriptPubKey.addresses[0] !== parsedData.sender)
+                parsedData.receiver = vout.scriptPubKey.addresses[0];
+        parsedData.time = txData.transactionDetails.time;
+        return parsedData;
+    }
+
+})('object' === typeof module ? module.exports : window.floTokenAPI = {});

style.css

@@ -1,194 +0,0 @@
-
-* {
-  box-sizing: border-box;
-}
-
-body {
-  background: #eceef1;
-  font-family: 'Slabo 27px', serif;
-  color: #333a45;
-}
-
-.wrapper {
-  margin: 5em auto;
-  max-width: 1000px;
-  background-color: #fff;
-  box-shadow: 0 0 5px 0 rgba(0, 0, 0, 0.06);
-}
-
-.header {
-  padding: 30px 30px 0;
-  text-align: center;
-}
-.header__title {
-  margin: 0;
-  text-transform: uppercase;
-  font-size: 2.5em;
-  font-weight: 500;
-  line-height: 1.1;
-}
-.header__subtitle {
-  margin: 0;
-  font-size: 1.5em;
-  color: #949fb0;
-  font-family: 'Yesteryear', cursive;
-  font-weight: 500;
-  line-height: 1.1;
-}
-
-.cards {
-  padding: 15px;
-  display: flex;
-  flex-flow: row wrap;
-}
-
-.cardcard {
-  margin: 15px;
-  width: calc((100% / 4) - 30px);
-  transition: all 0.2s ease-in-out;
-}
-@media screen and (max-width: 991px) {
-  .card {
-    width: calc((100% / 2) - 30px);
-  }
-}
-@media screen and (max-width: 767px) {
-  .card {
-    width: 100%;
-  }
-}
-.card:hover .card__inner {
-  background-color: #1abc9c;
-  -webkit-transform: scale(1.05);
-          transform: scale(1.05);
-}
-.card__inner {
-  width: 100%;
-  padding: 30px;
-  position: relative;
-  cursor: pointer;
-  background-color: #949fb0;
-  color: #eceef1;
-  font-size: 1.5em;
-  text-transform: uppercase;
-  text-align: center;
-  transition: all 0.2s ease-in-out;
-}
-.card__inner:after {
-  transition: all 0.3s ease-in-out;
-}
-.card__inner .fa {
-  width: 100%;
-  margin-top: .25em;
-}
-.card__expander {
-  transition: all 0.2s ease-in-out;
-  width: 100%;
-  position: relative;
-  border-style: solid;
-  border-width: thin;
-  text-align: left;
-  overflow:auto;
-  display: flex;
-  flex-direction: column;
-  flex-wrap: nowrap;
-  justify-content: center;
-  padding: 30px 15px 30px;
-  /*color: #5c34a2;
-  background-color: rgba(92, 52, 162, .1);*/
-}
-.card__expander .fa {
-  font-size: 0.75em;
-  position: absolute;
-  top: 10px;
-  right: 10px;
-  cursor: pointer;
-}
-.card__expander .fa:hover {
-  opacity: 0.9;
-}
-.card.is-collapsed .card__inner:after {
-  content: "";
-  opacity: 0;
-}
-.card.is-collapsed .card__expander {
-  max-height: 0;
-  min-height: 0;
-  overflow: hidden;
-  margin-top: 0;
-  opacity: 0;
-}
-.card.is-expanded .card__inner {
-  background-color: #1abc9c;
-}
-.card.is-expanded .card__inner:after {
-  content: "";
-  opacity: 1;
-  display: block;
-  height: 0;
-  width: 0;
-  position: absolute;
-  bottom: -30px;
-  left: calc(50% - 15px);
-  border-left: 15px solid transparent;
-  border-right: 15px solid transparent;
-  border-bottom: 15px solid #333a45;
-}
-.card.is-expanded .card__inner .fa:before {
-  content: "\f115";
-}
-.card.is-expanded .card__expander {
-  max-height: 1000px;
-  min-height: 200px;
-  overflow: visible;
-  margin-top: 30px;
-  opacity: 1;
-}
-.card.is-expanded:hover .card__inner {
-  -webkit-transform: scale(1);
-          transform: scale(1);
-}
-.card.is-inactive .card__inner {
-  pointer-events: none;
-  opacity: 0.5;
-}
-.card.is-inactive:hover .card__inner {
-  background-color: #949fb0;
-  -webkit-transform: scale(1);
-          transform: scale(1);
-}
-
-@media screen and (min-width: 992px) {
-  .card:nth-of-type(4n+2) .card__expander {
-    margin-left: calc(-100%);
-  }
-
-  .card:nth-of-type(4n+3) .card__expander {
-    margin-left: calc(-200%);
-  }
-
-  .card:nth-of-type(4n+4) .card__expander {
-    margin-left: calc(-300%);
-  }
-
-  .card:nth-of-type(4n+5) {
-    clear: left;
-  }
-
-  .card__expander {
-    width: calc(400%);
-  }
-}
-@media screen and (min-width: 768px) and (max-width: 991px) {
-  .card:nth-of-type(2n+2) .card__expander {
-    margin-left: calc(-100% - 30px);
-  }
-
-  .card:nth-of-type(2n+3) {
-    clear: left;
-  }
-
-  .card__expander {
-    width: calc(200% + 30px);
-  }
-}

style1.css

@@ -1,185 +0,0 @@
-* {
-  box-sizing: border-box;
-}
-
-body {
-  background: #eceef1;
-  font-family: 'Slabo 27px', serif;
-  color: #333a45;
-}
-
-.wrapper {
-  margin: 5em auto;
-  max-width: 1000px;
-  background-color: #fff;
-  box-shadow: 0 0 5px 0 rgba(0, 0, 0, 0.06);
-}
-
-.header {
-  padding: 30px 30px 0;
-  text-align: center;
-}
-.header__title {
-  margin: 0;
-  text-transform: uppercase;
-  font-size: 2.5em;
-  font-weight: 500;
-  line-height: 1.1;
-}
-.header__subtitle {
-  margin: 0;
-  font-size: 1.5em;
-  color: #949fb0;
-  font-family: 'Yesteryear', cursive;
-  font-weight: 500;
-  line-height: 1.1;
-}
-
-.cards {
-  padding: 15px;
-  display: flex;
-  flex-flow: row wrap;
-}
-
-.card {
-  margin: 15px;
-  width: calc((100% / 3) - 30px);
-  transition: all 0.2s ease-in-out;
-}
-@media screen and (max-width: 991px) {
-  .card {
-    width: calc((100% / 2) - 30px);
-  }
-}
-@media screen and (max-width: 767px) {
-  .card {
-    width: 100%;
-  }
-}
-.card:hover .card__inner {
-  background-color: #1abc9c;
-  -webkit-transform: scale(1.05);
-          transform: scale(1.05);
-}
-.card__inner {
-  width: 100%;
-  padding: 30px;
-  position: relative;
-  cursor: pointer;
-  background-color: #949fb0;
-  color: #eceef1;
-  font-size: 1.5em;
-  text-transform: uppercase;
-  text-align: center;
-  transition: all 0.2s ease-in-out;
-}
-.card__inner:after {
-  transition: all 0.3s ease-in-out;
-}
-.card__inner .fa {
-  width: 100%;
-  margin-top: .25em;
-}
-.card__expander {
-  transition: all 0.2s ease-in-out;
-  background-color: #333a45;
-  width: 100%;
-  position: relative;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  text-transform: uppercase;
-  color: #eceef1;
-  font-size: 1.5em;
-}
-.card__expander .fa {
-  font-size: 0.75em;
-  position: absolute;
-  top: 10px;
-  right: 10px;
-  cursor: pointer;
-}
-.card__expander .fa:hover {
-  opacity: 0.9;
-}
-.card.is-collapsed .card__inner:after {
-  content: "";
-  opacity: 0;
-}
-.card.is-collapsed .card__expander {
-  max-height: 0;
-  min-height: 0;
-  overflow: hidden;
-  margin-top: 0;
-  opacity: 0;
-}
-.card.is-expanded .card__inner {
-  background-color: #1abc9c;
-}
-.card.is-expanded .card__inner:after {
-  content: "";
-  opacity: 1;
-  display: block;
-  height: 0;
-  width: 0;
-  position: absolute;
-  bottom: -30px;
-  left: calc(50% - 15px);
-  border-left: 15px solid transparent;
-  border-right: 15px solid transparent;
-  border-bottom: 15px solid #333a45;
-}
-.card.is-expanded .card__inner .fa:before {
-  content: "\f115";
-}
-.card.is-expanded .card__expander {
-  max-height: 1000px;
-  min-height: 200px;
-  overflow: visible;
-  margin-top: 30px;
-  opacity: 1;
-}
-.card.is-expanded:hover .card__inner {
-  -webkit-transform: scale(1);
-          transform: scale(1);
-}
-.card.is-inactive .card__inner {
-  pointer-events: none;
-  opacity: 0.5;
-}
-.card.is-inactive:hover .card__inner {
-  background-color: #949fb0;
-  -webkit-transform: scale(1);
-          transform: scale(1);
-}
-
-@media screen and (min-width: 992px) {
-  .card:nth-of-type(3n+2) .card__expander {
-    margin-left: calc(-100% - 30px);
-  }
-
-  .card:nth-of-type(3n+3) .card__expander {
-    margin-left: calc(-200% - 60px);
-  }
-
-  .card:nth-of-type(3n+4) {
-    clear: left;
-  }
-
-  .card__expander {
-    width: calc(300% + 60px);
-  }
-}
-@media screen and (min-width: 768px) and (max-width: 991px) {
-  .card:nth-of-type(2n+2) .card__expander {
-    margin-left: calc(-100% - 30px);
-  }
-
-  .card:nth-of-type(2n+3) {
-    clear: left;
-  }
-
-  .card__expander {
-    width: calc(200% + 30px);
-  }
-}