Initial commit
This commit is contained in:
Sai Raj
GitHub
commit
4cc9a0c478
1
.gitignore
vendored
Normal file
1
.gitignore
vendored
Normal file
@ -0,0 +1 @@
|
|||||||
|
*.tmp*
|
||||||
21
LICENCE
Normal file
21
LICENCE
Normal file
@ -0,0 +1,21 @@
|
|||||||
|
MIT License
|
||||||
|
|
||||||
|
Copyright (c) 2023 Sai Raj
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||||
|
of this software and associated documentation files (the "Software"), to deal
|
||||||
|
in the Software without restriction, including without limitation the rights
|
||||||
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||||
|
copies of the Software, and to permit persons to whom the Software is
|
||||||
|
furnished to do so, subject to the following conditions:
|
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included in all
|
||||||
|
copies or substantial portions of the Software.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||||
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||||
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||||
|
SOFTWARE.
|
||||||
939
README.md
Normal file
939
README.md
Normal file
@ -0,0 +1,939 @@
|
|||||||
|
# FLO Standard Operations
|
||||||
|
RanchiMall is releasing FLO Standard Operations in order to make it easier for everyone in community to access common functions that any developer would need in a standardized way for JavaScript based development around FLO Blockchain ecosystem.
|
||||||
|
|
||||||
|
The methods enable developers to read and write into FLO Blockchain directly without any wallet or Chrome extension dependencies. They also enable developers to create digital signatures for any message out of any FLO ID, and functions verify them as well. In additional, standard methods are being provided for data encryption using recipient FLO ID and private key splitting using Shamir Secret Sharing algorithm.
|
||||||
|
|
||||||
|
We are also provding access to a common data infrastructure called the FLO Blockchain Data Cloud which can provide place for host data that will be too expensive to put inside the blockchain.
|
||||||
|
|
||||||
|
We are offering methods simplifying access to inbuilt browser database IndexedDB or IDB.
|
||||||
|
|
||||||
|
Last but not the least, we are also providing methods for simplying common operations for FLO based Distributed Application Development.
|
||||||
|
|
||||||
|
# IMPORTANT
|
||||||
|
We have two versions of cloud: old cloud version is 2.0.x in floCloudAPI, and new cloud version is >2.1.0 in floCloudAPI. Please check that the version in floCloudAPI is >2.1.0 whenever you use floCloudAPI as we are deprecating version 2.0.x
|
||||||
|
|
||||||
|
# Background on FLO Distributed Applications
|
||||||
|
|
||||||
|
FLO distibuted applications use the FLO Blockchain to store core data, and FLO Blockchain Cloud for other data. The data is accessed directly by browser based clients. No other component or servers are needed typically.
|
||||||
|
|
||||||
|
Every application has a role called the Master Admin. The clients trust anything that the Master Admin declares in the FLO Blockchain. Usually Master Admin will only declare the FLO IDs that will have operational roles in the application. These FLO IDs are called SubAdmins. The browser based clients trust actions only and only from subAdmins and no one else. That creates the trust model. First trust the Master Admin. Then find out who the master admin has authorized to act as SubAdmins in the FLO blockchain. Then trust the data and actions signed by approved SubAdmins. Since the entire chain of trust is blockchain based, it enables a blockchain driven trust model. As the blockchain data is immutable and permanent, so long as users can trust the Master Admin, blockchain will ensure that the trust is efficiently transmitted.
|
||||||
|
|
||||||
|
This approach decentralizes the trust process totally and extends the capacity of the blockchain to model almost any server based IT application.
|
||||||
|
|
||||||
|
## RanchiMall recommended approach to create a FLO Distributed Application
|
||||||
|
|
||||||
|
1. Create Master Admin FLO ID and private key
|
||||||
|
2. Role Modeling: Create SubAdmins by having Master Admin declare it in the FLO Blockchain, and decide what roles will different kind of SubAdmins play
|
||||||
|
3. Data Modeling: Create Blockchain cloud data formats for your application. Do it twice: One for system trusted users like SubAdmins using Object Data. And again for normal untrusted users using General Data
|
||||||
|
4. Define core business functionalities of the app, and create Javascript methods to model it
|
||||||
|
5. Secure the user Private Key (and other sensitive data, if any)
|
||||||
|
6. Create UI for the application, and create Javascript methods invoking them
|
||||||
|
7. Define initial startup routines using onLoadStartUp function to act when the initial load of page is done, and when refresh of the page is required for in response to any user action
|
||||||
|
|
||||||
|
## Basic Concepts of RanchiMall Blockchain Cloud for developers
|
||||||
|
|
||||||
|
* RanchiMall blockchain cloud is a service to provide a set of decentralized servers that will provide data storage to users. These decentralized servers are listed in the FLO Blockchain under an authorized FLO address. This gives the assurance to the users that those data servers can be trusted.
|
||||||
|
|
||||||
|
* The user can store his data in these servers freely. RanchiMall cloud service also provides facilities to store Javascript Objects directly. Storage in JavaScript object form makes it easier for JavaScript based applications to process the data.
|
||||||
|
|
||||||
|
* The cloud servers provide automatic backup and restoration for each other.
|
||||||
|
|
||||||
|
* Using the blockchain based data cloud, users will not need any database to store their data. The cloud will provide data storage, backup and restoration facilites.
|
||||||
|
|
||||||
|
* RanchiMall Blockchain Cloud is a password less system. Every sender has to digitally sign his data with the private key associated with its FLO ID. The cloud verifies the digital signature of the sender before storing sender data.
|
||||||
|
|
||||||
|
* Since the blockchain cloud is an ensemble of servers, we need a method to pick the right server to store the data. For this purpose, we find the a server closest to receipient of the data according to an artificial distance measure.
|
||||||
|
|
||||||
|
* Every client of the cloud can automatically compute the correct server where the data needs to be stored, and sends the message directly to that server.
|
||||||
|
|
||||||
|
* Every client of the cloud is the consumer of the data. It can ask the cloud for data sorted by a recipient, or by various options we provide like name of application, type of data, or by specific comments. The client can can also ask for all data after or before a certain point of time using a concept called Vector Clock.
|
||||||
|
|
||||||
|
* The cloud attaches the exact epoch time to any message given by a sender, and using the combination of epoch time, and sender FLO ID, the vector clock is constructed.
|
||||||
|
|
||||||
|
* The two basic forms in which users can submit data to the cloud are `General Data` and `Object Data`. `General Data` is freely flowing data, and `Object Data` is stored directly as pure Javascript Object.
|
||||||
|
|
||||||
|
* Both `General Data` and `Object Data` have been derived from `Application Data` which is the basic system data type in the cloud. Normal users will never need to use Application Data. But for documentation purposes, we are providing the technical details for Application Data as well.
|
||||||
|
|
||||||
|
- `General Data` = `Application Data` + User level Vector Clock filtering facilities
|
||||||
|
|
||||||
|
- `Object Data` = `Application Data` + Message field modified to handle Javascript Object + User level Vector Clock filtering facilities
|
||||||
|
|
||||||
|
* Consistent with blockchain data principles, RanchiMall blockchain cloud will also provide data to everyone who asks for it. So sensitive data should be encrypted using the receiver's public key using Crypto functions of FLO Standard Operations.
|
||||||
|
|
||||||
|
* Consumers of data can ask for data by receiver ID, or filter it by application, type, or comment. They can also ask for data for a given type before and after a certain vector clock.
|
||||||
|
|
||||||
|
## Common examples in usage of Standard Operations
|
||||||
|
|
||||||
|
* Sends "Hello World" message to the cloud as General Data with type1 as `type` with `myFloID` as default sender and `floGlobals.adminID` as receiver. This has vectorClock support, our the client side will automatically synchronise all the relevant data stored in cloud.
|
||||||
|
```
|
||||||
|
floCloudAPI.sendGeneralData("Hello World", "type1")
|
||||||
|
```
|
||||||
|
|
||||||
|
* Request general data of type1 type, but filtered by senderIDs being floGlobals.subAdmins
|
||||||
|
```
|
||||||
|
floCloudAPI.requestGeneralData("type1", { senderIDs: floGlobals.subAdmins })
|
||||||
|
```
|
||||||
|
|
||||||
|
* Usage of sendGeneralData from RIBC dApp
|
||||||
|
```
|
||||||
|
//take name and comments as function parameters, and sendGeneralData of InternRequests type
|
||||||
|
applyForIntern: function (name, comments = '') {
|
||||||
|
return floCloudAPI.sendGeneralData([name, comments], "InternRequests")
|
||||||
|
},
|
||||||
|
|
||||||
|
//take updates as function parameter, and return a promise that sends general data of type "InternUpdates"
|
||||||
|
postInternUpdate: function (updates) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
floCloudAPI.sendGeneralData(updates, "InternUpdates")
|
||||||
|
.then(results => resolve(results))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
})
|
||||||
|
|
||||||
|
applyForTask: function (projectCode, branch, task, comments = '') {
|
||||||
|
return floCloudAPI.sendGeneralData([projectCode, branch, task, comments], "TaskRequests")
|
||||||
|
},
|
||||||
|
|
||||||
|
setRequestStatus: function (vectorClock, status) {
|
||||||
|
return floCloudAPI.sendGeneralData({ vectorClock, status }, "RequestStatus")
|
||||||
|
},
|
||||||
|
```
|
||||||
|
* Object Data handling is automated in Standard operations unlike General data. Define, update and reset, these are only object data operations possible, yet they are very powerful in data capabilities.
|
||||||
|
```
|
||||||
|
//Initiates "myFirstObject" with {a:1,b:2}, and sends to cloud with myFloID
|
||||||
|
as default sender and floGlobals.adminID as receiver
|
||||||
|
|
||||||
|
floGlobals.appObjects["myFirstObject"] = {a:1,b:2}
|
||||||
|
floCloudAPI.resetObjectData("myFirstObject")
|
||||||
|
|
||||||
|
//Updates the old value of "myFirstObject" with {a:1,b:2}, and sends to cloud with myFloID as default sender
|
||||||
|
and floGlobals.adminID as receiver. In case of update, only the object diff will be sent
|
||||||
|
|
||||||
|
floGlobals.appObjects["myFirstObject"] = {a:1,c:3,d:4}
|
||||||
|
floCloudAPI.updateObjectData("myFirstObject")
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
* floGlobals usage from RIBC dApp
|
||||||
|
```
|
||||||
|
|
||||||
|
floGlobals.vectorClock
|
||||||
|
= {RIBC: '1637841611864_FCja6sLv58e3RMy41T5AmWyvXEWesqBCkX'}
|
||||||
|
|
||||||
|
floGlobals.generalVC["{\"application\":\"RIBC\",\"type\":\"InternUpdates\"}"]
|
||||||
|
= '1640106537305_FSdjJCJdU43a1dyWY6dRES1ekoupEjFPqQ'
|
||||||
|
|
||||||
|
floGlobals.vectorClock.RIBC
|
||||||
|
= '1637841611864_FCja6sLv58e3RMy41T5AmWyvXEWesqBCkX'
|
||||||
|
|
||||||
|
floGlobals.generalVC["{\"application\":\"RIBC\",\"type\":\"InternUpdates\"}"]
|
||||||
|
= '1640106537305_FSdjJCJdU43a1dyWY6dRES1ekoupEjFPqQ'
|
||||||
|
|
||||||
|
floGlobals.generalData["{\"application\":\"RIBC\",\"type\":\"InternUpdates\"}"][2]
|
||||||
|
= {sender: 'FPFeL5PXzW9bGosUjQYCxTHSMHidnygvvd',
|
||||||
|
vectorClock: '1580815876258_FPFeL5PXzW9bGosUjQYCxTHSMHidnygvvd', message: {…}}
|
||||||
|
|
||||||
|
floGlobals.generalData["{\"application\":\"RIBC\",\"type\":\"InternUpdates\"}"][2]["vectorClock"]
|
||||||
|
= '1580815876258_FPFeL5PXzW9bGosUjQYCxTHSMHidnygvvd'
|
||||||
|
|
||||||
|
floGlobals.generalData["{\"application\":\"RIBC\",\"type\":\"InternUpdates\"}"][2]["message"]["sender"]
|
||||||
|
= 'FPFeL5PXzW9bGosUjQYCxTHSMHidnygvvd'
|
||||||
|
|
||||||
|
floGlobals.generalData["{\"application\":\"RIBC\",\"type\":\"InternUpdates\"}"][808]["message"]["description"]
|
||||||
|
= 'Working on the flow and structure of Pearl Harbor topic'
|
||||||
|
|
||||||
|
floGlobals.appObjects.RIBC.internList.F7HVKrF68Y6YKE9XXpHhAcxt6MwRLcUD67
|
||||||
|
= 'Salomi Sarkar'
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
# Technical Details of standard operations
|
||||||
|
|
||||||
|
This template contains standard operations that can be used for the following:
|
||||||
|
| index |
|
||||||
|
| --- |
|
||||||
|
| [FLO Globals](#flo-globals) |
|
||||||
|
| [FLO Crypto Operations](#flo-crypto-operations) |
|
||||||
|
| [FLO Blockchain API Operations](#flo-blockchain-api-operations) |
|
||||||
|
| [Compact IndexedDB Operations](#compact-indexeddb-operations) |
|
||||||
|
| [FLO Cloud API Operations](#flo-cloud-api-operations) |
|
||||||
|
| [FLO Decentralized app (Dapp) Operations](#flo-decentralised-applications-dapps) |
|
||||||
|
|
||||||
|
## FLO Globals
|
||||||
|
`floGlobals` object contains the global variables and constants required for the operations. Make sure to add this object before any other scripts.
|
||||||
|
|
||||||
|
`floGlobals` contains the following properties :
|
||||||
|
1. `blockchain` : Indicates the blockchain (`"FLO"` or `"FLO_TEST"`).
|
||||||
|
2. `apiURL` : Indicates the URL for blockchain API calls.
|
||||||
|
3. `adminID` : Indicates the master admin FLO ID for the project/application.
|
||||||
|
4. `application`: Name of the project/application.
|
||||||
|
5. `sendAmt` : Indicates the default flo amount to be sent while sending transactions into the blockchain.
|
||||||
|
6. `fee` : Indicates the default fee amount to be deduced while sending transactions into the blockchain.
|
||||||
|
7. `SNStorageID`* : SuperNode Storage adminID.
|
||||||
|
8. `supernodes`⁺ : List of supernodes.
|
||||||
|
9. `subAdmins`⁺ : subAdmins of the application.
|
||||||
|
10. `appObjects`⁺ : Object Data for the app (data sent by subAdmins).
|
||||||
|
11. `generalData`⁺: General Data for the app (data sent by any user).
|
||||||
|
12. `vectorClock`⁺ and `generalVC`⁺ : vectorclocks for application data and general data respectively.
|
||||||
|
|
||||||
|
\* Values that should NOT be edited.
|
||||||
|
⁺ Values that updates in runtime.
|
||||||
|
1-8 : Required for all applications.
|
||||||
|
9-12: Required for applications based on floClouldAPI and floDapps module.
|
||||||
|
|
||||||
|
In addition, we have these system variables outside FLO Globals but used globally
|
||||||
|
1. `myFloID` : FLO ID with which user has logged in
|
||||||
|
2. `myPubKey` : Public Key attached to the user FLO ID
|
||||||
|
3. `myPrivKey` : Private Key corresponding to the user FLO ID
|
||||||
|
|
||||||
|
|
||||||
|
## FLO Crypto Operations
|
||||||
|
`floCrypto` operations can be used to perform blockchain-cryptography methods. `floCrypto` operations are synchronized and return a value. Contains the following Operations.
|
||||||
|
|
||||||
|
#### Important: FLO Crypto operations are all functions. They have not been promisified
|
||||||
|
|
||||||
|
#### Generate New FLO ID pair
|
||||||
|
floCrypto.generateNewID()
|
||||||
|
`generateNewID` generates a new flo ID and returns private-key, public-key and floID
|
||||||
|
* Returns : Object { privKey , pubKey, floID }
|
||||||
|
|
||||||
|
#### Calculate Public Key Hex
|
||||||
|
floCrypto.getPubKeyHex(privateKey)
|
||||||
|
`getPubKeyHex` returns public-key from given private-key
|
||||||
|
1. privateKey - private key in WIF format (Hex)
|
||||||
|
* Returns : pubKey (string)
|
||||||
|
|
||||||
|
#### Calculate FLO ID
|
||||||
|
floCrypto.getFloID(publickey_or_privateKey)
|
||||||
|
`getFloID` returns flo-ID from given public-key (or) private-key
|
||||||
|
1. publickey_or_privateKey - public key or private key hex value
|
||||||
|
* Returns : floID (string)
|
||||||
|
|
||||||
|
#### Calculate Address
|
||||||
|
floCrypto.getAddress(privateKey, *strict)
|
||||||
|
`getAddress` returns respective address from given private-key
|
||||||
|
1. privateKey - private key in WIF format
|
||||||
|
2. strict - boolean value (optional, default=false) (false: return flo-id if no prefix match is found)
|
||||||
|
* Returns : address (string)
|
||||||
|
|
||||||
|
#### Verify Private Key
|
||||||
|
floCrypto.verifyPrivKey(privateKey, pubKey_floID, *isfloID)
|
||||||
|
`verifyPrivKey` verify the private-key for the given public-key or flo-ID
|
||||||
|
1. privateKey - private key in WIF format (Hex)
|
||||||
|
2. pubKey_floID - public Key or flo ID
|
||||||
|
3. isfloID - boolean value (true: compare as flo ID, false: compare as public key) (optional, default is true)
|
||||||
|
* Returns : boolen (true or false)
|
||||||
|
|
||||||
|
#### Validate Address
|
||||||
|
floCrypto.validateAddr(address, *std, *bech)
|
||||||
|
`validateAddr` check if the given Address (any blockchain) is valid or not
|
||||||
|
1. address - address to validate
|
||||||
|
2. std - checks for legacy version (optional, default=true) (true: allow any, array: list of versions, value: one version only, false: allow none)
|
||||||
|
3. bech - checks for bech version (optional, default=true) (true: allow any, array: list of versions, value: one version only, false: allow none)
|
||||||
|
* Returns : boolen (true or false)
|
||||||
|
|
||||||
|
#### Validate FLO ID
|
||||||
|
floCrypto.validateFloID(floID)
|
||||||
|
`validateFloID` check if the given floID is valid or not
|
||||||
|
1. floID - flo ID to validate
|
||||||
|
* Returns : boolen (true or false)
|
||||||
|
|
||||||
|
#### Verify Public Key
|
||||||
|
floCrypto.verifyPubKey(publicKey, address)
|
||||||
|
`verifyPubKey` verify the public key for the given address (any blockchain)
|
||||||
|
1. publicKey - public key
|
||||||
|
2. address - address to verify
|
||||||
|
* Returns : boolen (true or false)
|
||||||
|
|
||||||
|
#### Data Encryption
|
||||||
|
floCrypto.encryptData(data, publicKey)
|
||||||
|
`encryptData` encrypts the given data using public-key
|
||||||
|
1. data - data to encrypt (String)
|
||||||
|
2. publicKey - public key of the recipient
|
||||||
|
* Returns : Encrypted data (Object)
|
||||||
|
|
||||||
|
#### Data Decryption
|
||||||
|
floCrypto.decryptData(data, privateKey)
|
||||||
|
`decryptData` decrypts the given data using private-key
|
||||||
|
1. data - encrypted data to decrypt (Object that was returned from encryptData)
|
||||||
|
2. privateKey - private key of the recipient
|
||||||
|
* Returns : Decrypted Data (String)
|
||||||
|
|
||||||
|
#### Sign Data
|
||||||
|
floCrypto.signData(data, privateKey)
|
||||||
|
`signData` signs the data using the private key
|
||||||
|
1. data - data to sign
|
||||||
|
2. privateKey - private key of the signer
|
||||||
|
* Returns : signature (String)
|
||||||
|
|
||||||
|
#### Verify Signature
|
||||||
|
floCrypto.verifySign(data, signature, publicKey)
|
||||||
|
`verifySign` verifies signatue of the data using public-key
|
||||||
|
1. data - data of the given signature
|
||||||
|
2. signature - signature of the data
|
||||||
|
3. publicKey - public key of the signer
|
||||||
|
* Returns : boolen (true or false)
|
||||||
|
|
||||||
|
#### Generate Random Interger
|
||||||
|
floCrypto.randInt(min, max)
|
||||||
|
`randInt` returns a randomly generated interger in a given range.
|
||||||
|
1. min - minimum value of the range
|
||||||
|
2. max - maximum value of the range
|
||||||
|
* Returns : randomNum (Interger)
|
||||||
|
|
||||||
|
#### Generate Random String
|
||||||
|
floCrypto.randString(length, alphaNumeric)
|
||||||
|
`randString` returns a randomly generated string of given length.
|
||||||
|
1. length - length of the string to be generated
|
||||||
|
2. alphaNumeric - boolean (true: generated string will only contain alphabets and digits, false: generated string will also have symbols) (optional, default value is false)
|
||||||
|
* Returns : randomString (String)
|
||||||
|
|
||||||
|
#### Create Shamir's Secret shares
|
||||||
|
floCrypto.createShamirsSecretShares(str, total_shares, threshold_limit)
|
||||||
|
`createShamirsSecretShares` splits the str into shares using shamir's secret.
|
||||||
|
1. str - string to be split
|
||||||
|
2. total_shares - total number of shares to be split into
|
||||||
|
3. threshold_limit - minimum number of shares required to reconstruct the secret str
|
||||||
|
* Returns : Shares (Array of string)
|
||||||
|
|
||||||
|
#### Retrieve Shamir's Secret
|
||||||
|
floCrypto.retrieveShamirSecret(sharesArray)
|
||||||
|
`retrieveShamirSecret` reconstructs the secret from the shares.
|
||||||
|
1. sharesArray - Array of shares
|
||||||
|
* Returns : retrivedData (String)
|
||||||
|
|
||||||
|
#### Verify Shamir's Secret
|
||||||
|
floCrypto.verifyShamirsSecret(sharesArray, str)
|
||||||
|
`verifyShamirsSecret` verfies the validity of the created shares.
|
||||||
|
1. sharesArray - Array of shares
|
||||||
|
2. str - originalData (string).
|
||||||
|
* Returns : boolen (true or false)
|
||||||
|
|
||||||
|
## FLO Blockchain API Operations
|
||||||
|
`floBlockchainAPI` object method can be used to send/recieve data to/from blockchain. These functions are asynchronous and return a promise. Contains the following functions.
|
||||||
|
|
||||||
|
#### Important: FLO Blockchain API operations have all been promisified. All output needs to be handled using .then These operations do not return function return values. Once again, they resolve do not return.
|
||||||
|
|
||||||
|
#### promisedAJAX
|
||||||
|
floBlockchainAPI.promisedAJAX(method, uri)
|
||||||
|
`promisedAJAX` requests data using API
|
||||||
|
1. method - GET/POST
|
||||||
|
- GET - Requests data from a specified resource.
|
||||||
|
- POST - Submits data to be processed to a specified resource.
|
||||||
|
2. uri(Uniform Resource Identifier) - identifier for AJAX resource. It is used to create URL(Uniform Resource Locator) for further operations.
|
||||||
|
* Resolves: responseData from the API
|
||||||
|
|
||||||
|
#### getBalance
|
||||||
|
floBlockchainAPI.getBalance(addr)
|
||||||
|
`getBalance` requests balance for specified FLO address.
|
||||||
|
1. addr - FLO address for which balance has to be retrieved
|
||||||
|
* Resolves: balance (Number)
|
||||||
|
|
||||||
|
#### writeData
|
||||||
|
floBlockchainAPI.writeData(senderAddr, Data, PrivKey, receiverAddr = floGlobals.adminID)
|
||||||
|
`writeData` writes data into blockchain, resolves transaction id if the transacation was succsessful.
|
||||||
|
1. senderAddr - FLO address from which the data and amount has to be sent.
|
||||||
|
2. Data - FLO data (string, max 1040 characters)
|
||||||
|
3. receiverAddr - FLO address to which has to be sent. (Default is specified in floGlobals.adminID)
|
||||||
|
4. PrivKey - Private key of sender
|
||||||
|
* Resolves: TransactionID (String)
|
||||||
|
|
||||||
|
#### writeDataMultiple
|
||||||
|
floBlockchainAPI.writeDataMultiple(senderPrivKeys, data, receivers = [floGlobals.adminID], preserveRatio = true)
|
||||||
|
`writeDataMultiple` writes data into blockchain from multiple floIDs to multiple floIDs, resolves transaction id if the transacation was succsessful.
|
||||||
|
1. senderPrivKeys - Array of Private keys of the senders.
|
||||||
|
2. Data - FLO data (string, max 1040 characters)
|
||||||
|
3. receivers - Array of receiver FLO Addresses. (Default is specified in floGlobals.adminID)
|
||||||
|
4. preserveRatio - boolean (true: preserves the ratio of the balance of senders, false: all senders contribute equal amount to the transaction) (optional, default is true)
|
||||||
|
* Resolves: TransactionID (String)
|
||||||
|
|
||||||
|
#### sendTx
|
||||||
|
floBlockchainAPI.sendTx(senderAddr, receiverAddr, sendAmt, PrivKey, floData = '')
|
||||||
|
`sendTx` sends a transaction to blockchain, resolves transaction id if the transacation was succsessful.
|
||||||
|
1. senderAddr - FLO address from which the data and amount has to be sent.
|
||||||
|
2. receiverAddr - FLO address to which has to be sent.
|
||||||
|
3. sendAmt - Amount of FLO coins to be sent to receiver.
|
||||||
|
4. PrivKey - Private key of sender to verify sender.
|
||||||
|
5. floData - FLO data (string, max 1040 characters) (optional, default value is empty string)
|
||||||
|
* Resolves: TransactionID (String)
|
||||||
|
|
||||||
|
#### sendTxMultiple
|
||||||
|
floBlockchainAPI.sendTxMultiple(senderPrivKeys, receivers, floData = '')
|
||||||
|
`sendTxMultiple` sends a transaction to blockchain from multiple floIDs to multiple floIDs, resolves transaction id if the transacation was succsessful.
|
||||||
|
1. senderPrivKeys - Array of Private keys of the senders (or) Object of private keys with sendAmount for each floID (eg: { privateKey1: sendAmt1, privateKey2: sendAmt2...}) .
|
||||||
|
Note: If passed as Array, then ratio of the balance of the senders are preserved. If passed as Object uses the amount given.
|
||||||
|
3. receivers - Object of receiver floIDs with receive amount (eg: {receiverID1: receiveAmt1, receiver2: receiveAmt2...})
|
||||||
|
4. floData - FLO data (string, max 1040 characters) (optional, default value is empty string)
|
||||||
|
* Resolves: TransactionID (String)
|
||||||
|
|
||||||
|
#### mergeUTXOs
|
||||||
|
floBlockchainAPI.mergeUTXOs(floID, privKey, floData = '')
|
||||||
|
`mergeUTXOs` sends a transaction to blockchain that merges all utxos of the given floID.
|
||||||
|
1. floID - FLO address of which the utxos should be merged.
|
||||||
|
2. privKey - private key of the floID.
|
||||||
|
3. floData - FLO data (string, max 1040 characters) (optional, default value is empty string)
|
||||||
|
* Resolves: TransactionID (String)
|
||||||
|
|
||||||
|
#### readTxs
|
||||||
|
floBlockchainAPI.readTxs(addr, from, to)
|
||||||
|
`readTxs` reads transactions of specified address between from and to.
|
||||||
|
1. addr - FLO address for which the transactions has to be read.
|
||||||
|
2. from - Reading transactions starts from 'from'.
|
||||||
|
3. to - Reading transactions ends on 'to'.
|
||||||
|
* Resolves: TransactionData (Object)
|
||||||
|
|
||||||
|
#### readAllTxs
|
||||||
|
floBlockchainAPI.readTxs(addr)
|
||||||
|
`readAllTxs` reads all transactions of specified address(newest first).
|
||||||
|
1. addr - FLO address for which the transactions has to be read.
|
||||||
|
* Resolves: TransactionData (Object)
|
||||||
|
|
||||||
|
#### readData
|
||||||
|
floBlockchainAPI.readData(addr, options = {})
|
||||||
|
`readData` reads FLO data from transactions of specified address
|
||||||
|
1. addr - FLO address for which the transactions data has to be read.
|
||||||
|
2. options - Contains options for filter data from transactions.
|
||||||
|
- limit : maximum number of filtered data (default = no limit)
|
||||||
|
- ignoreOld : ignore old transactions (default = 0)
|
||||||
|
- sentOnly : filters only sent data
|
||||||
|
- pattern : filters data that contains pattern as an object key in the JSON string
|
||||||
|
- filter : custom filter funtion for floData (eg . filter: d => {return d[0] == '$'})
|
||||||
|
* Resolves: Object {totalTxs, floData (Array)}
|
||||||
|
|
||||||
|
## Compact IndexedDB operations
|
||||||
|
`compactIDB` operations can be used to perform basic IndexedDB operations such as add, read/write, modify and remove. These functions are asynchronous and return a promise. Contains the following operations.
|
||||||
|
|
||||||
|
#### Important: Compact IndexedDB operations have all been promisified. All output needs to be handled using .then These operations do not return function return values. Once again, they resolve: they do not return.
|
||||||
|
|
||||||
|
#### setDefaultDB
|
||||||
|
compactIDB.setDefaultDB(dbName)
|
||||||
|
`setDefaultDB` sets the database on which further operations will be performed.
|
||||||
|
1. dbName - This is the name of default database to be used.
|
||||||
|
* Note: this operation is neither promisified nor returns a value. It just sets the default DB
|
||||||
|
|
||||||
|
#### initDB
|
||||||
|
compactIDB.initDB(dbName, objectStores = {})
|
||||||
|
`initDB` initializes new IndexedDB.
|
||||||
|
1. dbName - Specifies database to be initialized.
|
||||||
|
2. objectStores - This is an object containing various objectStores to be initiazed when creating an IDB.
|
||||||
|
* Resolves: Status (string) | Rejects: error
|
||||||
|
|
||||||
|
#### openDB
|
||||||
|
compactIDB.openDB(dbName = this.defaultDB)
|
||||||
|
`openDB` returns a promise that resolves to a default database object.
|
||||||
|
1. dbName - Name of the database (optional, uses defaultDB if not specified)
|
||||||
|
* Resolves: database (IDB) | Rejects: error
|
||||||
|
|
||||||
|
#### deleteDB
|
||||||
|
compactIDB.deleteDB(dbName = this.defaultDB)
|
||||||
|
`deleteDB` deletes the specified database.
|
||||||
|
1. dbName - Name of the database (optional, uses defaultDB if not specified)
|
||||||
|
* Resolves: Status (string) | Rejects: error
|
||||||
|
|
||||||
|
#### writeData
|
||||||
|
compactIDB.writeData(obsName, data, key = false, dbName = this.defaultDB)
|
||||||
|
`writeData` writes specified data into the database if data doesn't exists or replaces it when data is already present.
|
||||||
|
1. obsName - object store name in which the data is to be written.
|
||||||
|
2. data - data that has to be written in specified object store.
|
||||||
|
3. key - Primary key of the data (optional, false indicates key is autoincremented or passed in data)
|
||||||
|
4. dbName - Name of the database (optional, uses defaultDB if not specified)
|
||||||
|
* Resolves: Status (string) | Rejects: error
|
||||||
|
|
||||||
|
#### addData
|
||||||
|
compactIDB.addData(obsName, data, key = false, dbName = this.defaultDB)
|
||||||
|
`addData` writes new data into object store. If data already exists, it will return an error.
|
||||||
|
1. obsName - Object store name in which has to be stored.
|
||||||
|
2. data - The data which has to be added to obeject store.
|
||||||
|
3. key - Primary key of the data (optional, false indicates key is autoincremented or passed in data)
|
||||||
|
4. dbName - Name of the database (optional, uses defaultDB if not specified)
|
||||||
|
* Resolves: Status (string) | Rejects: error
|
||||||
|
|
||||||
|
#### removeData
|
||||||
|
compactDB.removeData(obsName, key, dbName = this.defaultDB)
|
||||||
|
`removeData` deletes data from specified object store using primary key.
|
||||||
|
1. obsName - Name of object store from which the data has to be removed.
|
||||||
|
2. key - Primary key of the data.
|
||||||
|
3. dbName - Name of the database (optional, uses defaultDB if not specified)
|
||||||
|
* Resolves: Status (string) | Rejects: error
|
||||||
|
|
||||||
|
#### clearData
|
||||||
|
compactDB.clearData(obsName, dbName = this.defaultDB)
|
||||||
|
`clearData` clears all data in the objectStore.
|
||||||
|
1. obsName - Name of object store from which the data has to be removed.
|
||||||
|
2. dbName - Name of the database (optional, uses defaultDB if not specified)
|
||||||
|
* Resolves: Status (string) | Rejects: error
|
||||||
|
|
||||||
|
#### readData
|
||||||
|
compactDB.readData(obsName, key, dbName = this.defaultDB)
|
||||||
|
`readData` reads the data from object store associated with specified key.
|
||||||
|
1. obsName - Name of object store from which the data has to be retrieved.
|
||||||
|
2. key - Primary key of the data to read.
|
||||||
|
3. dbName - Name of the database (optional, uses defaultDB if not specified)
|
||||||
|
* Resolves: data (Object) | Rejects: error
|
||||||
|
|
||||||
|
#### readAllData
|
||||||
|
compactDB.readAllData(obsName, dbName = this.defaultDB)
|
||||||
|
`readAllData` reads all the data from specified object store using IndexedDB openCursor method.
|
||||||
|
1. obsName - Name of object store from which the data has to be retrieved.
|
||||||
|
2. dbName - Name of the database (optional, uses defaultDB if not specified)
|
||||||
|
* Resolves: data (Object) | Rejects: error
|
||||||
|
|
||||||
|
## FLO Cloud API operations
|
||||||
|
`floCloudAPI` operations can interact with floSupernode cloud to send and retrieve data for applications. floCloudAPI uses floSupernode module for backend interactions. FLO Cloud API functions are promisified and resolves the data or status.
|
||||||
|
|
||||||
|
#### NEW providing callback as a new option for automatic refresh of data in browser
|
||||||
|
We have implemented a new feature where Standard Operations page can listen to any new general data or new object data and request for new data will be automatic. As soon as a new data is available in a cloud address, it will be notified to listening clients. This has been achieved by expanding `options` in `requestGeneralData` and `requestObjectData`
|
||||||
|
|
||||||
|
A blank callback function can be provided as an option in `requestGeneralData` in which case the `floGlobals.generalData` will be automatically updated with new generalData relevant to that `requestGeneralData` whenever such data is available with the cloud.
|
||||||
|
|
||||||
|
A blank callback function when added as an option to `requestObjectData` will automatically update `floGlobals.appObjects` with all refreshes ar available to that `requestObjectData` without calling `requestObjectData` again explicitly.
|
||||||
|
|
||||||
|
You can also specify an actual function name in callback, in which case that function will also be executed in addition to automatic data refreshes. This is usually for UI refresh needs. Alternately, one can monitor changes to `floGlobals.generalData` and `floGlobals.appObjects` via an event mechanism, and update UI whenever there are changes, in which case blank callback function is sufficient.
|
||||||
|
|
||||||
|
Note: Callbacks have been implemented using persistent listening websockets in both browsers and the cloud. So it will load the cloud with persistent memory requirements. Use it only when it is absolutely needed.
|
||||||
|
|
||||||
|
```javascript
|
||||||
|
|
||||||
|
//Requesting general data of type1 with calls in two equivalent ways using callback option for automatic refresh
|
||||||
|
floCloudAPI.requestGeneralData("type1", {callback(){}})
|
||||||
|
floCloudAPI.requestGeneralData("type1", {callback: _=> null})
|
||||||
|
|
||||||
|
//Requesting Object data for article_valuation_individual object using callback option for automatic refresh
|
||||||
|
floCloudAPI.requestObjectData("article_valuation_individual", {callback: _=> null) })
|
||||||
|
|
||||||
|
//They are all equivalent
|
||||||
|
floCloudAPI.requestGeneralData("type1", {senderID:[x,y,z], callback: ()=>{} })
|
||||||
|
floCloudAPI.requestGeneralData("type1", {senderID:[x,y,z], callback(){} })
|
||||||
|
floCloudAPI.requestGeneralData("type1", {senderID:[x,y,z], callback: _=> null })
|
||||||
|
|
||||||
|
//Implementation of a callback function that will update the UI and display data in console
|
||||||
|
floCloudAPI.requestObjectData("article_valuation_individual", {callback: fnToUseTheData} )
|
||||||
|
|
||||||
|
fnToUseTheData example:
|
||||||
|
fnToUseTheData: function (data, error) {
|
||||||
|
if(!error) {
|
||||||
|
console.log(data);
|
||||||
|
//Add Update UI function
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
#### sendApplicationData
|
||||||
|
floCloudAPI.sendApplicationData(message, type, options = {})
|
||||||
|
`sendApplicationData` sends application data to the cloud.
|
||||||
|
1. message - data to be sent
|
||||||
|
2. type - type of the data
|
||||||
|
3. options - (optional, options detailed at end of module)
|
||||||
|
* Resolves: Sent-Status (string) | Rejects: error
|
||||||
|
|
||||||
|
#### requestApplicationData
|
||||||
|
floCloudAPI.requestApplicationData(options = {})
|
||||||
|
`requestApplicationData` requests application data from the cloud.
|
||||||
|
1. options - (optional, options detailed at end of module)
|
||||||
|
* Resolves: data (Object) | Rejects: error
|
||||||
|
|
||||||
|
#### sendGeneralData
|
||||||
|
floCloudAPI.sendGeneralData(message, type, options = {})
|
||||||
|
`sendGeneralData` sends general data to the cloud.
|
||||||
|
1. message - data to be sent
|
||||||
|
2. type - type of the data
|
||||||
|
3. options - (optional, options detailed at end of module)
|
||||||
|
* Resolves: Sent-Status (string) | Rejects: error
|
||||||
|
|
||||||
|
###### Minimal Example:
|
||||||
|
floCloudAPI.sendGeneralData("Hello World", "type1")
|
||||||
|
Sends "Hello World" message to the cloud as General Data with type1 as `type` with `myFloID` as default sender and `floGlobals.adminID` as receiver
|
||||||
|
|
||||||
|
#### requestGeneralData
|
||||||
|
floCloudAPI.requestGeneralData(type, options = {})
|
||||||
|
`requestGeneralData` requests application data from the cloud.
|
||||||
|
1. type - type of the data
|
||||||
|
2. options - (optional, options detailed at end of module)
|
||||||
|
* Resolves: Status (string) | Rejects: error
|
||||||
|
|
||||||
|
###### Minimal Example:
|
||||||
|
```
|
||||||
|
floCloudAPI.requestGeneralData("type1")
|
||||||
|
Requests all messages of General Data nature from the cloud with type1 as `type` sent by anyone and `floGlobals.adminID` as default receiverID
|
||||||
|
```
|
||||||
|
#### resetObjectData
|
||||||
|
floCloudAPI.resetObjectData("objectName", options = {})
|
||||||
|
`resetObjectData` resets the objectData to cloud.
|
||||||
|
1. "objectName" - Name of the objectData to be reset. Quotes are must
|
||||||
|
2. options - (optional, options detailed at end of module)
|
||||||
|
* Resolves: Sent-Status (string) | Rejects: error
|
||||||
|
|
||||||
|
Note: value of objectData is taken from floGlobals.appObjects["objectName"]
|
||||||
|
The object data corresponding with Object Name must be defined in floGlobals.appObjects["objectName"] before a reset can be done
|
||||||
|
|
||||||
|
###### Minimal Example:
|
||||||
|
floGlobals.appObjects["myFirstObject"] = {a:1,b:2}
|
||||||
|
floCloudAPI.resetObjectData("myFirstObject")
|
||||||
|
Initiates "myFirstObject" with {a:1,b:2}, and sends to cloud with `myFloID` as default sender and `floGlobals.adminID` as receiver
|
||||||
|
|
||||||
|
#### updateObjectData
|
||||||
|
floCloudAPI.updateObjectData("objectName", options = {})
|
||||||
|
`updateObjectData` updates the objectData to cloud.
|
||||||
|
1. "objectName" - Name of the objectData to be updated. Quotes are must.
|
||||||
|
2. options - (optional, options detailed at end of module)
|
||||||
|
* Resolves: Sent-Status (string) | Rejects: error
|
||||||
|
|
||||||
|
Note: value of objectData is taken from floGlobals.appObjects["objectName"]
|
||||||
|
The object data corresponding with Object Name must be defined in floGlobals.appObjects["objectName"] before an update can be done
|
||||||
|
|
||||||
|
###### Minimal Example:
|
||||||
|
floGlobals.appObjects["myFirstObject"] = {a:1,c:3,d:4}
|
||||||
|
floCloudAPI.updateObjectData("myFirstObject")
|
||||||
|
Updates "myFirstObject" with {a:1,c:3,d:4}, and sends to cloud with `myFloID` as default sender and `floGlobals.adminID` as receiver.
|
||||||
|
|
||||||
|
#### requestObjectData
|
||||||
|
floCloudAPI.requestObjectData("objectName", options = {})
|
||||||
|
`requestObjectData` requests application data from the cloud.
|
||||||
|
1. "objectName" - Name of the objectData to be requested. Quotes are must.
|
||||||
|
2. options - (optional, options detailed at end of module)
|
||||||
|
* Resolves: Status (string) | Rejects: error
|
||||||
|
|
||||||
|
Note: The output is available at floGlobals.appObjects["objectName"] after the promise is resolved
|
||||||
|
|
||||||
|
###### Minimal Example:
|
||||||
|
floCloudAPI.requestObjectData("myFirstObject")
|
||||||
|
Requests the latest value of "myFirstObject" from the cloud. The request is sent to cloud with `myFloID` as sender and `floGlobals.adminID` as receiver. The output is available at floGlobals.appObjects["myFirstObject"]
|
||||||
|
|
||||||
|
#### sendApplicationData
|
||||||
|
floCloudAPI.sendApplicationData(message, type, options = {})
|
||||||
|
`sendApplicationData` sends application data to the cloud.
|
||||||
|
1. message - data to be sent
|
||||||
|
2. type - type of the data
|
||||||
|
3. options - (optional, options detailed at end of module)
|
||||||
|
|
||||||
|
Note: type is mandatory while sending but optional while requesting in case of Application Data. This allows ApplicationData to span different types in retrieval.
|
||||||
|
|
||||||
|
###### Minimal Example:
|
||||||
|
floCloudAPI.sendApplicationData("Hello Application World", "typeA")
|
||||||
|
Sends "Hello Application World" message to the cloud as Application Data with typeA as `type` with `myFloID` as default sender and `floGlobals.adminID` as receiver
|
||||||
|
|
||||||
|
#### requestApplicationData
|
||||||
|
floCloudAPI.requestApplicationData(options = {})
|
||||||
|
`requestApplicationData` requests application data from the cloud.
|
||||||
|
1. options - (optional, options detailed at end of module)
|
||||||
|
|
||||||
|
Note: type is mandatory while sending but optional while requesting in case of Application Data. This allows ApplicationData to span different types in retrieval.
|
||||||
|
|
||||||
|
Note: Application Data results are not stored in local IndexedDB by Standard Operations Framework.
|
||||||
|
|
||||||
|
Note: If a blank REQUEST APPLICATION DATA is made, then cloud will give all application data at the admin ID of the application
|
||||||
|
|
||||||
|
###### Minimal Example:
|
||||||
|
```
|
||||||
|
floCloudAPI.requestApplicationData()
|
||||||
|
Requests all messages of Apllication Data nature from the cloud with any `type` sent by anyone and `floGlobals.adminID` as receiverID
|
||||||
|
```
|
||||||
|
|
||||||
|
## 4. GENERAL DATA PARAMETERS AND OPTIONS
|
||||||
|
|
||||||
|
### SEND GENERAL DATA PARAMETERS AND OPTIONS
|
||||||
|
Parameters while sending
|
||||||
|
|
||||||
|
* `Message`: Actual Message to be sent
|
||||||
|
* `Type`: User defined type (anything that user wants to classify as type)
|
||||||
|
|
||||||
|
#### Options
|
||||||
|
* `receiverID` - receiver of the data
|
||||||
|
* `application` - name of the application sending the general data
|
||||||
|
* `comment` - user comment for the data
|
||||||
|
|
||||||
|
Important: Never use senderIDs in SEND GENERAL DATA options. The system automatically picks the FLO ID of the sender from FLO Globals. Its a common mistake developers make.
|
||||||
|
|
||||||
|
Type is mandatory in SEND GENERAL DATA because without at least one data identifier like TYPE, the message cannot be retrieved back
|
||||||
|
|
||||||
|
Application field is used by the Cloud to judge whether this message should be deleted after 7 days, or stored permanently. Developers should be careful not to change value of application field if the default value enables the message to be stored permanently. Currently messages sent from subadmins to any receiverID for applications notified by the cloud in the FLO Blockchain are stored permanently. So do not change application field as a caution. Use the comment field.
|
||||||
|
|
||||||
|
###### Minimal Example:
|
||||||
|
```
|
||||||
|
floCloudAPI.sendGeneralData("Hello World", "type1")
|
||||||
|
Sends "Hello World" message to the cloud as General Data with type1 as `type` with `myFloID` as default sender and `floGlobals.adminID` as receiver
|
||||||
|
```
|
||||||
|
### REQUEST GENERAL DATA PARAMETERS AND OPTIONS
|
||||||
|
|
||||||
|
Parameters while requesting
|
||||||
|
|
||||||
|
* `Type`: User defined type (retrieves all data of that type which the sender might have used in SEND DATA phase)
|
||||||
|
|
||||||
|
#### request options
|
||||||
|
* `receiverID` - receiver FLO ID of the data. ReceiverID is always a single value in our cloud design
|
||||||
|
* `senderIDs` - array of senderIDs. This must be in an array even if a single senderID is requested
|
||||||
|
* `application` - name of the application that sent the general data
|
||||||
|
* `comment` - comments for the data
|
||||||
|
* `lowerVectorClock` - VC from which the data is to be requested
|
||||||
|
* `upperVectorClock` - VC till which the data is to be requested
|
||||||
|
* `atVectorClock` - VC at which the data is to requested
|
||||||
|
* `mostRecent` - boolean (true: request only the recent data matching the pattern. Just the last one)
|
||||||
|
* `callback(){}` - will initialize websocket for automatic updates.
|
||||||
|
* `callback: fnToUseTheData` - will initialize websocket for automatic updates, and will alse execute fnToUseTheData
|
||||||
|
|
||||||
|
The results are available in floGlobals.generalData after the request promise has been resolved
|
||||||
|
|
||||||
|
floDapps.getNextGeneralData should be used to retrieve the output in the client browser where the retrieval from floGlobals.generalData has been simplified.
|
||||||
|
|
||||||
|
Type is mandatory in REQUEST GENERAL DATA. So every TYPE of general data must be requested individually and separately.
|
||||||
|
|
||||||
|
If you want to use requests to give results from all types at one go, use Application Data.
|
||||||
|
|
||||||
|
Application field is used by the Cloud to judge whether this message should be deleted after 7 days, or stored permanently. Developers should be careful not to change value of application field if the default value enables the message to be stored permanently. Currently messages sent from subadmins to any receiverID for applications notified by the cloud in the FLO Blockchain are stored permanently. So do not change application field as a caution. Use the comment field.
|
||||||
|
|
||||||
|
###### Minimal Example:
|
||||||
|
```
|
||||||
|
floCloudAPI.requestGeneralData("type1")
|
||||||
|
Requests all messages of General Data nature from the cloud with type1 as `type` sent by anyone and `floGlobals.adminID` as default receiverID
|
||||||
|
|
||||||
|
floCloudAPI.requestGeneralData("type1", {senderID:[x,y,z], callback: ()=>{}})
|
||||||
|
floCloudAPI.requestGeneralData("type1", {senderID:[x,y,z], callback(){}})
|
||||||
|
floCloudAPI.requestGeneralData("type1", {senderID:[x,y,z], callback: _=> null})
|
||||||
|
|
||||||
|
floCloudAPI.requestObjectData("article_valuation_individual", {callback: fnToUseTheData})
|
||||||
|
|
||||||
|
fnToUseTheData example:
|
||||||
|
fnToUseTheData: function (data, error) {
|
||||||
|
if(!error) console.log(data)
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
## 5. OBJECT DATA PARAMETERS AND OPTIONS
|
||||||
|
|
||||||
|
### RESET or UPDATE OBJECT DATA PARAMETERS AND OPTIONS
|
||||||
|
Parameters while resetting or updating
|
||||||
|
* `Object Name`: Name of the object with data populated in floGlobals.appObjects[objectName]
|
||||||
|
|
||||||
|
Note: The object data corresponding with Object Name must be defined in floGlobals.appObjects[objectName] before a reset or update can be done
|
||||||
|
|
||||||
|
#### Options
|
||||||
|
* `receiverID` - receiver FLO ID of the data. If this is not specified, the admin ID will be taken as receiverID
|
||||||
|
* `application` - name of the application for sending the object data
|
||||||
|
* `comment` - comment for the object data
|
||||||
|
|
||||||
|
Note: Never use senderIDs in RESET and UPDATE. The system automatically picks the FLO ID of the sender from FLO Globals. Its a common mistake developers make.
|
||||||
|
|
||||||
|
Note: Type field is never used in RESET, UPDATE or REQUEST operations in Object Data. Type field is internally blocked for Object Data.
|
||||||
|
|
||||||
|
### REQUEST OBJECT DATA PARAMETERS AND OPTIONS
|
||||||
|
|
||||||
|
#### Mandatory
|
||||||
|
`Object Name`
|
||||||
|
|
||||||
|
#### request options
|
||||||
|
* `receiverID` - receiver FLO ID of the data. ReceiverID is always a single value in our cloud design. If this is not specified, the admin ID will be taken as receiverID
|
||||||
|
* `senderIDs` - array of senderIDs. This must be in an array even if a single senderID is requested
|
||||||
|
* `application` - name of the application for which the object data is intended
|
||||||
|
* `comment` - comment for the object data
|
||||||
|
* `lowerVectorClock` - VC from which the data is to be requested
|
||||||
|
* `upperVectorClock` - VC till which the data is to be requested
|
||||||
|
* `atVectorClock` - VC at which the data is to requested
|
||||||
|
* `mostRecent` - boolean (true: request only the recent data matching the pattern. Just the last one.)
|
||||||
|
* `callback(){}` - will initialize websocket for automatic updates.
|
||||||
|
* `callback: fnToUseTheData` - will initialize websocket for automatic updates, and will alse execute fnToUseTheData
|
||||||
|
|
||||||
|
The output is available in floGlobals.appObjects[objectName] after request Object Data promise is resolved
|
||||||
|
|
||||||
|
Type field is never used while RESET, UPDATE or REQUEST operations in Object Data. Type field is internally blocked for Object Data.
|
||||||
|
|
||||||
|
Application field is used by the Cloud to judge whether this message should be deleted after 7 days, or stored permanently. Developers should be careful not to change value of application field if the default value enables the message to be stored permanently. Currently messages sent from subadmins to any receiverID for applications notified by the cloud in the FLO Blockchain are stored permanently. So do not change application field as a caution. Use the comment field.
|
||||||
|
|
||||||
|
## 6. APPLICATION DATA PARAMETERS, OPTIONS AND EXPLANATIONS
|
||||||
|
|
||||||
|
### SEND APPLICATION DATA PARAMETERS AND OPTIONS
|
||||||
|
Parameters while sending
|
||||||
|
|
||||||
|
* `Message`: Actual Message to be sent
|
||||||
|
* `Type`: User defined type (anything that user wants to classify as type)
|
||||||
|
|
||||||
|
#### Options
|
||||||
|
* `receiverID` - receiver of the data. If this is not specified, the admin ID will be taken as receiverID
|
||||||
|
* `application` - name of the application sending the data
|
||||||
|
* `comment` - user comment for the data
|
||||||
|
|
||||||
|
Important: Never use senderIDs in SEND DATA options. The system automatically picks the FLO ID of the sender from FLO Globals. Its a common mistake developers make.
|
||||||
|
|
||||||
|
Type is mandatory in SEND APPLICATION DATA because without at least one data identifier like TYPE, the message cannot be retrieved back
|
||||||
|
|
||||||
|
Application field is used by the Cloud to judge whether this message should be deleted after 7 days, or stored permanently. Developers should be careful not to change value of application field if the default value enables the message to be stored permanently. Currently messages sent from subadmins to any receiverID for applications notified by the cloud in the FLO Blockchain are stored permanently. So do not change application field as a caution. Use the comment field.
|
||||||
|
|
||||||
|
### REQUEST APPLICATION DATA PARAMETERS AND OPTIONS
|
||||||
|
|
||||||
|
#### Mandatory Parameters while requesting
|
||||||
|
None
|
||||||
|
|
||||||
|
#### request options
|
||||||
|
* `receiverID` - receiver FLO ID of the data. If this is not specified, the admin ID will be taken as receiverID. It is always a single value.
|
||||||
|
* `Type`: User defined type (retrieves all data of that type which the sender might have used in SEND DATA phase)
|
||||||
|
* `senderIDs` - array of senderIDs. This must be in an array even if a single senderID is requested.
|
||||||
|
* `application` - application of the data
|
||||||
|
* `comment` - comment of the data
|
||||||
|
* `lowerVectorClock` - VC from which the data is to be requested
|
||||||
|
* `upperVectorClock` - VC till which the data is to be requested
|
||||||
|
* `atVectorClock` - VC at which the data is to requested
|
||||||
|
* `mostRecent` - boolean (true: request only the recent data matching the pattern. Just the last one)
|
||||||
|
* `callback(){}` - will initialize websocket for automatic updates.
|
||||||
|
* `callback: fnToUseTheData` - will initialize websocket for automatic updates, and will alse execute fnToUseTheData
|
||||||
|
|
||||||
|
Note: Results will be available in promise.resolve(requestApplicationData(..)), and user will have to handle the response himself.
|
||||||
|
|
||||||
|
Note: TYPE is mandatory while SEND APPLICATION DATA but not in REQUEST APPLICATION DATA. This enables a single Application Data request to fetch across all TYPES
|
||||||
|
|
||||||
|
Note: We recommend developers to use either objectData or GeneralData as we provide inbuilt data synchronization with cloud in them. If developer wants to receive response across all TYPES, or he is interested in doing request response management of the promise himself, he should use Application Data. Rad more in next section.
|
||||||
|
|
||||||
|
Note: Application Data results are not stored in local IndexedDB by Standard Operations Framework.
|
||||||
|
|
||||||
|
Note: If a blank REQUEST APPLICATION DATA is made, then cloud will give all application data at the admin ID of the application
|
||||||
|
|
||||||
|
Note: Application field is used by the Cloud to judge whether this message should be deleted after 7 days, or stored permanently. Developers should be careful not to change value of application field if the default value enables the message to be stored permanently. Currently messages sent from subadmins to any receiverID for applications notified by the cloud in the FLO Blockchain are stored permanently. So do not change application field as a caution. Use the comment field.
|
||||||
|
|
||||||
|
# Examples for FLO Cloud data operations
|
||||||
|
|
||||||
|
## 1. Data fields stored in each of decentralised servers
|
||||||
|
|
||||||
|
vectorClock, senderID, receiverID, pubKey, message, sign, application, type, comment
|
||||||
|
|
||||||
|
* `vectorClock`: Unique time stamp and sender FLO ID attached to every message
|
||||||
|
* `senderID`: FLO ID of the sender
|
||||||
|
* `receiverID`: FLO ID of the receiver
|
||||||
|
* `pubKey`: Public Key of the sender
|
||||||
|
* `message`: The actual user data
|
||||||
|
* `sign`: Digital signature of the entire data
|
||||||
|
* `application`: The name of the application sending the data
|
||||||
|
* `type`: What internal type of data the application is sending
|
||||||
|
* `comment`: A free field for additional data
|
||||||
|
|
||||||
|
## 2. Concept of Vector Clock
|
||||||
|
Decentralized cloud servers attach a unique time based ID to every message sent to the cloud, and store it alongside the message fields.
|
||||||
|
|
||||||
|
It is stored in the form EpochTime_SenderFLOID
|
||||||
|
|
||||||
|
Vector Clock field is unique for every message stored in cloud
|
||||||
|
|
||||||
|
It allows the clients to retrieve messages before and after a certain time, and also help us identify who sent the message easily
|
||||||
|
|
||||||
|
#### Example of Vector Clock
|
||||||
|
* `1580484792246_FP97cbzsgTjHn7eyBtKSVcbkSSxZ5jWYHM`
|
||||||
|
|
||||||
|
- `1580484792246` Epoch time is GMT: Friday, January 31, 2020 3:33:12.246 PM in common time
|
||||||
|
- `FP97cbzsgTjHn7eyBtKSVcbkSSxZ5jWYHM` is the FLO ID of sender
|
||||||
|
|
||||||
|
## 3. Data Types supported by the cloud
|
||||||
|
|
||||||
|
### User Data Types
|
||||||
|
* `General Data`: Message field can be in any user form.
|
||||||
|
* `Object Data`: Message field can only be a JavaScript Object
|
||||||
|
|
||||||
|
### System Data Type
|
||||||
|
* `Application Data`: Application data is the base on which General Data system and Object Data system has been created. The formats for General Data and Application Data are exactly the same exfept type is not mandatory in SEND APPLICATION DATA. This should be used if developer wants to do his own response data management, or wants no cloud-client data synchronization.
|
||||||
|
|
||||||
|
Note:
|
||||||
|
* `General Data:` Type field is mandatory
|
||||||
|
* `Object Data:` Type field has been consumed to create object functionality
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#### Philosophy of Application Data
|
||||||
|
Application data system is original data field system that we created for our cloud. It does not integrate with local IDB storage and synchronization in the browser. In our development process, General Data was created by adding vector clock support to application data at browser level to synchronize cloud and local IDB. SEND and REQUEST options in Application Data are exactly the same as General data without vector clock IDB local storage support at browser level.
|
||||||
|
|
||||||
|
Even ObjectData was created on top of Application Data. ObjectData is a special construction provided by framework so that Javacript objects can directly be stored and retrieved from the cloud
|
||||||
|
|
||||||
|
#### Vector Clock issues in Application Data
|
||||||
|
Application data supports Vector clock in REQUEST option, but it is not mandatory. Since Application Data system has no mandatory vector clock requirement in REQUEST OPTIONS, it will always give the entire data set stored in the cloud since start if invoked without vectorClock, and user will have to custom handle the request output himself at client end. Our client side framework will not store it for the user. However the application data request invoked with vectorClock, then our cloud will give data after the vectorClock
|
||||||
|
|
||||||
|
Usually ObjectData and GeneralData systems will support most of user needs. But for cases when the user wants the entire cloud data set, and no client side framework handling, he should use ApplicationData. Although Application Data system supports lower vectorClock, upper vectorClock, at vectorClock and mostRecentvectorClock as a REQUEST option, but the processing of these have to be done by user. Unlike in case of ObjectData and GeneralData, the output of Request Application Data is not available in floGlobals.
|
||||||
|
|
||||||
|
* If lower vectorClock is specified, it will give all cloud stored application data after that vectorClock.
|
||||||
|
* If upper vectorClock is specified, it will give all cloud stored application data before that vectorClock.
|
||||||
|
* If at vectorClock is specified, it will give cloud stored application data exactly at that vectorClock.
|
||||||
|
* If most recent vectorClock is set as true, it will give just the last stored application data.
|
||||||
|
* If no vectorClock is specified, it will give all the data stored in cloud
|
||||||
|
|
||||||
|
#### No local IDB storage
|
||||||
|
Application Data results are not stored in local IndexedDB by Standard Operations Framework.
|
||||||
|
|
||||||
|
## FLO Decentralised Applications (Dapps)
|
||||||
|
`floDapps` module contains methods for basic Dapp. floDapps uses all of the above modules.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
#### setCustomPrivKeyInput
|
||||||
|
floDapps.setCustomPrivKeyInput(customFn)
|
||||||
|
`setCustomPrivKeyInput` adds a startup funtion to the Dapp
|
||||||
|
1. customFn - custom function to get login credentials (privateKey)
|
||||||
|
|
||||||
|
|
||||||
|
#### manageSubAdmins
|
||||||
|
floDapps.manageSubAdmins(adminPrivKey, addList, rmList)
|
||||||
|
`manageSubAdmins` adds and/or removes subAdmins by sending transaction to blockchain.
|
||||||
|
1. adminPrivKey - private key of the adminID
|
||||||
|
2. addList - Array of subAdmins to add
|
||||||
|
3. rmList - Array of subAdmins to remove
|
||||||
|
|
||||||
|
|
||||||
|
* Example: floDapps.manageSubAdmins(adminPrivKey, [addr1, addr2..]) to add addr1 and addr2 as subAdmin
|
||||||
|
* Example: floDapps.manageSubAdmins(adminPrivKey, null, [addr1, addr2..]) to remove addr1 and addr2 as subAdmin
|
||||||
|
* This command must be run from the console of app page only.
|
||||||
|
|
||||||
|
#### clearCredentials
|
||||||
|
floDapps.clearCredentials()
|
||||||
|
`clearCredentials` removes the login credentials stored in IDB.
|
||||||
|
|
||||||
|
#### securePrivKey
|
||||||
|
floDapps.securePrivKey(pwd)
|
||||||
|
`securePrivKey` replaces the stored private key with an encrypted variant
|
||||||
|
1. pwd - password for the encryption
|
||||||
|
Note: if securePrivKey is used, then password must be requested during customPrivKeyInput (in setCustomPrivKeyInput).
|
||||||
|
|
||||||
|
#### getNextGeneralData
|
||||||
|
floDapps.getNextGeneralData(type, vectorClock, options = {})
|
||||||
|
`getNextGeneralData` return the next generaldata
|
||||||
|
1. type - type of the general data
|
||||||
|
2. vectorClock - current known VC, from which next data to be retrived
|
||||||
|
3. options - (optional, {comment, application} of the data)
|
||||||
|
|
||||||
|
#### launchStartUp
|
||||||
|
floDapps.launchStartUp()
|
||||||
|
`launchStartUp` launchs the Dapp startup functions
|
||||||
|
|
||||||
|
##### reactorEvents
|
||||||
|
* startUpSuccessLog - called when a startup funtion is successfully completed
|
||||||
|
* startUpErrorLog - called when a startup funtion encounters an error
|
||||||
|
|
||||||
|
##### onLoadStartUp
|
||||||
|
Sample startup is defined in onLoadStartUp function
|
||||||
|
|
||||||
|
#### addStartUpFunction
|
||||||
|
floDapps.addStartUpFunction(fname, fn)
|
||||||
|
`addStartUpFunction` adds a startup funtion to the Dapp
|
||||||
|
1. fname - Name of the startup function
|
||||||
|
2. fn - body of the function
|
||||||
|
Note: startup funtions are called in parallel. Therefore only add custom startup funtion only if it can run in parallel with other startup functions. (default startup funtions are read supernode list and subAdmin list from blockchain API, load data from indexedDB, get login credentials)
|
||||||
|
|
||||||
|
```javascript
|
||||||
|
//Executes automatically on startup before anything else executes
|
||||||
|
floDapps.addStartUpFunction("myFirstFunction",
|
||||||
|
function (){
|
||||||
|
return new Promise (
|
||||||
|
(resolve,reject)=>{
|
||||||
|
console.log("First function Executed before everything else");
|
||||||
|
resolve("My First Function executed")
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
// Manual execution on console
|
||||||
|
floDapps.util.startUpFunctions.myFirstFunction();
|
||||||
|
```
|
||||||
|
|
||||||
|
Philosophy: Suppose you want a function that must run before any of standard operation function runs. Then you need to first create a promisified version of that function
|
||||||
|
|
||||||
|
### Advanced Dapp functions usually not needed for users
|
||||||
|
|
||||||
|
#### setAppObjectStores
|
||||||
|
floDapps.setAppObjectStores(appObs)
|
||||||
|
`setAppObjectStores` adds additionals objectstores for the app
|
||||||
|
1. appObs - additionals objects for the app
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
996
btcOperator.js
Normal file
996
btcOperator.js
Normal file
@ -0,0 +1,996 @@
|
|||||||
|
(function (EXPORTS) { //btcOperator v1.1.3b
|
||||||
|
/* BTC Crypto and API Operator */
|
||||||
|
const btcOperator = EXPORTS;
|
||||||
|
|
||||||
|
//This library uses API provided by chain.so (https://chain.so/)
|
||||||
|
const URL = "https://blockchain.info/";
|
||||||
|
|
||||||
|
const DUST_AMT = 546,
|
||||||
|
MIN_FEE_UPDATE = 219;
|
||||||
|
|
||||||
|
const fetch_api = btcOperator.fetch = function (api, json_res = true) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
console.debug(URL + api);
|
||||||
|
fetch(URL + api).then(response => {
|
||||||
|
if (response.ok) {
|
||||||
|
(json_res ? response.json() : response.text())
|
||||||
|
.then(result => resolve(result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
} else {
|
||||||
|
response.json()
|
||||||
|
.then(result => reject(result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
}
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
};
|
||||||
|
|
||||||
|
const SATOSHI_IN_BTC = 1e8;
|
||||||
|
|
||||||
|
const util = btcOperator.util = {};
|
||||||
|
|
||||||
|
util.Sat_to_BTC = value => parseFloat((value / SATOSHI_IN_BTC).toFixed(8));
|
||||||
|
util.BTC_to_Sat = value => parseInt(value * SATOSHI_IN_BTC);
|
||||||
|
|
||||||
|
function get_fee_rate() {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
fetch('https://api.blockchain.info/mempool/fees').then(response => {
|
||||||
|
if (response.ok)
|
||||||
|
response.json()
|
||||||
|
.then(result => resolve(util.Sat_to_BTC(result.regular)))
|
||||||
|
.catch(error => reject(error));
|
||||||
|
else
|
||||||
|
reject(response);
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
const broadcastTx = btcOperator.broadcastTx = rawTxHex => new Promise((resolve, reject) => {
|
||||||
|
let url = 'https://coinb.in/api/?uid=1&key=12345678901234567890123456789012&setmodule=bitcoin&request=sendrawtransaction';
|
||||||
|
fetch(url, {
|
||||||
|
method: 'POST',
|
||||||
|
headers: {
|
||||||
|
'Content-Type': 'application/x-www-form-urlencoded'
|
||||||
|
},
|
||||||
|
body: "rawtx=" + rawTxHex
|
||||||
|
}).then(response => {
|
||||||
|
response.text().then(resultText => {
|
||||||
|
let r = resultText.match(/<result>.*<\/result>/);
|
||||||
|
if (!r)
|
||||||
|
reject(resultText);
|
||||||
|
else {
|
||||||
|
r = r.pop().replace('<result>', '').replace('</result>', '');
|
||||||
|
if (r == '1') {
|
||||||
|
let txid = resultText.match(/<txid>.*<\/txid>/).pop().replace('<txid>', '').replace('</txid>', '');
|
||||||
|
resolve(txid);
|
||||||
|
} else if (r == '0') {
|
||||||
|
let error = resultText.match(/<response>.*<\/response>/).pop().replace('<response>', '').replace('</response>', '');
|
||||||
|
reject(decodeURIComponent(error.replace(/\+/g, " ")));
|
||||||
|
} else reject(resultText);
|
||||||
|
}
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
});
|
||||||
|
|
||||||
|
Object.defineProperties(btcOperator, {
|
||||||
|
newKeys: {
|
||||||
|
get: () => {
|
||||||
|
let r = coinjs.newKeys();
|
||||||
|
r.segwitAddress = coinjs.segwitAddress(r.pubkey).address;
|
||||||
|
r.bech32Address = coinjs.bech32Address(r.pubkey).address;
|
||||||
|
return r;
|
||||||
|
}
|
||||||
|
},
|
||||||
|
pubkey: {
|
||||||
|
value: key => key.length >= 66 ? key : (key.length == 64 ? coinjs.newPubkey(key) : coinjs.wif2pubkey(key).pubkey)
|
||||||
|
},
|
||||||
|
address: {
|
||||||
|
value: (key, prefix = undefined) => coinjs.pubkey2address(btcOperator.pubkey(key), prefix)
|
||||||
|
},
|
||||||
|
segwitAddress: {
|
||||||
|
value: key => coinjs.segwitAddress(btcOperator.pubkey(key)).address
|
||||||
|
},
|
||||||
|
bech32Address: {
|
||||||
|
value: key => coinjs.bech32Address(btcOperator.pubkey(key)).address
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
coinjs.compressed = true;
|
||||||
|
|
||||||
|
const verifyKey = btcOperator.verifyKey = function (addr, key) {
|
||||||
|
if (!addr || !key)
|
||||||
|
return undefined;
|
||||||
|
switch (coinjs.addressDecode(addr).type) {
|
||||||
|
case "standard":
|
||||||
|
return btcOperator.address(key) === addr;
|
||||||
|
case "multisig":
|
||||||
|
return btcOperator.segwitAddress(key) === addr;
|
||||||
|
case "bech32":
|
||||||
|
return btcOperator.bech32Address(key) === addr;
|
||||||
|
default:
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
const validateAddress = btcOperator.validateAddress = function (addr) {
|
||||||
|
if (!addr)
|
||||||
|
return undefined;
|
||||||
|
let type = coinjs.addressDecode(addr).type;
|
||||||
|
if (["standard", "multisig", "bech32", "multisigBech32"].includes(type))
|
||||||
|
return type;
|
||||||
|
else
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.multiSigAddress = function (pubKeys, minRequired, bech32 = true) {
|
||||||
|
if (!Array.isArray(pubKeys))
|
||||||
|
throw "pubKeys must be an array of public keys";
|
||||||
|
else if (pubKeys.length < minRequired)
|
||||||
|
throw "minimum required should be less than the number of pubKeys";
|
||||||
|
if (bech32)
|
||||||
|
return coinjs.pubkeys2MultisigAddressBech32(pubKeys, minRequired);
|
||||||
|
else
|
||||||
|
return coinjs.pubkeys2MultisigAddress(pubKeys, minRequired);
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.decodeRedeemScript = function (redeemScript, bech32 = true) {
|
||||||
|
let script = coinjs.script();
|
||||||
|
let decoded = (bech32) ?
|
||||||
|
script.decodeRedeemScriptBech32(redeemScript) :
|
||||||
|
script.decodeRedeemScript(redeemScript);
|
||||||
|
if (!decoded)
|
||||||
|
return null;
|
||||||
|
return {
|
||||||
|
address: decoded.address,
|
||||||
|
pubKeys: decoded.pubkeys,
|
||||||
|
redeemScript: decoded.redeemscript,
|
||||||
|
required: decoded.signaturesRequired
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
//convert from one blockchain to another blockchain (target version)
|
||||||
|
btcOperator.convert = {};
|
||||||
|
|
||||||
|
btcOperator.convert.wif = function (source_wif, target_version = coinjs.priv) {
|
||||||
|
let keyHex = util.decodeLegacy(source_wif).hex;
|
||||||
|
if (!keyHex || keyHex.length < 66 || !/01$/.test(keyHex))
|
||||||
|
return null;
|
||||||
|
else
|
||||||
|
return util.encodeLegacy(keyHex, target_version);
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.convert.legacy2legacy = function (source_addr, target_version = coinjs.pub) {
|
||||||
|
let rawHex = util.decodeLegacy(source_addr).hex;
|
||||||
|
if (!rawHex)
|
||||||
|
return null;
|
||||||
|
else
|
||||||
|
return util.encodeLegacy(rawHex, target_version);
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.convert.legacy2bech = function (source_addr, target_version = coinjs.bech32.version, target_hrp = coinjs.bech32.hrp) {
|
||||||
|
let rawHex = util.decodeLegacy(source_addr).hex;
|
||||||
|
if (!rawHex)
|
||||||
|
return null;
|
||||||
|
else
|
||||||
|
return util.encodeBech32(rawHex, target_version, target_hrp);
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.convert.bech2bech = function (source_addr, target_version = coinjs.bech32.version, target_hrp = coinjs.bech32.hrp) {
|
||||||
|
let rawHex = util.decodeBech32(source_addr).hex;
|
||||||
|
if (!rawHex)
|
||||||
|
return null;
|
||||||
|
else
|
||||||
|
return util.encodeBech32(rawHex, target_version, target_hrp);
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.convert.bech2legacy = function (source_addr, target_version = coinjs.pub) {
|
||||||
|
let rawHex = util.decodeBech32(source_addr).hex;
|
||||||
|
if (!rawHex)
|
||||||
|
return null;
|
||||||
|
else
|
||||||
|
return util.encodeLegacy(rawHex, target_version);
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.convert.multisig2multisig = function (source_addr, target_version = coinjs.multisig) {
|
||||||
|
let rawHex = util.decodeLegacy(source_addr).hex;
|
||||||
|
if (!rawHex)
|
||||||
|
return null;
|
||||||
|
else
|
||||||
|
return util.encodeLegacy(rawHex, target_version);
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.convert.bech2multisig = function (source_addr, target_version = coinjs.multisig) {
|
||||||
|
let rawHex = util.decodeBech32(source_addr).hex;
|
||||||
|
if (!rawHex)
|
||||||
|
return null;
|
||||||
|
else {
|
||||||
|
rawHex = Crypto.util.bytesToHex(ripemd160(Crypto.util.hexToBytes(rawHex), { asBytes: true }));
|
||||||
|
return util.encodeLegacy(rawHex, target_version);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
util.decodeLegacy = function (source) {
|
||||||
|
var decode = coinjs.base58decode(source);
|
||||||
|
var raw = decode.slice(0, decode.length - 4),
|
||||||
|
checksum = decode.slice(decode.length - 4);
|
||||||
|
var hash = Crypto.SHA256(Crypto.SHA256(raw, {
|
||||||
|
asBytes: true
|
||||||
|
}), {
|
||||||
|
asBytes: true
|
||||||
|
});
|
||||||
|
if (hash[0] != checksum[0] || hash[1] != checksum[1] || hash[2] != checksum[2] || hash[3] != checksum[3])
|
||||||
|
return false;
|
||||||
|
let version = raw.shift();
|
||||||
|
return {
|
||||||
|
version: version,
|
||||||
|
hex: Crypto.util.bytesToHex(raw)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
util.encodeLegacy = function (hex, version) {
|
||||||
|
var bytes = Crypto.util.hexToBytes(hex);
|
||||||
|
bytes.unshift(version);
|
||||||
|
var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
|
||||||
|
asBytes: true
|
||||||
|
}), {
|
||||||
|
asBytes: true
|
||||||
|
});
|
||||||
|
var checksum = hash.slice(0, 4);
|
||||||
|
return coinjs.base58encode(bytes.concat(checksum));
|
||||||
|
}
|
||||||
|
|
||||||
|
util.decodeBech32 = function (source) {
|
||||||
|
let decode = coinjs.bech32_decode(source);
|
||||||
|
if (!decode)
|
||||||
|
return false;
|
||||||
|
var raw = decode.data;
|
||||||
|
let version = raw.shift();
|
||||||
|
raw = coinjs.bech32_convert(raw, 5, 8, false);
|
||||||
|
return {
|
||||||
|
hrp: decode.hrp,
|
||||||
|
version: version,
|
||||||
|
hex: Crypto.util.bytesToHex(raw)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
util.encodeBech32 = function (hex, version, hrp) {
|
||||||
|
var bytes = Crypto.util.hexToBytes(hex);
|
||||||
|
bytes = coinjs.bech32_convert(bytes, 8, 5, true);
|
||||||
|
bytes.unshift(version)
|
||||||
|
return coinjs.bech32_encode(hrp, bytes);
|
||||||
|
}
|
||||||
|
|
||||||
|
//BTC blockchain APIs
|
||||||
|
|
||||||
|
btcOperator.getBalance = addr => new Promise((resolve, reject) => {
|
||||||
|
fetch_api(`q/addressbalance/${addr}`)
|
||||||
|
.then(result => resolve(util.Sat_to_BTC(result)))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
});
|
||||||
|
|
||||||
|
const BASE_TX_SIZE = 12,
|
||||||
|
BASE_INPUT_SIZE = 41,
|
||||||
|
LEGACY_INPUT_SIZE = 107,
|
||||||
|
BECH32_INPUT_SIZE = 27,
|
||||||
|
BECH32_MULTISIG_INPUT_SIZE = 35,
|
||||||
|
SEGWIT_INPUT_SIZE = 59,
|
||||||
|
MULTISIG_INPUT_SIZE_ES = 351,
|
||||||
|
BASE_OUTPUT_SIZE = 9,
|
||||||
|
LEGACY_OUTPUT_SIZE = 25,
|
||||||
|
BECH32_OUTPUT_SIZE = 23,
|
||||||
|
BECH32_MULTISIG_OUTPUT_SIZE = 34,
|
||||||
|
SEGWIT_OUTPUT_SIZE = 23;
|
||||||
|
|
||||||
|
function _redeemScript(addr, key) {
|
||||||
|
let decode = coinjs.addressDecode(addr);
|
||||||
|
switch (decode.type) {
|
||||||
|
case "standard":
|
||||||
|
return false;
|
||||||
|
case "multisig":
|
||||||
|
return key ? coinjs.segwitAddress(btcOperator.pubkey(key)).redeemscript : null;
|
||||||
|
case "bech32":
|
||||||
|
return decode.redeemscript;
|
||||||
|
default:
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function _sizePerInput(addr, rs) {
|
||||||
|
switch (coinjs.addressDecode(addr).type) {
|
||||||
|
case "standard":
|
||||||
|
return BASE_INPUT_SIZE + LEGACY_INPUT_SIZE;
|
||||||
|
case "bech32":
|
||||||
|
return BASE_INPUT_SIZE + BECH32_INPUT_SIZE;
|
||||||
|
case "multisigBech32":
|
||||||
|
return BASE_INPUT_SIZE + BECH32_MULTISIG_INPUT_SIZE;
|
||||||
|
case "multisig":
|
||||||
|
switch (coinjs.script().decodeRedeemScript(rs).type) {
|
||||||
|
case "segwit__":
|
||||||
|
return BASE_INPUT_SIZE + SEGWIT_INPUT_SIZE;
|
||||||
|
case "multisig__":
|
||||||
|
return BASE_INPUT_SIZE + MULTISIG_INPUT_SIZE_ES;
|
||||||
|
default:
|
||||||
|
return null;
|
||||||
|
};
|
||||||
|
default:
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function _sizePerOutput(addr) {
|
||||||
|
switch (coinjs.addressDecode(addr).type) {
|
||||||
|
case "standard":
|
||||||
|
return BASE_OUTPUT_SIZE + LEGACY_OUTPUT_SIZE;
|
||||||
|
case "bech32":
|
||||||
|
return BASE_OUTPUT_SIZE + BECH32_OUTPUT_SIZE;
|
||||||
|
case "multisigBech32":
|
||||||
|
return BASE_OUTPUT_SIZE + BECH32_MULTISIG_OUTPUT_SIZE;
|
||||||
|
case "multisig":
|
||||||
|
return BASE_OUTPUT_SIZE + SEGWIT_OUTPUT_SIZE;
|
||||||
|
default:
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function validateTxParameters(parameters) {
|
||||||
|
let invalids = [];
|
||||||
|
//sender-ids
|
||||||
|
if (parameters.senders) {
|
||||||
|
if (!Array.isArray(parameters.senders))
|
||||||
|
parameters.senders = [parameters.senders];
|
||||||
|
parameters.senders.forEach(id => !validateAddress(id) ? invalids.push(id) : null);
|
||||||
|
if (invalids.length)
|
||||||
|
throw "Invalid senders:" + invalids;
|
||||||
|
}
|
||||||
|
if (parameters.privkeys) {
|
||||||
|
if (!Array.isArray(parameters.privkeys))
|
||||||
|
parameters.privkeys = [parameters.privkeys];
|
||||||
|
if (parameters.senders.length != parameters.privkeys.length)
|
||||||
|
throw "Array length for senders and privkeys should be equal";
|
||||||
|
parameters.senders.forEach((id, i) => {
|
||||||
|
let key = parameters.privkeys[i];
|
||||||
|
if (!verifyKey(id, key)) //verify private-key
|
||||||
|
invalids.push(id);
|
||||||
|
if (key.length === 64) //convert Hex to WIF if needed
|
||||||
|
parameters.privkeys[i] = coinjs.privkey2wif(key);
|
||||||
|
});
|
||||||
|
if (invalids.length)
|
||||||
|
throw "Invalid private key for address:" + invalids;
|
||||||
|
}
|
||||||
|
//receiver-ids (and change-id)
|
||||||
|
if (!Array.isArray(parameters.receivers))
|
||||||
|
parameters.receivers = [parameters.receivers];
|
||||||
|
parameters.receivers.forEach(id => !validateAddress(id) ? invalids.push(id) : null);
|
||||||
|
if (invalids.length)
|
||||||
|
throw "Invalid receivers:" + invalids;
|
||||||
|
if (parameters.change_address && !validateAddress(parameters.change_address))
|
||||||
|
throw "Invalid change_address:" + parameters.change_address;
|
||||||
|
//fee and amounts
|
||||||
|
if ((typeof parameters.fee !== "number" || parameters.fee <= 0) && parameters.fee !== null) //fee = null (auto calc)
|
||||||
|
throw "Invalid fee:" + parameters.fee;
|
||||||
|
if (!Array.isArray(parameters.amounts))
|
||||||
|
parameters.amounts = [parameters.amounts];
|
||||||
|
if (parameters.receivers.length != parameters.amounts.length)
|
||||||
|
throw "Array length for receivers and amounts should be equal";
|
||||||
|
parameters.amounts.forEach(a => typeof a !== "number" || a <= 0 ? invalids.push(a) : null);
|
||||||
|
if (invalids.length)
|
||||||
|
throw "Invalid amounts:" + invalids;
|
||||||
|
//return
|
||||||
|
return parameters;
|
||||||
|
}
|
||||||
|
|
||||||
|
function createTransaction(senders, redeemScripts, receivers, amounts, fee, change_address, fee_from_receiver) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
let total_amount = parseFloat(amounts.reduce((t, a) => t + a, 0).toFixed(8));
|
||||||
|
const tx = coinjs.transaction();
|
||||||
|
let output_size = addOutputs(tx, receivers, amounts, change_address);
|
||||||
|
addInputs(tx, senders, redeemScripts, total_amount, fee, output_size, fee_from_receiver).then(result => {
|
||||||
|
if (result.change_amount > 0 && result.change_amount > result.fee) //add change amount if any (ignore dust change)
|
||||||
|
tx.outs[tx.outs.length - 1].value = util.BTC_to_Sat(result.change_amount); //values are in satoshi
|
||||||
|
if (fee_from_receiver) { //deduce fee from receivers if fee_from_receiver
|
||||||
|
let fee_remaining = util.BTC_to_Sat(result.fee);
|
||||||
|
for (let i = 0; i < tx.outs.length - 1 && fee_remaining > 0; i++) {
|
||||||
|
if (fee_remaining < tx.outs[i].value) {
|
||||||
|
tx.outs[i].value -= fee_remaining;
|
||||||
|
fee_remaining = 0;
|
||||||
|
} else {
|
||||||
|
fee_remaining -= tx.outs[i].value;
|
||||||
|
tx.outs[i].value = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (fee_remaining > 0)
|
||||||
|
return reject("Send amount is less than fee");
|
||||||
|
|
||||||
|
}
|
||||||
|
//remove all output with value less than DUST amount
|
||||||
|
let filtered_outputs = [], dust_value = 0;
|
||||||
|
tx.outs.forEach(o => o.value >= DUST_AMT ? filtered_outputs.push(o) : dust_value += o.value);
|
||||||
|
tx.outs = filtered_outputs;
|
||||||
|
//update result values
|
||||||
|
result.fee += util.Sat_to_BTC(dust_value);
|
||||||
|
result.output_size = output_size;
|
||||||
|
result.output_amount = total_amount - (fee_from_receiver ? result.fee : 0);
|
||||||
|
result.total_size = BASE_TX_SIZE + output_size + result.input_size;
|
||||||
|
result.transaction = tx;
|
||||||
|
resolve(result);
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
function addInputs(tx, senders, redeemScripts, total_amount, fee, output_size, fee_from_receiver) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (fee !== null) {
|
||||||
|
addUTXOs(tx, senders, redeemScripts, fee_from_receiver ? total_amount : total_amount + fee, false).then(result => {
|
||||||
|
result.fee = fee;
|
||||||
|
resolve(result);
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
} else {
|
||||||
|
get_fee_rate().then(fee_rate => {
|
||||||
|
let net_fee = BASE_TX_SIZE * fee_rate;
|
||||||
|
net_fee += (output_size * fee_rate);
|
||||||
|
(fee_from_receiver ?
|
||||||
|
addUTXOs(tx, senders, redeemScripts, total_amount, false) :
|
||||||
|
addUTXOs(tx, senders, redeemScripts, total_amount + net_fee, fee_rate)
|
||||||
|
).then(result => {
|
||||||
|
result.fee = parseFloat((net_fee + (result.input_size * fee_rate)).toFixed(8));
|
||||||
|
result.fee_rate = fee_rate;
|
||||||
|
resolve(result);
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
function addUTXOs(tx, senders, redeemScripts, required_amount, fee_rate, rec_args = {}) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
required_amount = parseFloat(required_amount.toFixed(8));
|
||||||
|
if (typeof rec_args.n === "undefined") {
|
||||||
|
rec_args.n = 0;
|
||||||
|
rec_args.input_size = 0;
|
||||||
|
rec_args.input_amount = 0;
|
||||||
|
}
|
||||||
|
if (required_amount <= 0)
|
||||||
|
return resolve({
|
||||||
|
input_size: rec_args.input_size,
|
||||||
|
input_amount: rec_args.input_amount,
|
||||||
|
change_amount: required_amount * -1 //required_amount will be -ve of change_amount
|
||||||
|
});
|
||||||
|
else if (rec_args.n >= senders.length)
|
||||||
|
return reject("Insufficient Balance");
|
||||||
|
let addr = senders[rec_args.n],
|
||||||
|
rs = redeemScripts[rec_args.n];
|
||||||
|
let addr_type = coinjs.addressDecode(addr).type;
|
||||||
|
let size_per_input = _sizePerInput(addr, rs);
|
||||||
|
fetch_api(`unspent?active=${addr}`).then(result => {
|
||||||
|
let utxos = result.unspent_outputs;
|
||||||
|
//console.debug("add-utxo", addr, rs, required_amount, utxos);
|
||||||
|
for (let i = 0; i < utxos.length && required_amount > 0; i++) {
|
||||||
|
if (!utxos[i].confirmations) //ignore unconfirmed utxo
|
||||||
|
continue;
|
||||||
|
var script;
|
||||||
|
if (!rs || !rs.length) //legacy script
|
||||||
|
script = utxos[i].script;
|
||||||
|
else if (((rs.match(/^00/) && rs.length == 44)) || (rs.length == 40 && rs.match(/^[a-f0-9]+$/gi)) || addr_type === 'multisigBech32') {
|
||||||
|
//redeemScript for segwit/bech32 and multisig (bech32)
|
||||||
|
let s = coinjs.script();
|
||||||
|
s.writeBytes(Crypto.util.hexToBytes(rs));
|
||||||
|
s.writeOp(0);
|
||||||
|
s.writeBytes(coinjs.numToBytes(utxos[i].value.toFixed(0), 8));
|
||||||
|
script = Crypto.util.bytesToHex(s.buffer);
|
||||||
|
} else //redeemScript for multisig (segwit)
|
||||||
|
script = rs;
|
||||||
|
tx.addinput(utxos[i].tx_hash_big_endian, utxos[i].tx_output_n, script, 0xfffffffd /*sequence*/); //0xfffffffd for Replace-by-fee
|
||||||
|
//update track values
|
||||||
|
rec_args.input_size += size_per_input;
|
||||||
|
rec_args.input_amount += util.Sat_to_BTC(utxos[i].value);
|
||||||
|
required_amount -= util.Sat_to_BTC(utxos[i].value);
|
||||||
|
if (fee_rate) //automatic fee calculation (dynamic)
|
||||||
|
required_amount += size_per_input * fee_rate;
|
||||||
|
}
|
||||||
|
rec_args.n += 1;
|
||||||
|
addUTXOs(tx, senders, redeemScripts, required_amount, fee_rate, rec_args)
|
||||||
|
.then(result => resolve(result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
function addOutputs(tx, receivers, amounts, change_address) {
|
||||||
|
let size = 0;
|
||||||
|
for (let i in receivers) {
|
||||||
|
tx.addoutput(receivers[i], amounts[i]);
|
||||||
|
size += _sizePerOutput(receivers[i]);
|
||||||
|
}
|
||||||
|
tx.addoutput(change_address, 0);
|
||||||
|
size += _sizePerOutput(change_address);
|
||||||
|
return size;
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
function autoFeeCalc(tx) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
get_fee_rate().then(fee_rate => {
|
||||||
|
let tx_size = tx.size();
|
||||||
|
for (var i = 0; i < this.ins.length; i++)
|
||||||
|
switch (tx.extractScriptKey(i).type) {
|
||||||
|
case 'scriptpubkey':
|
||||||
|
tx_size += SIGN_SIZE;
|
||||||
|
break;
|
||||||
|
case 'segwit':
|
||||||
|
case 'multisig':
|
||||||
|
tx_size += SIGN_SIZE * 0.25;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
console.warn('Unknown script-type');
|
||||||
|
tx_size += SIGN_SIZE;
|
||||||
|
}
|
||||||
|
resolve(tx_size * fee_rate);
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
function editFee(tx, current_fee, target_fee, index = -1) {
|
||||||
|
//values are in satoshi
|
||||||
|
index = parseInt(index >= 0 ? index : tx.outs.length - index);
|
||||||
|
if (index < 0 || index >= tx.outs.length)
|
||||||
|
throw "Invalid index";
|
||||||
|
let edit_value = parseInt(current_fee - target_fee), //rip of any decimal places
|
||||||
|
current_value = tx.outs[index].value; //could be BigInterger
|
||||||
|
if (edit_value < 0 && edit_value > current_value)
|
||||||
|
throw "Insufficient value at vout";
|
||||||
|
tx.outs[index].value = current_value instanceof BigInteger ?
|
||||||
|
current_value.add(new BigInteger('' + edit_value)) : parseInt(current_value + edit_value);
|
||||||
|
}
|
||||||
|
*/
|
||||||
|
|
||||||
|
function tx_fetch_for_editing(tx) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (typeof tx == 'string' && /^[0-9a-f]{64}$/i.test(tx)) { //tx is txid
|
||||||
|
getTx.hex(tx)
|
||||||
|
.then(txhex => resolve(deserializeTx(txhex)))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
} else resolve(deserializeTx(tx));
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
btcOperator.editFee = function (tx_hex, new_fee, private_keys, change_only = true) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (!Array.isArray(private_keys))
|
||||||
|
private_keys = [private_keys];
|
||||||
|
tx_fetch_for_editing(tx_hex).then(tx => {
|
||||||
|
parseTransaction(tx).then(tx_parsed => {
|
||||||
|
if (tx_parsed.fee >= new_fee)
|
||||||
|
return reject("Fees can only be increased");
|
||||||
|
|
||||||
|
//editable addresses in output values (for fee increase)
|
||||||
|
var edit_output_address = new Set();
|
||||||
|
if (change_only === true) //allow only change values (ie, sender address) to be edited to inc fee
|
||||||
|
tx_parsed.inputs.forEach(inp => edit_output_address.add(inp.address));
|
||||||
|
else if (change_only === false) //allow all output values to be edited
|
||||||
|
tx_parsed.outputs.forEach(out => edit_output_address.add(out.address));
|
||||||
|
else if (typeof change_only == 'string') // allow only given receiver id output to be edited
|
||||||
|
edit_output_address.add(change_only);
|
||||||
|
else if (Array.isArray(change_only)) //allow only given set of receiver id outputs to be edited
|
||||||
|
change_only.forEach(id => edit_output_address.add(id));
|
||||||
|
|
||||||
|
//edit output values to increase fee
|
||||||
|
let inc_fee = util.BTC_to_Sat(new_fee - tx_parsed.fee);
|
||||||
|
if (inc_fee < MIN_FEE_UPDATE)
|
||||||
|
return reject(`Insufficient additional fee. Minimum increment: ${MIN_FEE_UPDATE}`);
|
||||||
|
for (let i = tx.outs.length - 1; i >= 0 && inc_fee > 0; i--) //reduce in reverse order
|
||||||
|
if (edit_output_address.has(tx_parsed.outputs[i].address)) {
|
||||||
|
let current_value = tx.outs[i].value;
|
||||||
|
if (current_value instanceof BigInteger) //convert BigInteger class to inv value
|
||||||
|
current_value = current_value.intValue();
|
||||||
|
//edit the value as required
|
||||||
|
if (current_value > inc_fee) {
|
||||||
|
tx.outs[i].value = current_value - inc_fee;
|
||||||
|
inc_fee = 0;
|
||||||
|
} else {
|
||||||
|
inc_fee -= current_value;
|
||||||
|
tx.outs[i].value = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (inc_fee > 0) {
|
||||||
|
let max_possible_fee = util.BTC_to_Sat(new_fee) - inc_fee; //in satoshi
|
||||||
|
return reject(`Insufficient output values to increase fee. Maximum fee possible: ${util.Sat_to_BTC(max_possible_fee)}`);
|
||||||
|
}
|
||||||
|
tx.outs = tx.outs.filter(o => o.value >= DUST_AMT); //remove all output with value less than DUST amount
|
||||||
|
|
||||||
|
//remove existing signatures and reset the scripts
|
||||||
|
let wif_keys = [];
|
||||||
|
for (let i in tx.ins) {
|
||||||
|
var addr = tx_parsed.inputs[i].address,
|
||||||
|
value = util.BTC_to_Sat(tx_parsed.inputs[i].value);
|
||||||
|
let addr_decode = coinjs.addressDecode(addr);
|
||||||
|
//find the correct key for addr
|
||||||
|
var privKey = private_keys.find(pk => verifyKey(addr, pk));
|
||||||
|
if (!privKey)
|
||||||
|
return reject(`Private key missing for ${addr}`);
|
||||||
|
//find redeemScript (if any)
|
||||||
|
const rs = _redeemScript(addr, privKey);
|
||||||
|
rs === false ? wif_keys.unshift(privKey) : wif_keys.push(privKey); //sorting private-keys (wif)
|
||||||
|
//reset the script for re-signing
|
||||||
|
var script;
|
||||||
|
if (!rs || !rs.length) {
|
||||||
|
//legacy script (derive from address)
|
||||||
|
let s = coinjs.script();
|
||||||
|
s.writeOp(118); //OP_DUP
|
||||||
|
s.writeOp(169); //OP_HASH160
|
||||||
|
s.writeBytes(addr_decode.bytes);
|
||||||
|
s.writeOp(136); //OP_EQUALVERIFY
|
||||||
|
s.writeOp(172); //OP_CHECKSIG
|
||||||
|
script = Crypto.util.bytesToHex(s.buffer);
|
||||||
|
} else if (((rs.match(/^00/) && rs.length == 44)) || (rs.length == 40 && rs.match(/^[a-f0-9]+$/gi)) || addr_decode.type === 'multisigBech32') {
|
||||||
|
//redeemScript for segwit/bech32 and multisig (bech32)
|
||||||
|
let s = coinjs.script();
|
||||||
|
s.writeBytes(Crypto.util.hexToBytes(rs));
|
||||||
|
s.writeOp(0);
|
||||||
|
s.writeBytes(coinjs.numToBytes(value.toFixed(0), 8));
|
||||||
|
script = Crypto.util.bytesToHex(s.buffer);
|
||||||
|
} else //redeemScript for multisig (segwit)
|
||||||
|
script = rs;
|
||||||
|
tx.ins[i].script = coinjs.script(script);
|
||||||
|
}
|
||||||
|
tx.witness = false; //remove all witness signatures
|
||||||
|
console.debug("Unsigned:", tx.serialize());
|
||||||
|
//re-sign the transaction
|
||||||
|
new Set(wif_keys).forEach(key => tx.sign(key, 1 /*sighashtype*/)); //Sign the tx using private key WIF
|
||||||
|
resolve(tx.serialize());
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.sendTx = function (senders, privkeys, receivers, amounts, fee = null, options = {}) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
createSignedTx(senders, privkeys, receivers, amounts, fee, options).then(result => {
|
||||||
|
debugger;
|
||||||
|
broadcastTx(result.transaction.serialize())
|
||||||
|
.then(txid => resolve(txid))
|
||||||
|
.catch(error => reject(error));
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
const createSignedTx = btcOperator.createSignedTx = function (senders, privkeys, receivers, amounts, fee = null, options = {}) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
try {
|
||||||
|
({
|
||||||
|
senders,
|
||||||
|
privkeys,
|
||||||
|
receivers,
|
||||||
|
amounts
|
||||||
|
} = validateTxParameters({
|
||||||
|
senders,
|
||||||
|
privkeys,
|
||||||
|
receivers,
|
||||||
|
amounts,
|
||||||
|
fee,
|
||||||
|
change_address: options.change_address
|
||||||
|
}));
|
||||||
|
} catch (e) {
|
||||||
|
return reject(e)
|
||||||
|
}
|
||||||
|
let redeemScripts = [],
|
||||||
|
wif_keys = [];
|
||||||
|
for (let i in senders) {
|
||||||
|
let rs = _redeemScript(senders[i], privkeys[i]); //get redeem-script (segwit/bech32)
|
||||||
|
redeemScripts.push(rs);
|
||||||
|
rs === false ? wif_keys.unshift(privkeys[i]) : wif_keys.push(privkeys[i]); //sorting private-keys (wif)
|
||||||
|
}
|
||||||
|
if (redeemScripts.includes(null)) //TODO: segwit
|
||||||
|
return reject("Unable to get redeem-script");
|
||||||
|
//create transaction
|
||||||
|
createTransaction(senders, redeemScripts, receivers, amounts, fee, options.change_address || senders[0], options.fee_from_receiver).then(result => {
|
||||||
|
let tx = result.transaction;
|
||||||
|
console.debug("Unsigned:", tx.serialize());
|
||||||
|
new Set(wif_keys).forEach(key => tx.sign(key, 1 /*sighashtype*/)); //Sign the tx using private key WIF
|
||||||
|
console.debug("Signed:", tx.serialize());
|
||||||
|
resolve(result);
|
||||||
|
}).catch(error => reject(error));
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.createTx = function (senders, receivers, amounts, fee = null, options = {}) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
try {
|
||||||
|
({
|
||||||
|
senders,
|
||||||
|
receivers,
|
||||||
|
amounts
|
||||||
|
} = validateTxParameters({
|
||||||
|
senders,
|
||||||
|
receivers,
|
||||||
|
amounts,
|
||||||
|
fee,
|
||||||
|
change_address: options.change_address
|
||||||
|
}));
|
||||||
|
} catch (e) {
|
||||||
|
return reject(e)
|
||||||
|
}
|
||||||
|
let redeemScripts = senders.map(id => _redeemScript(id));
|
||||||
|
if (redeemScripts.includes(null)) //TODO: segwit
|
||||||
|
return reject("Unable to get redeem-script");
|
||||||
|
//create transaction
|
||||||
|
createTransaction(senders, redeemScripts, receivers, amounts, fee, options.change_address || senders[0], options.fee_from_receiver).then(result => {
|
||||||
|
result.tx_hex = result.transaction.serialize();
|
||||||
|
delete result.transaction;
|
||||||
|
resolve(result);
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.createMultiSigTx = function (sender, redeemScript, receivers, amounts, fee = null, options = {}) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
//validate tx parameters
|
||||||
|
let addr_type = validateAddress(sender);
|
||||||
|
if (!(["multisig", "multisigBech32"].includes(addr_type)))
|
||||||
|
return reject("Invalid sender (multisig):" + sender);
|
||||||
|
else {
|
||||||
|
let script = coinjs.script();
|
||||||
|
let decode = (addr_type == "multisig") ?
|
||||||
|
script.decodeRedeemScript(redeemScript) :
|
||||||
|
script.decodeRedeemScriptBech32(redeemScript);
|
||||||
|
if (!decode || decode.address !== sender)
|
||||||
|
return reject("Invalid redeem-script");
|
||||||
|
}
|
||||||
|
try {
|
||||||
|
({
|
||||||
|
receivers,
|
||||||
|
amounts
|
||||||
|
} = validateTxParameters({
|
||||||
|
receivers,
|
||||||
|
amounts,
|
||||||
|
fee,
|
||||||
|
change_address: options.change_address
|
||||||
|
}));
|
||||||
|
} catch (e) {
|
||||||
|
return reject(e)
|
||||||
|
}
|
||||||
|
//create transaction
|
||||||
|
createTransaction([sender], [redeemScript], receivers, amounts, fee, options.change_address || sender, options.fee_from_receiver).then(result => {
|
||||||
|
result.tx_hex = result.transaction.serialize();
|
||||||
|
delete result.transaction;
|
||||||
|
resolve(result);
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
function deserializeTx(tx) {
|
||||||
|
if (typeof tx === 'string' || Array.isArray(tx)) {
|
||||||
|
try {
|
||||||
|
tx = coinjs.transaction().deserialize(tx);
|
||||||
|
} catch {
|
||||||
|
throw "Invalid transaction hex";
|
||||||
|
}
|
||||||
|
} else if (typeof tx !== 'object' || typeof tx.sign !== 'function')
|
||||||
|
throw "Invalid transaction object";
|
||||||
|
return tx;
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.signTx = function (tx, privkeys, sighashtype = 1) {
|
||||||
|
tx = deserializeTx(tx);
|
||||||
|
if (!Array.isArray(privkeys))
|
||||||
|
privkeys = [privkeys];
|
||||||
|
for (let i in privkeys)
|
||||||
|
if (privkeys[i].length === 64)
|
||||||
|
privkeys[i] = coinjs.privkey2wif(privkeys[i]);
|
||||||
|
new Set(privkeys).forEach(key => tx.sign(key, sighashtype)); //Sign the tx using private key WIF
|
||||||
|
return tx.serialize();
|
||||||
|
}
|
||||||
|
|
||||||
|
const checkSigned = btcOperator.checkSigned = function (tx, bool = true) {
|
||||||
|
tx = deserializeTx(tx);
|
||||||
|
let n = [];
|
||||||
|
for (let i in tx.ins) {
|
||||||
|
var s = tx.extractScriptKey(i);
|
||||||
|
if (s['type'] !== 'multisig' && s['type'] !== 'multisig_bech32')
|
||||||
|
n.push(s.signed == 'true' || (tx.witness[i] && tx.witness[i].length == 2))
|
||||||
|
else {
|
||||||
|
var rs = coinjs.script().decodeRedeemScript(s.script); //will work for bech32 too, as only address is diff
|
||||||
|
let x = {
|
||||||
|
s: s['signatures'],
|
||||||
|
r: rs['signaturesRequired'],
|
||||||
|
t: rs['pubkeys'].length
|
||||||
|
};
|
||||||
|
if (x.r > x.t)
|
||||||
|
throw "signaturesRequired is more than publicKeys";
|
||||||
|
else if (x.s < x.r)
|
||||||
|
n.push(x);
|
||||||
|
else
|
||||||
|
n.push(true);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return bool ? !(n.filter(x => x !== true).length) : n;
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.checkIfSameTx = function (tx1, tx2) {
|
||||||
|
tx1 = deserializeTx(tx1);
|
||||||
|
tx2 = deserializeTx(tx2);
|
||||||
|
//compare input and output length
|
||||||
|
if (tx1.ins.length !== tx2.ins.length || tx1.outs.length !== tx2.outs.length)
|
||||||
|
return false;
|
||||||
|
//compare inputs
|
||||||
|
for (let i = 0; i < tx1.ins.length; i++)
|
||||||
|
if (tx1.ins[i].outpoint.hash !== tx2.ins[i].outpoint.hash || tx1.ins[i].outpoint.index !== tx2.ins[i].outpoint.index)
|
||||||
|
return false;
|
||||||
|
//compare outputs
|
||||||
|
for (let i = 0; i < tx1.outs.length; i++)
|
||||||
|
if (tx1.outs[i].value !== tx2.outs[i].value || Crypto.util.bytesToHex(tx1.outs[i].script.buffer) !== Crypto.util.bytesToHex(tx2.outs[i].script.buffer))
|
||||||
|
return false;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
const getTxOutput = (txid, i) => new Promise((resolve, reject) => {
|
||||||
|
fetch_api(`rawtx/${txid}`)
|
||||||
|
.then(result => resolve(result.out[i]))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
});
|
||||||
|
|
||||||
|
const parseTransaction = btcOperator.parseTransaction = function (tx) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
tx = deserializeTx(tx);
|
||||||
|
let result = {};
|
||||||
|
let promises = [];
|
||||||
|
//Parse Inputs
|
||||||
|
for (let i = 0; i < tx.ins.length; i++)
|
||||||
|
promises.push(getTxOutput(tx.ins[i].outpoint.hash, tx.ins[i].outpoint.index));
|
||||||
|
Promise.all(promises).then(inputs => {
|
||||||
|
result.inputs = inputs.map(inp => Object({
|
||||||
|
address: inp.addr,
|
||||||
|
value: util.Sat_to_BTC(inp.value)
|
||||||
|
}));
|
||||||
|
let signed = checkSigned(tx, false);
|
||||||
|
result.inputs.forEach((inp, i) => inp.signed = signed[i]);
|
||||||
|
//Parse Outputs
|
||||||
|
result.outputs = tx.outs.map(out => {
|
||||||
|
var address;
|
||||||
|
switch (out.script.chunks[0]) {
|
||||||
|
case 0: //bech32, multisig-bech32
|
||||||
|
address = util.encodeBech32(Crypto.util.bytesToHex(out.script.chunks[1]), coinjs.bech32.version, coinjs.bech32.hrp);
|
||||||
|
break;
|
||||||
|
case 169: //segwit, multisig-segwit
|
||||||
|
address = util.encodeLegacy(Crypto.util.bytesToHex(out.script.chunks[1]), coinjs.multisig);
|
||||||
|
break;
|
||||||
|
case 118: //legacy
|
||||||
|
address = util.encodeLegacy(Crypto.util.bytesToHex(out.script.chunks[2]), coinjs.pub);
|
||||||
|
}
|
||||||
|
return {
|
||||||
|
address,
|
||||||
|
value: util.Sat_to_BTC(out.value)
|
||||||
|
}
|
||||||
|
});
|
||||||
|
//Parse Totals
|
||||||
|
result.total_input = parseFloat(result.inputs.reduce((a, inp) => a += inp.value, 0).toFixed(8));
|
||||||
|
result.total_output = parseFloat(result.outputs.reduce((a, out) => a += out.value, 0).toFixed(8));
|
||||||
|
result.fee = parseFloat((result.total_input - result.total_output).toFixed(8));
|
||||||
|
resolve(result);
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
btcOperator.transactionID = function (tx) {
|
||||||
|
tx = deserializeTx(tx);
|
||||||
|
let clone = coinjs.clone(tx);
|
||||||
|
clone.witness = null;
|
||||||
|
let raw_bytes = Crypto.util.hexToBytes(clone.serialize());
|
||||||
|
let txid = Crypto.SHA256(Crypto.SHA256(raw_bytes, { asBytes: true }), { asBytes: true }).reverse();
|
||||||
|
return Crypto.util.bytesToHex(txid);
|
||||||
|
}
|
||||||
|
|
||||||
|
const getLatestBlock = btcOperator.getLatestBlock = () => new Promise((resolve, reject) => {
|
||||||
|
fetch_api(`q/getblockcount`)
|
||||||
|
.then(result => resolve(result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
})
|
||||||
|
|
||||||
|
const getTx = btcOperator.getTx = txid => new Promise((resolve, reject) => {
|
||||||
|
fetch_api(`rawtx/${txid}`).then(result => {
|
||||||
|
getLatestBlock().then(latest_block => resolve({
|
||||||
|
block: result.block_height,
|
||||||
|
txid: result.hash,
|
||||||
|
time: result.time * 1000,
|
||||||
|
confirmations: result.block_height === null ? 0 : latest_block - result.block_height, //calculate confirmations using latest block number as api doesnt relay it
|
||||||
|
size: result.size,
|
||||||
|
fee: util.Sat_to_BTC(result.fee),
|
||||||
|
inputs: result.inputs.map(i => Object({ address: i.prev_out.addr, value: util.Sat_to_BTC(i.prev_out.value) })),
|
||||||
|
total_input_value: util.Sat_to_BTC(result.inputs.reduce((a, i) => a + i.prev_out.value, 0)),
|
||||||
|
outputs: result.out.map(o => Object({ address: o.addr, value: util.Sat_to_BTC(o.value) })),
|
||||||
|
total_output_value: util.Sat_to_BTC(result.out.reduce((a, o) => a += o.value, 0)),
|
||||||
|
}))
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
});
|
||||||
|
|
||||||
|
getTx.hex = txid => new Promise((resolve, reject) => {
|
||||||
|
fetch_api(`rawtx/${txid}?format=hex`, false)
|
||||||
|
.then(result => resolve(result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
})
|
||||||
|
|
||||||
|
btcOperator.getAddressData = address => new Promise((resolve, reject) => {
|
||||||
|
fetch_api(`rawaddr/${address}`).then(data => {
|
||||||
|
let details = {};
|
||||||
|
details.balance = util.Sat_to_BTC(data.final_balance);
|
||||||
|
details.address = data.address;
|
||||||
|
details.txs = data.txs.map(tx => {
|
||||||
|
let d = {
|
||||||
|
txid: tx.hash,
|
||||||
|
time: tx.time * 1000, //s to ms
|
||||||
|
block: tx.block_height,
|
||||||
|
}
|
||||||
|
//sender list
|
||||||
|
d.tx_senders = {};
|
||||||
|
tx.inputs.forEach(i => {
|
||||||
|
if (i.prev_out.addr in d.tx_senders)
|
||||||
|
d.tx_senders[i.prev_out.addr] += i.prev_out.value;
|
||||||
|
else d.tx_senders[i.prev_out.addr] = i.prev_out.value;
|
||||||
|
});
|
||||||
|
d.tx_input_value = 0;
|
||||||
|
for (let s in d.tx_senders) {
|
||||||
|
let val = d.tx_senders[s];
|
||||||
|
d.tx_senders[s] = util.Sat_to_BTC(val);
|
||||||
|
d.tx_input_value += val;
|
||||||
|
}
|
||||||
|
d.tx_input_value = util.Sat_to_BTC(d.tx_input_value);
|
||||||
|
//receiver list
|
||||||
|
d.tx_receivers = {};
|
||||||
|
tx.out.forEach(o => {
|
||||||
|
if (o.addr in d.tx_receivers)
|
||||||
|
d.tx_receivers[o.addr] += o.value;
|
||||||
|
else d.tx_receivers[o.addr] = o.value;
|
||||||
|
});
|
||||||
|
d.tx_output_value = 0;
|
||||||
|
for (let r in d.tx_receivers) {
|
||||||
|
let val = d.tx_receivers[r];
|
||||||
|
d.tx_receivers[r] = util.Sat_to_BTC(val);
|
||||||
|
d.tx_output_value += val;
|
||||||
|
}
|
||||||
|
d.tx_output_value = util.Sat_to_BTC(d.tx_output_value);
|
||||||
|
d.tx_fee = util.Sat_to_BTC(tx.fee);
|
||||||
|
//tx type
|
||||||
|
if (tx.result > 0) { //net > 0, balance inc => type=in
|
||||||
|
d.type = "in";
|
||||||
|
d.amount = util.Sat_to_BTC(tx.result);
|
||||||
|
d.sender = Object.keys(d.tx_senders).filter(s => s !== address);
|
||||||
|
} else if (Object.keys(d.tx_receivers).some(r => r !== address)) { //net < 0, balance dec & receiver present => type=out
|
||||||
|
d.type = "out";
|
||||||
|
d.amount = util.Sat_to_BTC(tx.result * -1);
|
||||||
|
d.receiver = Object.keys(d.tx_receivers).filter(r => r !== address);
|
||||||
|
d.fee = d.tx_fee;
|
||||||
|
} else { //net < 0 (fee) & no other id in receiver list => type=self
|
||||||
|
d.type = "self";
|
||||||
|
d.amount = d.tx_receivers[address];
|
||||||
|
d.address = address
|
||||||
|
}
|
||||||
|
return d;
|
||||||
|
})
|
||||||
|
resolve(details);
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
});
|
||||||
|
|
||||||
|
btcOperator.getBlock = block => new Promise((resolve, reject) => {
|
||||||
|
fetch_api(`rawblock/${block}`).then(result => resolve({
|
||||||
|
height: result.height,
|
||||||
|
hash: result.hash,
|
||||||
|
merkle_root: result.mrkl_root,
|
||||||
|
prev_block: result.prev_block,
|
||||||
|
next_block: result.next_block[0],
|
||||||
|
size: result.size,
|
||||||
|
time: result.time * 1000, //s to ms
|
||||||
|
txs: result.tx.map(t => Object({
|
||||||
|
fee: t.fee,
|
||||||
|
size: t.size,
|
||||||
|
inputs: t.inputs.map(i => Object({ address: i.prev_out.addr, value: util.Sat_to_BTC(i.prev_out.value) })),
|
||||||
|
total_input_value: util.Sat_to_BTC(t.inputs.reduce((a, i) => a + i.prev_out.value, 0)),
|
||||||
|
outputs: t.out.map(o => Object({ address: o.addr, value: util.Sat_to_BTC(o.value) })),
|
||||||
|
total_output_value: util.Sat_to_BTC(t.out.reduce((a, o) => a += o.value, 0)),
|
||||||
|
}))
|
||||||
|
|
||||||
|
})).catch(error => reject(error))
|
||||||
|
});
|
||||||
|
|
||||||
|
})('object' === typeof module ? module.exports : window.btcOperator = {});
|
||||||
257
compactIDB.js
Normal file
257
compactIDB.js
Normal file
@ -0,0 +1,257 @@
|
|||||||
|
(function (EXPORTS) { //compactIDB v2.1.2
|
||||||
|
/* Compact IndexedDB operations */
|
||||||
|
'use strict';
|
||||||
|
const compactIDB = EXPORTS;
|
||||||
|
|
||||||
|
var defaultDB;
|
||||||
|
|
||||||
|
const indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
|
||||||
|
const IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction || window.msIDBTransaction;
|
||||||
|
const IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange || window.msIDBKeyRange;
|
||||||
|
|
||||||
|
if (!indexedDB) {
|
||||||
|
console.error("Your browser doesn't support a stable version of IndexedDB.");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
compactIDB.setDefaultDB = dbName => defaultDB = dbName;
|
||||||
|
|
||||||
|
Object.defineProperty(compactIDB, 'default', {
|
||||||
|
get: () => defaultDB,
|
||||||
|
set: dbName => defaultDB = dbName
|
||||||
|
});
|
||||||
|
|
||||||
|
function getDBversion(dbName = defaultDB) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
openDB(dbName).then(db => {
|
||||||
|
resolve(db.version)
|
||||||
|
db.close()
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
function upgradeDB(dbName, createList = null, deleteList = null) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
getDBversion(dbName).then(version => {
|
||||||
|
var idb = indexedDB.open(dbName, version + 1);
|
||||||
|
idb.onerror = (event) => reject("Error in opening IndexedDB");
|
||||||
|
idb.onupgradeneeded = (event) => {
|
||||||
|
let db = event.target.result;
|
||||||
|
if (createList instanceof Object) {
|
||||||
|
if (Array.isArray(createList)) {
|
||||||
|
let tmp = {}
|
||||||
|
createList.forEach(o => tmp[o] = {})
|
||||||
|
createList = tmp
|
||||||
|
}
|
||||||
|
for (let o in createList) {
|
||||||
|
let obs = db.createObjectStore(o, createList[o].options || {});
|
||||||
|
if (createList[o].indexes instanceof Object)
|
||||||
|
for (let i in createList[o].indexes)
|
||||||
|
obs.createIndex(i, i, createList[o].indexes || {});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (Array.isArray(deleteList))
|
||||||
|
deleteList.forEach(o => db.deleteObjectStore(o));
|
||||||
|
resolve('Database upgraded')
|
||||||
|
}
|
||||||
|
idb.onsuccess = (event) => event.target.result.close();
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
compactIDB.initDB = function (dbName, objectStores = {}) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (!(objectStores instanceof Object))
|
||||||
|
return reject('ObjectStores must be an object or array')
|
||||||
|
defaultDB = defaultDB || dbName;
|
||||||
|
var idb = indexedDB.open(dbName);
|
||||||
|
idb.onerror = (event) => reject("Error in opening IndexedDB");
|
||||||
|
idb.onsuccess = (event) => {
|
||||||
|
var db = event.target.result;
|
||||||
|
let cList = Object.values(db.objectStoreNames);
|
||||||
|
var obs = {},
|
||||||
|
a_obs = {},
|
||||||
|
d_obs = [];
|
||||||
|
if (!Array.isArray(objectStores))
|
||||||
|
var obs = objectStores
|
||||||
|
else
|
||||||
|
objectStores.forEach(o => obs[o] = {})
|
||||||
|
let nList = Object.keys(obs)
|
||||||
|
for (let o of nList)
|
||||||
|
if (!cList.includes(o))
|
||||||
|
a_obs[o] = obs[o]
|
||||||
|
for (let o of cList)
|
||||||
|
if (!nList.includes(o))
|
||||||
|
d_obs.push(o)
|
||||||
|
if (!Object.keys(a_obs).length && !d_obs.length)
|
||||||
|
resolve("Initiated IndexedDB");
|
||||||
|
else
|
||||||
|
upgradeDB(dbName, a_obs, d_obs)
|
||||||
|
.then(result => resolve(result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
db.close();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
const openDB = compactIDB.openDB = function (dbName = defaultDB) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
var idb = indexedDB.open(dbName);
|
||||||
|
idb.onerror = (event) => reject("Error in opening IndexedDB");
|
||||||
|
idb.onupgradeneeded = (event) => {
|
||||||
|
event.target.result.close();
|
||||||
|
deleteDB(dbName).then(_ => null).catch(_ => null).finally(_ => reject("Datebase not found"))
|
||||||
|
}
|
||||||
|
idb.onsuccess = (event) => resolve(event.target.result);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
const deleteDB = compactIDB.deleteDB = function (dbName = defaultDB) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
var deleteReq = indexedDB.deleteDatabase(dbName);;
|
||||||
|
deleteReq.onerror = (event) => reject("Error deleting database!");
|
||||||
|
deleteReq.onsuccess = (event) => resolve("Database deleted successfully");
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
compactIDB.writeData = function (obsName, data, key = false, dbName = defaultDB) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
openDB(dbName).then(db => {
|
||||||
|
var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
|
||||||
|
let writeReq = (key ? obs.put(data, key) : obs.put(data));
|
||||||
|
writeReq.onsuccess = (evt) => resolve(`Write data Successful`);
|
||||||
|
writeReq.onerror = (evt) => reject(
|
||||||
|
`Write data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
||||||
|
);
|
||||||
|
db.close();
|
||||||
|
}).catch(error => reject(error));
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
compactIDB.addData = function (obsName, data, key = false, dbName = defaultDB) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
openDB(dbName).then(db => {
|
||||||
|
var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
|
||||||
|
let addReq = (key ? obs.add(data, key) : obs.add(data));
|
||||||
|
addReq.onsuccess = (evt) => resolve(`Add data successful`);
|
||||||
|
addReq.onerror = (evt) => reject(
|
||||||
|
`Add data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
||||||
|
);
|
||||||
|
db.close();
|
||||||
|
}).catch(error => reject(error));
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
compactIDB.removeData = function (obsName, key, dbName = defaultDB) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
openDB(dbName).then(db => {
|
||||||
|
var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
|
||||||
|
let delReq = obs.delete(key);
|
||||||
|
delReq.onsuccess = (evt) => resolve(`Removed Data ${key}`);
|
||||||
|
delReq.onerror = (evt) => reject(
|
||||||
|
`Remove data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
||||||
|
);
|
||||||
|
db.close();
|
||||||
|
}).catch(error => reject(error));
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
compactIDB.clearData = function (obsName, dbName = defaultDB) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
openDB(dbName).then(db => {
|
||||||
|
var obs = db.transaction(obsName, "readwrite").objectStore(obsName);
|
||||||
|
let clearReq = obs.clear();
|
||||||
|
clearReq.onsuccess = (evt) => resolve(`Clear data Successful`);
|
||||||
|
clearReq.onerror = (evt) => reject(`Clear data Unsuccessful`);
|
||||||
|
db.close();
|
||||||
|
}).catch(error => reject(error));
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
compactIDB.readData = function (obsName, key, dbName = defaultDB) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
openDB(dbName).then(db => {
|
||||||
|
var obs = db.transaction(obsName, "readonly").objectStore(obsName);
|
||||||
|
let getReq = obs.get(key);
|
||||||
|
getReq.onsuccess = (evt) => resolve(evt.target.result);
|
||||||
|
getReq.onerror = (evt) => reject(
|
||||||
|
`Read data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
||||||
|
);
|
||||||
|
db.close();
|
||||||
|
}).catch(error => reject(error));
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
compactIDB.readAllData = function (obsName, dbName = defaultDB) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
openDB(dbName).then(db => {
|
||||||
|
var obs = db.transaction(obsName, "readonly").objectStore(obsName);
|
||||||
|
var tmpResult = {}
|
||||||
|
let curReq = obs.openCursor();
|
||||||
|
curReq.onsuccess = (evt) => {
|
||||||
|
var cursor = evt.target.result;
|
||||||
|
if (cursor) {
|
||||||
|
tmpResult[cursor.primaryKey] = cursor.value;
|
||||||
|
cursor.continue();
|
||||||
|
} else
|
||||||
|
resolve(tmpResult);
|
||||||
|
}
|
||||||
|
curReq.onerror = (evt) => reject(
|
||||||
|
`Read-All data unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`
|
||||||
|
);
|
||||||
|
db.close();
|
||||||
|
}).catch(error => reject(error));
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
/* compactIDB.searchData = function (obsName, options = {}, dbName = defaultDB) {
|
||||||
|
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
openDB(dbName).then(db => {
|
||||||
|
var obs = db.transaction(obsName, "readonly").objectStore(obsName);
|
||||||
|
var filteredResult = {}
|
||||||
|
let keyRange;
|
||||||
|
if(options.lowerKey!==null && options.upperKey!==null)
|
||||||
|
keyRange = IDBKeyRange.bound(options.lowerKey, options.upperKey);
|
||||||
|
else if(options.lowerKey!==null)
|
||||||
|
keyRange = IDBKeyRange.lowerBound(options.lowerKey);
|
||||||
|
else if (options.upperKey!==null)
|
||||||
|
keyRange = IDBKeyRange.upperBound(options.upperBound);
|
||||||
|
else if (options.atKey)
|
||||||
|
let curReq = obs.openCursor(keyRange, )
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}*/
|
||||||
|
|
||||||
|
compactIDB.searchData = function (obsName, options = {}, dbName = defaultDB) {
|
||||||
|
options.lowerKey = options.atKey || options.lowerKey || 0
|
||||||
|
options.upperKey = options.atKey || options.upperKey || false
|
||||||
|
options.patternEval = options.patternEval || ((k, v) => true);
|
||||||
|
options.limit = options.limit || false;
|
||||||
|
options.reverse = options.reverse || false;
|
||||||
|
options.lastOnly = options.lastOnly || false
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
openDB(dbName).then(db => {
|
||||||
|
var obs = db.transaction(obsName, "readonly").objectStore(obsName);
|
||||||
|
var filteredResult = {}
|
||||||
|
let curReq = obs.openCursor(
|
||||||
|
options.upperKey ? IDBKeyRange.bound(options.lowerKey, options.upperKey) : IDBKeyRange.lowerBound(options.lowerKey),
|
||||||
|
options.lastOnly || options.reverse ? "prev" : "next");
|
||||||
|
curReq.onsuccess = (evt) => {
|
||||||
|
var cursor = evt.target.result;
|
||||||
|
if (!cursor || (options.limit && options.limit <= Object.keys(filteredResult).length))
|
||||||
|
return resolve(filteredResult); //reached end of key list or limit reached
|
||||||
|
else if (options.patternEval(cursor.primaryKey, cursor.value)) {
|
||||||
|
filteredResult[cursor.primaryKey] = cursor.value;
|
||||||
|
options.lastOnly ? resolve(filteredResult) : cursor.continue();
|
||||||
|
} else
|
||||||
|
cursor.continue();
|
||||||
|
}
|
||||||
|
curReq.onerror = (evt) => reject(`Search unsuccessful [${evt.target.error.name}] ${evt.target.error.message}`);
|
||||||
|
db.close();
|
||||||
|
}).catch(error => reject(error));
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
})(window.compactIDB = {});
|
||||||
1044
floBlockchainAPI.js
Normal file
1044
floBlockchainAPI.js
Normal file
File diff suppressed because it is too large
Load Diff
1055
floCloudAPI.js
Normal file
1055
floCloudAPI.js
Normal file
File diff suppressed because it is too large
Load Diff
530
floCrypto.js
Normal file
530
floCrypto.js
Normal file
@ -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 = {});
|
||||||
845
floDapps.js
Normal file
845
floDapps.js
Normal file
@ -0,0 +1,845 @@
|
|||||||
|
(function (EXPORTS) { //floDapps v2.4.0
|
||||||
|
/* General functions for FLO Dapps*/
|
||||||
|
'use strict';
|
||||||
|
const floDapps = EXPORTS;
|
||||||
|
|
||||||
|
const DEFAULT = {
|
||||||
|
root: "floDapps",
|
||||||
|
application: floGlobals.application,
|
||||||
|
adminID: floGlobals.adminID
|
||||||
|
};
|
||||||
|
|
||||||
|
Object.defineProperties(floDapps, {
|
||||||
|
application: {
|
||||||
|
get: () => DEFAULT.application
|
||||||
|
},
|
||||||
|
adminID: {
|
||||||
|
get: () => DEFAULT.adminID
|
||||||
|
},
|
||||||
|
root: {
|
||||||
|
get: () => DEFAULT.root
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
var user_priv_raw, aes_key, user_priv_wrap; //private variable inside capsule
|
||||||
|
const raw_user = {
|
||||||
|
get private() {
|
||||||
|
if (!user_priv_raw)
|
||||||
|
throw "User not logged in";
|
||||||
|
return Crypto.AES.decrypt(user_priv_raw, aes_key);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var user_id, user_public, user_private;
|
||||||
|
const user = floDapps.user = {
|
||||||
|
get id() {
|
||||||
|
if (!user_id)
|
||||||
|
throw "User not logged in";
|
||||||
|
return user_id;
|
||||||
|
},
|
||||||
|
get public() {
|
||||||
|
if (!user_public)
|
||||||
|
throw "User not logged in";
|
||||||
|
return user_public;
|
||||||
|
},
|
||||||
|
get private() {
|
||||||
|
if (!user_private)
|
||||||
|
throw "User not logged in";
|
||||||
|
else if (user_private instanceof Function)
|
||||||
|
return user_private();
|
||||||
|
else
|
||||||
|
return Crypto.AES.decrypt(user_private, aes_key);
|
||||||
|
},
|
||||||
|
sign(message) {
|
||||||
|
return floCrypto.signData(message, raw_user.private);
|
||||||
|
},
|
||||||
|
decrypt(data) {
|
||||||
|
return floCrypto.decryptData(data, raw_user.private);
|
||||||
|
},
|
||||||
|
encipher(message) {
|
||||||
|
return Crypto.AES.encrypt(message, raw_user.private);
|
||||||
|
},
|
||||||
|
decipher(data) {
|
||||||
|
return Crypto.AES.decrypt(data, raw_user.private);
|
||||||
|
},
|
||||||
|
get db_name() {
|
||||||
|
return "floDapps#" + floCrypto.toFloID(user.id);
|
||||||
|
},
|
||||||
|
lock() {
|
||||||
|
user_private = user_priv_wrap;
|
||||||
|
},
|
||||||
|
async unlock() {
|
||||||
|
if (await user.private === raw_user.private)
|
||||||
|
user_private = user_priv_raw;
|
||||||
|
},
|
||||||
|
get_contact(id) {
|
||||||
|
if (!user.contacts)
|
||||||
|
throw "Contacts not available";
|
||||||
|
else if (user.contacts[id])
|
||||||
|
return user.contacts[id];
|
||||||
|
else {
|
||||||
|
let id_raw = floCrypto.decodeAddr(id).hex;
|
||||||
|
for (let i in user.contacts)
|
||||||
|
if (floCrypto.decodeAddr(i).hex == id_raw)
|
||||||
|
return user.contacts[i];
|
||||||
|
}
|
||||||
|
},
|
||||||
|
get_pubKey(id) {
|
||||||
|
if (!user.pubKeys)
|
||||||
|
throw "Contacts not available";
|
||||||
|
else if (user.pubKeys[id])
|
||||||
|
return user.pubKeys[id];
|
||||||
|
else {
|
||||||
|
let id_raw = floCrypto.decodeAddr(id).hex;
|
||||||
|
for (let i in user.pubKeys)
|
||||||
|
if (floCrypto.decodeAddr(i).hex == id_raw)
|
||||||
|
return user.pubKeys[i];
|
||||||
|
}
|
||||||
|
},
|
||||||
|
clear() {
|
||||||
|
user_id = user_public = user_private = undefined;
|
||||||
|
user_priv_raw = aes_key = undefined;
|
||||||
|
delete user.contacts;
|
||||||
|
delete user.pubKeys;
|
||||||
|
delete user.messages;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
Object.defineProperties(window, {
|
||||||
|
myFloID: {
|
||||||
|
get: () => {
|
||||||
|
try {
|
||||||
|
return user.id;
|
||||||
|
} catch {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
myUserID: {
|
||||||
|
get: () => {
|
||||||
|
try {
|
||||||
|
return user.id;
|
||||||
|
} catch {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
myPubKey: {
|
||||||
|
get: () => {
|
||||||
|
try {
|
||||||
|
return user.public;
|
||||||
|
} catch {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
},
|
||||||
|
myPrivKey: {
|
||||||
|
get: () => {
|
||||||
|
try {
|
||||||
|
return user.private;
|
||||||
|
} catch {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
var subAdmins, trustedIDs, settings;
|
||||||
|
Object.defineProperties(floGlobals, {
|
||||||
|
subAdmins: {
|
||||||
|
get: () => subAdmins
|
||||||
|
},
|
||||||
|
trustedIDs: {
|
||||||
|
get: () => trustedIDs
|
||||||
|
},
|
||||||
|
settings: {
|
||||||
|
get: () => settings
|
||||||
|
},
|
||||||
|
contacts: {
|
||||||
|
get: () => user.contacts
|
||||||
|
},
|
||||||
|
pubKeys: {
|
||||||
|
get: () => user.pubKeys
|
||||||
|
},
|
||||||
|
messages: {
|
||||||
|
get: () => user.messages
|
||||||
|
}
|
||||||
|
})
|
||||||
|
|
||||||
|
function initIndexedDB() {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
var obs_g = {
|
||||||
|
//general
|
||||||
|
lastTx: {},
|
||||||
|
//supernode (cloud list)
|
||||||
|
supernodes: {
|
||||||
|
indexes: {
|
||||||
|
uri: null,
|
||||||
|
pubKey: null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
var obs_a = {
|
||||||
|
//login credentials
|
||||||
|
credentials: {},
|
||||||
|
//for Dapps
|
||||||
|
subAdmins: {},
|
||||||
|
trustedIDs: {},
|
||||||
|
settings: {},
|
||||||
|
appObjects: {},
|
||||||
|
generalData: {},
|
||||||
|
lastVC: {}
|
||||||
|
}
|
||||||
|
//add other given objectStores
|
||||||
|
initIndexedDB.appObs = initIndexedDB.appObs || {}
|
||||||
|
for (let o in initIndexedDB.appObs)
|
||||||
|
if (!(o in obs_a))
|
||||||
|
obs_a[o] = initIndexedDB.appObs[o]
|
||||||
|
Promise.all([
|
||||||
|
compactIDB.initDB(DEFAULT.application, obs_a),
|
||||||
|
compactIDB.initDB(DEFAULT.root, obs_g)
|
||||||
|
]).then(result => {
|
||||||
|
compactIDB.setDefaultDB(DEFAULT.application)
|
||||||
|
resolve("IndexedDB App Storage Initated Successfully")
|
||||||
|
}).catch(error => reject(error));
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
function initUserDB() {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
var obs = {
|
||||||
|
contacts: {},
|
||||||
|
pubKeys: {},
|
||||||
|
messages: {}
|
||||||
|
}
|
||||||
|
compactIDB.initDB(user.db_name, obs).then(result => {
|
||||||
|
resolve("UserDB Initated Successfully")
|
||||||
|
}).catch(error => reject('Init userDB failed'));
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
function loadUserDB() {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
var loadData = ["contacts", "pubKeys", "messages"]
|
||||||
|
var promises = []
|
||||||
|
for (var i = 0; i < loadData.length; i++)
|
||||||
|
promises[i] = compactIDB.readAllData(loadData[i], user.db_name)
|
||||||
|
Promise.all(promises).then(results => {
|
||||||
|
for (var i = 0; i < loadData.length; i++)
|
||||||
|
user[loadData[i]] = results[i]
|
||||||
|
resolve("Loaded Data from userDB")
|
||||||
|
}).catch(error => reject('Load userDB failed'))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
const startUpOptions = {
|
||||||
|
cloud: true,
|
||||||
|
app_config: true,
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.startUpOptions = {
|
||||||
|
set app_config(val) {
|
||||||
|
if (val === true || val === false)
|
||||||
|
startUpOptions.app_config = val;
|
||||||
|
},
|
||||||
|
get app_config() { return startUpOptions.app_config },
|
||||||
|
|
||||||
|
set cloud(val) {
|
||||||
|
if (val === true || val === false)
|
||||||
|
startUpOptions.cloud = val;
|
||||||
|
},
|
||||||
|
get cloud() { return startUpOptions.cloud },
|
||||||
|
}
|
||||||
|
|
||||||
|
const startUpFunctions = [];
|
||||||
|
|
||||||
|
startUpFunctions.push(function readSupernodeListFromAPI() {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (!startUpOptions.cloud)
|
||||||
|
return resolve("No cloud for this app");
|
||||||
|
compactIDB.readData("lastTx", floCloudAPI.SNStorageID, DEFAULT.root).then(lastTx => {
|
||||||
|
var query_options = { sentOnly: true, pattern: floCloudAPI.SNStorageName };
|
||||||
|
if (typeof lastTx == 'number') //lastTx is tx count (*backward support)
|
||||||
|
query_options.ignoreOld = lastTx;
|
||||||
|
else if (typeof lastTx == 'string') //lastTx is txid of last tx
|
||||||
|
query_options.after = lastTx;
|
||||||
|
//fetch data from flosight
|
||||||
|
floBlockchainAPI.readData(floCloudAPI.SNStorageID, query_options).then(result => {
|
||||||
|
for (var i = result.data.length - 1; i >= 0; i--) {
|
||||||
|
var content = JSON.parse(result.data[i])[floCloudAPI.SNStorageName];
|
||||||
|
for (let sn in content.removeNodes)
|
||||||
|
compactIDB.removeData("supernodes", sn, DEFAULT.root);
|
||||||
|
for (let sn in content.newNodes)
|
||||||
|
compactIDB.writeData("supernodes", content.newNodes[sn], sn, DEFAULT.root);
|
||||||
|
for (let sn in content.updateNodes)
|
||||||
|
compactIDB.readData("supernodes", sn, DEFAULT.root).then(r => {
|
||||||
|
r = r || {}
|
||||||
|
r.uri = content.updateNodes[sn];
|
||||||
|
compactIDB.writeData("supernodes", r, sn, DEFAULT.root);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
compactIDB.writeData("lastTx", result.lastItem, floCloudAPI.SNStorageID, DEFAULT.root);
|
||||||
|
compactIDB.readAllData("supernodes", DEFAULT.root).then(nodes => {
|
||||||
|
floCloudAPI.init(nodes)
|
||||||
|
.then(result => resolve("Loaded Supernode list\n" + result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
})
|
||||||
|
})
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
});
|
||||||
|
|
||||||
|
startUpFunctions.push(function readAppConfigFromAPI() {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (!startUpOptions.app_config)
|
||||||
|
return resolve("No configs for this app");
|
||||||
|
compactIDB.readData("lastTx", `${DEFAULT.application}|${DEFAULT.adminID}`, DEFAULT.root).then(lastTx => {
|
||||||
|
var query_options = { sentOnly: true, pattern: DEFAULT.application };
|
||||||
|
if (typeof lastTx == 'number') //lastTx is tx count (*backward support)
|
||||||
|
query_options.ignoreOld = lastTx;
|
||||||
|
else if (typeof lastTx == 'string') //lastTx is txid of last tx
|
||||||
|
query_options.after = lastTx;
|
||||||
|
//fetch data from flosight
|
||||||
|
floBlockchainAPI.readData(DEFAULT.adminID, query_options).then(result => {
|
||||||
|
for (var i = result.data.length - 1; i >= 0; i--) {
|
||||||
|
var content = JSON.parse(result.data[i])[DEFAULT.application];
|
||||||
|
if (!content || typeof content !== "object")
|
||||||
|
continue;
|
||||||
|
if (Array.isArray(content.removeSubAdmin))
|
||||||
|
for (var j = 0; j < content.removeSubAdmin.length; j++)
|
||||||
|
compactIDB.removeData("subAdmins", content.removeSubAdmin[j]);
|
||||||
|
if (Array.isArray(content.addSubAdmin))
|
||||||
|
for (var k = 0; k < content.addSubAdmin.length; k++)
|
||||||
|
compactIDB.writeData("subAdmins", true, content.addSubAdmin[k]);
|
||||||
|
if (Array.isArray(content.removeTrustedID))
|
||||||
|
for (var j = 0; j < content.removeTrustedID.length; j++)
|
||||||
|
compactIDB.removeData("trustedIDs", content.removeTrustedID[j]);
|
||||||
|
if (Array.isArray(content.addTrustedID))
|
||||||
|
for (var k = 0; k < content.addTrustedID.length; k++)
|
||||||
|
compactIDB.writeData("trustedIDs", true, content.addTrustedID[k]);
|
||||||
|
if (content.settings)
|
||||||
|
for (let l in content.settings)
|
||||||
|
compactIDB.writeData("settings", content.settings[l], l)
|
||||||
|
}
|
||||||
|
compactIDB.writeData("lastTx", result.lastItem, `${DEFAULT.application}|${DEFAULT.adminID}`, DEFAULT.root);
|
||||||
|
compactIDB.readAllData("subAdmins").then(result => {
|
||||||
|
subAdmins = Object.keys(result);
|
||||||
|
compactIDB.readAllData("trustedIDs").then(result => {
|
||||||
|
trustedIDs = Object.keys(result);
|
||||||
|
compactIDB.readAllData("settings").then(result => {
|
||||||
|
settings = result;
|
||||||
|
resolve("Read app configuration from blockchain");
|
||||||
|
})
|
||||||
|
})
|
||||||
|
})
|
||||||
|
})
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
});
|
||||||
|
|
||||||
|
startUpFunctions.push(function loadDataFromAppIDB() {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (!startUpOptions.cloud)
|
||||||
|
return resolve("No cloud for this app");
|
||||||
|
var loadData = ["appObjects", "generalData", "lastVC"]
|
||||||
|
var promises = []
|
||||||
|
for (var i = 0; i < loadData.length; i++)
|
||||||
|
promises[i] = compactIDB.readAllData(loadData[i])
|
||||||
|
Promise.all(promises).then(results => {
|
||||||
|
for (var i = 0; i < loadData.length; i++)
|
||||||
|
floGlobals[loadData[i]] = results[i]
|
||||||
|
resolve("Loaded Data from app IDB")
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
});
|
||||||
|
|
||||||
|
var keyInput = type => new Promise((resolve, reject) => {
|
||||||
|
let inputVal = prompt(`Enter ${type}: `)
|
||||||
|
if (inputVal === null)
|
||||||
|
reject(null)
|
||||||
|
else
|
||||||
|
resolve(inputVal)
|
||||||
|
});
|
||||||
|
|
||||||
|
function getCredentials() {
|
||||||
|
|
||||||
|
const readSharesFromIDB = indexArr => new Promise((resolve, reject) => {
|
||||||
|
var promises = []
|
||||||
|
for (var i = 0; i < indexArr.length; i++)
|
||||||
|
promises.push(compactIDB.readData('credentials', indexArr[i]))
|
||||||
|
Promise.all(promises).then(shares => {
|
||||||
|
var secret = floCrypto.retrieveShamirSecret(shares)
|
||||||
|
if (secret)
|
||||||
|
resolve(secret)
|
||||||
|
else
|
||||||
|
reject("Shares are insufficient or incorrect")
|
||||||
|
}).catch(error => {
|
||||||
|
clearCredentials();
|
||||||
|
location.reload();
|
||||||
|
})
|
||||||
|
});
|
||||||
|
|
||||||
|
const writeSharesToIDB = (shares, i = 0, resultIndexes = []) => new Promise(resolve => {
|
||||||
|
if (i >= shares.length)
|
||||||
|
return resolve(resultIndexes)
|
||||||
|
var n = floCrypto.randInt(0, 100000)
|
||||||
|
compactIDB.addData("credentials", shares[i], n).then(res => {
|
||||||
|
resultIndexes.push(n)
|
||||||
|
writeSharesToIDB(shares, i + 1, resultIndexes)
|
||||||
|
.then(result => resolve(result))
|
||||||
|
}).catch(error => {
|
||||||
|
writeSharesToIDB(shares, i, resultIndexes)
|
||||||
|
.then(result => resolve(result))
|
||||||
|
})
|
||||||
|
});
|
||||||
|
|
||||||
|
const getPrivateKeyCredentials = () => new Promise((resolve, reject) => {
|
||||||
|
var indexArr = localStorage.getItem(`${DEFAULT.application}#privKey`)
|
||||||
|
if (indexArr) {
|
||||||
|
readSharesFromIDB(JSON.parse(indexArr))
|
||||||
|
.then(result => resolve(result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
} else {
|
||||||
|
var privKey;
|
||||||
|
keyInput("PRIVATE_KEY").then(result => {
|
||||||
|
if (!result)
|
||||||
|
return reject("Empty Private Key")
|
||||||
|
var floID = floCrypto.getFloID(result)
|
||||||
|
if (!floID || !floCrypto.validateFloID(floID))
|
||||||
|
return reject("Invalid Private Key")
|
||||||
|
privKey = result;
|
||||||
|
}).catch(error => {
|
||||||
|
console.log(error, "Generating Random Keys")
|
||||||
|
privKey = floCrypto.generateNewID().privKey
|
||||||
|
}).finally(_ => {
|
||||||
|
if (!privKey)
|
||||||
|
return;
|
||||||
|
var threshold = floCrypto.randInt(10, 20)
|
||||||
|
var shares = floCrypto.createShamirsSecretShares(privKey, threshold, threshold)
|
||||||
|
writeSharesToIDB(shares).then(resultIndexes => {
|
||||||
|
//store index keys in localStorage
|
||||||
|
localStorage.setItem(`${DEFAULT.application}#privKey`, JSON.stringify(resultIndexes))
|
||||||
|
//also add a dummy privatekey to the IDB
|
||||||
|
var randomPrivKey = floCrypto.generateNewID().privKey
|
||||||
|
var randomThreshold = floCrypto.randInt(10, 20)
|
||||||
|
var randomShares = floCrypto.createShamirsSecretShares(randomPrivKey, randomThreshold, randomThreshold)
|
||||||
|
writeSharesToIDB(randomShares)
|
||||||
|
//resolve private Key
|
||||||
|
resolve(privKey)
|
||||||
|
})
|
||||||
|
})
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
const checkIfPinRequired = key => new Promise((resolve, reject) => {
|
||||||
|
if (key.length == 52)
|
||||||
|
resolve(key)
|
||||||
|
else {
|
||||||
|
keyInput("PIN/Password").then(pwd => {
|
||||||
|
try {
|
||||||
|
let privKey = Crypto.AES.decrypt(key, pwd);
|
||||||
|
resolve(privKey)
|
||||||
|
} catch (error) {
|
||||||
|
reject("Access Denied: Incorrect PIN/Password")
|
||||||
|
}
|
||||||
|
}).catch(error => reject("Access Denied: PIN/Password required"))
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
getPrivateKeyCredentials().then(key => {
|
||||||
|
checkIfPinRequired(key).then(privKey => {
|
||||||
|
try {
|
||||||
|
user_public = floCrypto.getPubKeyHex(privKey);
|
||||||
|
user_id = floCrypto.getAddress(privKey);
|
||||||
|
if (startUpOptions.cloud)
|
||||||
|
floCloudAPI.user(user_id, privKey); //Set user for floCloudAPI
|
||||||
|
user_priv_wrap = () => checkIfPinRequired(key);
|
||||||
|
let n = floCrypto.randInt(12, 20);
|
||||||
|
aes_key = floCrypto.randString(n);
|
||||||
|
user_priv_raw = Crypto.AES.encrypt(privKey, aes_key);
|
||||||
|
user_private = user_priv_wrap;
|
||||||
|
resolve('Login Credentials loaded successful')
|
||||||
|
} catch (error) {
|
||||||
|
console.log(error)
|
||||||
|
reject("Corrupted Private Key")
|
||||||
|
}
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
var startUpLog = (status, log) => status ? console.log(log) : console.error(log);
|
||||||
|
|
||||||
|
const callStartUpFunction = i => new Promise((resolve, reject) => {
|
||||||
|
startUpFunctions[i]().then(result => {
|
||||||
|
callStartUpFunction.completed += 1;
|
||||||
|
startUpLog(true, `${result}\nCompleted ${callStartUpFunction.completed}/${callStartUpFunction.total} Startup functions`)
|
||||||
|
resolve(true)
|
||||||
|
}).catch(error => {
|
||||||
|
callStartUpFunction.failed += 1;
|
||||||
|
startUpLog(false, `${error}\nFailed ${callStartUpFunction.failed}/${callStartUpFunction.total} Startup functions`)
|
||||||
|
reject(false)
|
||||||
|
})
|
||||||
|
});
|
||||||
|
|
||||||
|
var _midFunction;
|
||||||
|
const midStartUp = () => new Promise((res, rej) => {
|
||||||
|
if (_midFunction instanceof Function) {
|
||||||
|
_midFunction()
|
||||||
|
.then(r => res("Mid startup function completed"))
|
||||||
|
.catch(e => rej("Mid startup function failed"))
|
||||||
|
} else
|
||||||
|
res("No mid startup function")
|
||||||
|
});
|
||||||
|
|
||||||
|
const callAndLog = p => new Promise((res, rej) => {
|
||||||
|
p.then(r => {
|
||||||
|
startUpLog(true, r)
|
||||||
|
res(r)
|
||||||
|
}).catch(e => {
|
||||||
|
startUpLog(false, e)
|
||||||
|
rej(e)
|
||||||
|
})
|
||||||
|
});
|
||||||
|
|
||||||
|
floDapps.launchStartUp = function () {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
initIndexedDB().then(log => {
|
||||||
|
console.log(log)
|
||||||
|
callStartUpFunction.total = startUpFunctions.length;
|
||||||
|
callStartUpFunction.completed = 0;
|
||||||
|
callStartUpFunction.failed = 0;
|
||||||
|
let p1 = new Promise((res, rej) => {
|
||||||
|
Promise.all(startUpFunctions.map((f, i) => callStartUpFunction(i))).then(r => {
|
||||||
|
callAndLog(midStartUp())
|
||||||
|
.then(r => res(true))
|
||||||
|
.catch(e => rej(false))
|
||||||
|
})
|
||||||
|
});
|
||||||
|
let p2 = new Promise((res, rej) => {
|
||||||
|
callAndLog(getCredentials()).then(r => {
|
||||||
|
callAndLog(initUserDB()).then(r => {
|
||||||
|
callAndLog(loadUserDB())
|
||||||
|
.then(r => res(true))
|
||||||
|
.catch(e => rej(false))
|
||||||
|
}).catch(e => rej(false))
|
||||||
|
}).catch(e => rej(false))
|
||||||
|
})
|
||||||
|
Promise.all([p1, p2])
|
||||||
|
.then(r => resolve('App Startup finished successful'))
|
||||||
|
.catch(e => reject('App Startup failed'))
|
||||||
|
}).catch(error => {
|
||||||
|
startUpLog(false, error);
|
||||||
|
reject("App database initiation failed")
|
||||||
|
})
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.addStartUpFunction = fn => fn instanceof Function && !startUpFunctions.includes(fn) ? startUpFunctions.push(fn) : false;
|
||||||
|
|
||||||
|
floDapps.setMidStartup = fn => fn instanceof Function ? _midFunction = fn : false;
|
||||||
|
|
||||||
|
floDapps.setCustomStartupLogger = fn => fn instanceof Function ? startUpLog = fn : false;
|
||||||
|
|
||||||
|
floDapps.setCustomPrivKeyInput = fn => fn instanceof Function ? keyInput = fn : false;
|
||||||
|
|
||||||
|
floDapps.setAppObjectStores = appObs => initIndexedDB.appObs = appObs;
|
||||||
|
|
||||||
|
floDapps.storeContact = function (floID, name) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (!floCrypto.validateAddr(floID))
|
||||||
|
return reject("Invalid floID!")
|
||||||
|
compactIDB.writeData("contacts", name, floID, user.db_name).then(result => {
|
||||||
|
user.contacts[floID] = name;
|
||||||
|
resolve("Contact stored")
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.storePubKey = function (floID, pubKey) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (floID in user.pubKeys)
|
||||||
|
return resolve("pubKey already stored")
|
||||||
|
if (!floCrypto.validateAddr(floID))
|
||||||
|
return reject("Invalid floID!")
|
||||||
|
if (!floCrypto.verifyPubKey(pubKey, floID))
|
||||||
|
return reject("Incorrect pubKey")
|
||||||
|
compactIDB.writeData("pubKeys", pubKey, floID, user.db_name).then(result => {
|
||||||
|
user.pubKeys[floID] = pubKey;
|
||||||
|
resolve("pubKey stored")
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.sendMessage = function (floID, message) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
let options = {
|
||||||
|
receiverID: floID,
|
||||||
|
application: DEFAULT.root,
|
||||||
|
comment: DEFAULT.application
|
||||||
|
}
|
||||||
|
if (floID in user.pubKeys)
|
||||||
|
message = floCrypto.encryptData(JSON.stringify(message), user.pubKeys[floID])
|
||||||
|
floCloudAPI.sendApplicationData(message, "Message", options)
|
||||||
|
.then(result => resolve(result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.requestInbox = function (callback) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
let lastVC = Object.keys(user.messages).sort().pop()
|
||||||
|
let options = {
|
||||||
|
receiverID: user.id,
|
||||||
|
application: DEFAULT.root,
|
||||||
|
lowerVectorClock: lastVC + 1
|
||||||
|
}
|
||||||
|
let privKey = raw_user.private;
|
||||||
|
options.callback = (d, e) => {
|
||||||
|
for (let v in d) {
|
||||||
|
try {
|
||||||
|
if (d[v].message instanceof Object && "secret" in d[v].message)
|
||||||
|
d[v].message = floCrypto.decryptData(d[v].message, privKey)
|
||||||
|
} catch (error) { }
|
||||||
|
compactIDB.writeData("messages", d[v], v, user.db_name)
|
||||||
|
user.messages[v] = d[v]
|
||||||
|
}
|
||||||
|
if (callback instanceof Function)
|
||||||
|
callback(d, e)
|
||||||
|
}
|
||||||
|
floCloudAPI.requestApplicationData("Message", options)
|
||||||
|
.then(result => resolve(result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.manageAppConfig = function (adminPrivKey, addList, rmList, settings) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (!startUpOptions.app_config)
|
||||||
|
return reject("No configs for this app");
|
||||||
|
if (!Array.isArray(addList) || !addList.length) addList = undefined;
|
||||||
|
if (!Array.isArray(rmList) || !rmList.length) rmList = undefined;
|
||||||
|
if (!settings || typeof settings !== "object" || !Object.keys(settings).length) settings = undefined;
|
||||||
|
if (!addList && !rmList && !settings)
|
||||||
|
return reject("No configuration change")
|
||||||
|
var floData = {
|
||||||
|
[DEFAULT.application]: {
|
||||||
|
addSubAdmin: addList,
|
||||||
|
removeSubAdmin: rmList,
|
||||||
|
settings: settings
|
||||||
|
}
|
||||||
|
}
|
||||||
|
var floID = floCrypto.getFloID(adminPrivKey)
|
||||||
|
if (floID != DEFAULT.adminID)
|
||||||
|
reject('Access Denied for Admin privilege')
|
||||||
|
else
|
||||||
|
floBlockchainAPI.writeData(floID, JSON.stringify(floData), adminPrivKey)
|
||||||
|
.then(result => resolve(['Updated App Configuration', result]))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.manageAppTrustedIDs = function (adminPrivKey, addList, rmList) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
if (!startUpOptions.app_config)
|
||||||
|
return reject("No configs for this app");
|
||||||
|
if (!Array.isArray(addList) || !addList.length) addList = undefined;
|
||||||
|
if (!Array.isArray(rmList) || !rmList.length) rmList = undefined;
|
||||||
|
if (!addList && !rmList)
|
||||||
|
return reject("No change in list")
|
||||||
|
var floData = {
|
||||||
|
[DEFAULT.application]: {
|
||||||
|
addTrustedID: addList,
|
||||||
|
removeTrustedID: rmList
|
||||||
|
}
|
||||||
|
}
|
||||||
|
var floID = floCrypto.getFloID(adminPrivKey)
|
||||||
|
if (floID != DEFAULT.adminID)
|
||||||
|
reject('Access Denied for Admin privilege')
|
||||||
|
else
|
||||||
|
floBlockchainAPI.writeData(floID, JSON.stringify(floData), adminPrivKey)
|
||||||
|
.then(result => resolve(['Updated App Configuration', result]))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
const clearCredentials = floDapps.clearCredentials = function () {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
compactIDB.clearData('credentials', DEFAULT.application).then(result => {
|
||||||
|
localStorage.removeItem(`${DEFAULT.application}#privKey`);
|
||||||
|
user.clear();
|
||||||
|
resolve("privKey credentials deleted!")
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.deleteUserData = function (credentials = false) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
let p = []
|
||||||
|
p.push(compactIDB.deleteDB(user.db_name))
|
||||||
|
if (credentials)
|
||||||
|
p.push(clearCredentials())
|
||||||
|
Promise.all(p)
|
||||||
|
.then(result => resolve('User database(local) deleted'))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.deleteAppData = function () {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
compactIDB.deleteDB(DEFAULT.application).then(result => {
|
||||||
|
localStorage.removeItem(`${DEFAULT.application}#privKey`)
|
||||||
|
user.clear();
|
||||||
|
compactIDB.removeData('lastTx', `${DEFAULT.application}|${DEFAULT.adminID}`, DEFAULT.root)
|
||||||
|
.then(result => resolve("App database(local) deleted"))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.securePrivKey = function (pwd) {
|
||||||
|
return new Promise(async (resolve, reject) => {
|
||||||
|
let indexArr = localStorage.getItem(`${DEFAULT.application}#privKey`)
|
||||||
|
if (!indexArr)
|
||||||
|
return reject("PrivKey not found");
|
||||||
|
indexArr = JSON.parse(indexArr)
|
||||||
|
let encryptedKey = Crypto.AES.encrypt(await user.private, pwd);
|
||||||
|
let threshold = indexArr.length;
|
||||||
|
let shares = floCrypto.createShamirsSecretShares(encryptedKey, threshold, threshold)
|
||||||
|
let promises = [];
|
||||||
|
let overwriteFn = (share, index) =>
|
||||||
|
compactIDB.writeData("credentials", share, index, DEFAULT.application);
|
||||||
|
for (var i = 0; i < threshold; i++)
|
||||||
|
promises.push(overwriteFn(shares[i], indexArr[i]));
|
||||||
|
Promise.all(promises)
|
||||||
|
.then(results => resolve("Private Key Secured"))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
floDapps.verifyPin = function (pin = null) {
|
||||||
|
const readSharesFromIDB = function (indexArr) {
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
var promises = []
|
||||||
|
for (var i = 0; i < indexArr.length; i++)
|
||||||
|
promises.push(compactIDB.readData('credentials', indexArr[i]))
|
||||||
|
Promise.all(promises).then(shares => {
|
||||||
|
var secret = floCrypto.retrieveShamirSecret(shares)
|
||||||
|
console.info(shares, secret)
|
||||||
|
if (secret)
|
||||||
|
resolve(secret)
|
||||||
|
else
|
||||||
|
reject("Shares are insufficient or incorrect")
|
||||||
|
}).catch(error => {
|
||||||
|
clearCredentials();
|
||||||
|
location.reload();
|
||||||
|
})
|
||||||
|
})
|
||||||
|
}
|
||||||
|
return new Promise((resolve, reject) => {
|
||||||
|
var indexArr = localStorage.getItem(`${DEFAULT.application}#privKey`)
|
||||||
|
console.info(indexArr)
|
||||||
|
if (!indexArr)
|
||||||
|
reject('No login credentials found')
|
||||||
|
readSharesFromIDB(JSON.parse(indexArr)).then(key => {
|
||||||
|
if (key.length == 52) {
|
||||||
|
if (pin === null)
|
||||||
|
resolve("Private key not secured")
|
||||||
|
else
|
||||||
|
reject("Private key not secured")
|
||||||
|
} else {
|
||||||
|
if (pin === null)
|
||||||
|
return reject("PIN/Password required")
|
||||||
|
try {
|
||||||
|
let privKey = Crypto.AES.decrypt(key, pin);
|
||||||
|
resolve("PIN/Password verified")
|
||||||
|
} catch (error) {
|
||||||
|
reject("Incorrect PIN/Password")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
const getNextGeneralData = floDapps.getNextGeneralData = function (type, vectorClock = null, options = {}) {
|
||||||
|
var fk = floCloudAPI.util.filterKey(type, options)
|
||||||
|
vectorClock = vectorClock || getNextGeneralData[fk] || '0';
|
||||||
|
var filteredResult = {}
|
||||||
|
if (floGlobals.generalData[fk]) {
|
||||||
|
for (let d in floGlobals.generalData[fk])
|
||||||
|
if (d > vectorClock)
|
||||||
|
filteredResult[d] = JSON.parse(JSON.stringify(floGlobals.generalData[fk][d]))
|
||||||
|
} else if (options.comment) {
|
||||||
|
let comment = options.comment;
|
||||||
|
delete options.comment;
|
||||||
|
let fk = floCloudAPI.util.filterKey(type, options);
|
||||||
|
for (let d in floGlobals.generalData[fk])
|
||||||
|
if (d > vectorClock && floGlobals.generalData[fk][d].comment == comment)
|
||||||
|
filteredResult[d] = JSON.parse(JSON.stringify(floGlobals.generalData[fk][d]))
|
||||||
|
}
|
||||||
|
if (options.decrypt) {
|
||||||
|
let decryptionKey = (options.decrypt === true) ? raw_user.private : options.decrypt;
|
||||||
|
if (!Array.isArray(decryptionKey))
|
||||||
|
decryptionKey = [decryptionKey];
|
||||||
|
for (let f in filteredResult) {
|
||||||
|
let data = filteredResult[f]
|
||||||
|
try {
|
||||||
|
if (data.message instanceof Object && "secret" in data.message) {
|
||||||
|
for (let key of decryptionKey) {
|
||||||
|
try {
|
||||||
|
let tmp = floCrypto.decryptData(data.message, key)
|
||||||
|
data.message = JSON.parse(tmp)
|
||||||
|
break;
|
||||||
|
} catch (error) { }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} catch (error) { }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
getNextGeneralData[fk] = Object.keys(filteredResult).sort().pop();
|
||||||
|
return filteredResult;
|
||||||
|
}
|
||||||
|
|
||||||
|
const syncData = floDapps.syncData = {};
|
||||||
|
|
||||||
|
syncData.oldDevice = () => new Promise((resolve, reject) => {
|
||||||
|
let sync = {
|
||||||
|
contacts: user.contacts,
|
||||||
|
pubKeys: user.pubKeys,
|
||||||
|
messages: user.messages
|
||||||
|
}
|
||||||
|
let message = Crypto.AES.encrypt(JSON.stringify(sync), raw_user.private)
|
||||||
|
let options = {
|
||||||
|
receiverID: user.id,
|
||||||
|
application: DEFAULT.root
|
||||||
|
}
|
||||||
|
floCloudAPI.sendApplicationData(message, "syncData", options)
|
||||||
|
.then(result => resolve(result))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
});
|
||||||
|
|
||||||
|
syncData.newDevice = () => new Promise((resolve, reject) => {
|
||||||
|
var options = {
|
||||||
|
receiverID: user.id,
|
||||||
|
senderID: user.id,
|
||||||
|
application: DEFAULT.root,
|
||||||
|
mostRecent: true,
|
||||||
|
}
|
||||||
|
floCloudAPI.requestApplicationData("syncData", options).then(response => {
|
||||||
|
let vc = Object.keys(response).sort().pop()
|
||||||
|
let sync = JSON.parse(Crypto.AES.decrypt(response[vc].message, raw_user.private))
|
||||||
|
let promises = []
|
||||||
|
let store = (key, val, obs) => promises.push(compactIDB.writeData(obs, val, key, user.db_name));
|
||||||
|
["contacts", "pubKeys", "messages"].forEach(c => {
|
||||||
|
for (let i in sync[c]) {
|
||||||
|
store(i, sync[c][i], c)
|
||||||
|
user[c][i] = sync[c][i]
|
||||||
|
}
|
||||||
|
})
|
||||||
|
Promise.all(promises)
|
||||||
|
.then(results => resolve("Sync data successful"))
|
||||||
|
.catch(error => reject(error))
|
||||||
|
}).catch(error => reject(error))
|
||||||
|
});
|
||||||
|
})('object' === typeof module ? module.exports : window.floDapps = {});
|
||||||
166
floTokenAPI.js
Normal file
166
floTokenAPI.js
Normal file
@ -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 = {});
|
||||||
57
index.html
Normal file
57
index.html
Normal file
@ -0,0 +1,57 @@
|
|||||||
|
<!DOCTYPE html>
|
||||||
|
<html lang="en">
|
||||||
|
|
||||||
|
<head>
|
||||||
|
<title>FLO Standard Operators</title>
|
||||||
|
<script id="floGlobals">
|
||||||
|
/* Constants for FLO blockchain operations !!Make sure to add this at beginning!! */
|
||||||
|
const floGlobals = {
|
||||||
|
blockchain: "FLO",
|
||||||
|
adminID: "FKAEdnPfjXLHSYwrXQu377ugN4tXU7VGdf",
|
||||||
|
application: "TEST_MODE",
|
||||||
|
}
|
||||||
|
</script>
|
||||||
|
<script>
|
||||||
|
(function () {
|
||||||
|
const urlSearchParams = new URLSearchParams(window.location.search);
|
||||||
|
const params = Object.fromEntries(urlSearchParams.entries());
|
||||||
|
if ('testnet' in params) {
|
||||||
|
floGlobals.blockchain = "FLO_TEST";
|
||||||
|
floGlobals.adminID = "oKKHdK5uYAJ52U91sYsWhnEaEAAhZP779B";
|
||||||
|
floGlobals.application = "TEST_MODE_testnet";
|
||||||
|
}
|
||||||
|
|
||||||
|
if ('quick' in params)
|
||||||
|
window.quick = true;
|
||||||
|
|
||||||
|
})();
|
||||||
|
</script>
|
||||||
|
<script src="lib.js"></script>
|
||||||
|
<script src="floCrypto.js"></script>
|
||||||
|
<script src="btcOperator.js"></script>
|
||||||
|
<script src="floBlockchainAPI.js"></script>
|
||||||
|
<script src="floTokenAPI.js"></script>
|
||||||
|
<script src="compactIDB.js"></script>
|
||||||
|
<script src="floCloudAPI.js"></script>
|
||||||
|
<script src="floDapps.js"></script>
|
||||||
|
<script id="onLoadStartUp">
|
||||||
|
function onLoadStartUp() {
|
||||||
|
if (window.quick) return;
|
||||||
|
//floDapps.addStartUpFunction('Sample', Promised Function)
|
||||||
|
//floDapps.setAppObjectStores({sampleObs1:{}, sampleObs2:{options{autoIncrement:true, keyPath:'SampleKey'}, Indexes:{sampleIndex:{}}}})
|
||||||
|
//floDapps.setCustomPrivKeyInput( () => { FUNCTION BODY *must resolve private key* } )
|
||||||
|
floDapps.launchStartUp().then(result => {
|
||||||
|
console.log(result)
|
||||||
|
alert(`Welcome FLO_ID: ${myFloID}`)
|
||||||
|
//App functions....
|
||||||
|
}).catch(error => console.error(error))
|
||||||
|
}
|
||||||
|
</script>
|
||||||
|
</head>
|
||||||
|
|
||||||
|
<body onload="onLoadStartUp()">
|
||||||
|
TEST_MODE
|
||||||
|
(use console)
|
||||||
|
</body>
|
||||||
|
|
||||||
|
</html>
|
||||||
Loading…
Reference in New Issue
Block a user