GitHub - Dopeboyz23/National-bank-

https://bitcoincore.org/bin/bitcoin-core-27.1/SHA256SUMS?utm_source=tokenpocketconstructed using ⍴ (reshape): 4 3 ⍴ ⍳5 ⍝ 0 1 2 ⍝ 3 4 0 ⍝ 1 2 3 ⍝ 4 0 1

⍝ Single-argument ⍴ gives you the dimensions back: ⍴ 4 3 ⍴ ⍳5 ⍝ 4 3

⍝ Values can be stored using ←. Let's calculate the mean ⍝ value of a vector of numbers: A ← 10 60 55 23

⍝ Sum of elements of A (/ is reduce): +/A ⍝ 148

⍝ Length of A: ⍴A ⍝ 4

⍝ Mean: (+/A) ÷ (⍴A) ⍝ 37

⍝ We can define this as a function using {} and ⍵: mean ← {(+/⍵)÷⍴⍵} mean A ⍝ 37 // Jest Snapshot v1, https://goo.gl/fbAQLP

exports[Badge component applestore renders correctly 1] = ` <a class="sc-htpNat mBQkt" color="blue600" href="https://itunes.apple.com/us/app/blockchain-bitcoin-wallet/id493253309" target="_blank"

`;

exports[Badge component googleplay renders correctly 1] = ` <a class="sc-htpNat mBQkt" color="blue600" href="https://play.google.com/store/apps/details?id=piuk.blockchain.android" target="_blank"

`;{ "label": "BTC DeFi Wallet", "archived": false, "default_derivation": "bech32", "derivations": [ { "type": "legacy", "purpose": 44, "xpriv": "xprv9yL1ousLjQQzGNBAYykaT8J3U626NV6zbLYkRv8rvUDpY4f1RnrvAXQneGXC9UNuNvGXX4j6oHBK5KiV2hKevRxY5ntis212oxjEL11ysuG", "xpub": "xpub6CKNDRQEZmyHUrFdf1HapGEn27ramwpqxZUMEJYUUokoQrz9yLBAiKjGVWDuiCT39udj1r3whqQN89Tar5KrojH8oqSy7ytzJKW8gwmhwD3", "address_labels": [ { "index": 0, "label": "labeled_address" } ], "cache": { "receiveAccount": "xpub6F41z8MqNcJMvKQgAd5QE2QYo32cocYigWp1D8726ykMmaMqvtqLkvuL1NqGuUJvU3aWyJaV2J4V6sD7Pv59J3tYGZdYRSx8gU7EG8ZuPSY", "changeAccount": "xpub6F41z8MqNcJMwmeUExdCv7UXvYBEgQB29SWq9jyxuZ7WefmSTWcwXB6NRAJkGCkB3L1Eu4ttzWnPVKZ6REissrQ4i6p8gTi9j5YwDLxmZ8p" } } ] }{ "guid": "50dae286-e42e-4d67-8419-d5dcc563746c", "sharedKey": "8a260b2b-5257-4357-ac56-7a7efca323ea", "double_encryption": false, "metadataHDNode": "xprv9tygGQP8be7uzNm5Czuy41juTK9pUKnWyZtDxgbmSEcCYa9VdvvtSknEyiKitqqm2TMv14NjXPQ68XLwSdH6Scc5GwXoZ31yRZZysxhVGU7", "options": { "pbkdf2_iterations": 5000, "fee_per_kb": 10000, "html5_notifications": false, "logout_time": 600000 }, "address_book": [], "tx_notes": {}, "tx_names": [], "keys": [ { "addr": "19XmKRY66VnUn5irHAafyoTfiwFuGLUxKF", "priv": "38W3vsxt246Lhawvz81y2HQVnsJrBUX87jSTUUnixPsE", "tag": 0, "label": "", "created_time": 1492721419269, "created_device_name": "javascript_web", "created_device_version": "3.0" }, { "addr": "14mQxLtEagsS8gYsdWJbzthFFuPDqDgtxQ", "priv": "BpD2ZuJjZ8PJPpDX6ZmsKFsXHkL7XV3dt385zghMfF6C", "tag": 0, "label": "labeled_imported", "created_time": 1492721432222, "created_device_name": "javascript_web", "created_device_version": "3.0" }, { "addr": "1JD73aGSdeqKUjJ4ntP4eCyUiuZ3ogJE1u", "priv": null, "tag": 0, "label": "", "created_time": 1492721461228, "created_device_name": "javascript_web", "created_device_version": "3.0" } ], "hd_wallets": [ { "seed_hex": "6a4d9524d413fdf69ca1b5664d1d6db0", "passphrase": "", "mnemonic_verified": false, "default_account_idx": 0, "accounts": [ { "label": "BTC DeFi Wallet", "archived": false, "xpriv": "xprv9yL1ousLjQQzGNBAYykaT8J3U626NV6zbLYkRv8rvUDpY4f1RnrvAXQneGXC9UNuNvGXX4j6oHBK5KiV2hKevRxY5ntis212oxjEL11ysuG", "xpub": "xpub6CKNDRQEZmyHUrFdf1HapGEn27ramwpqxZUMEJYUUokoQrz9yLBAiKjGVWDuiCT39udj1r3whqQN89Tar5KrojH8oqSy7ytzJKW8gwmhwD3", "address_labels": [ { "index": 0, "label": "labeled_address" } ], "cache": { "receiveAccount": "xpub6F41z8MqNcJMvKQgAd5QE2QYo32cocYigWp1D8726ykMmaMqvtqLkvuL1NqGuUJvU3aWyJaV2J4V6sD7Pv59J3tYGZdYRSx8gU7EG8ZuPSY", "changeAccount": "xpub6F41z8MqNcJMwmeUExdCv7UXvYBEgQB29SWq9jyxuZ7WefmSTWcwXB6NRAJkGCkB3L1Eu4ttzWnPVKZ6REissrQ4i6p8gTi9j5YwDLxmZ8p" } } ] } ]import { is, map, pipe } from 'ramda' import { view } from 'ramda-lens'

import * as HDWallet from './HDWallet' import List from './List'

export class HDWalletList extends List {}

export const isHDWalletList = is(HDWalletList)

// we never add multiple hdwallets // select always by default hdwallet 0 export const hdwallet = HDWalletList.define(0)

export const selectHDWallet = view(hdwallet)

export const toJS = pipe(HDWalletList.guard, (wList) => { return map(HDWallet.toJS, wList).toArray() })

export const fromJS = (wallets) => { if (is(HDWalletList, wallets)) { return wallets } const ws = wallets || [] return new HDWalletList(map(HDWallet.fromJS, ws)) }

export const createNew = ( guid, password, sharedKey, mnemonic, firstAccountName = 'DeFi Wallet', nAccounts = 1 ) => fromJS([HDWallet.js(firstAccountName, mnemonic, undefined, nAccounts, undefined)])

export const reviver = (jsObject) => { return new HDWalletList(jsObject) }import BIP39 from 'bip39-light' import * as Bitcoin from 'bitcoinjs-lib' import Base58 from 'bs58' import Either from 'data.either' import Maybe from 'data.maybe' import Task from 'data.task' import memoize from 'fast-memoize' import { __, compose, concat, curry, flip, is, isNil, map, pipe, split } from 'ramda' import { over, set, traversed, traverseOf, view } from 'ramda-lens'

import { keyPairToAddress } from '../utils/btc' import * as crypto from '../walletCrypto' import * as Address from './Address' import * as AddressBook from './AddressBook' import * as AddressLabelMap from './AddressLabelMap' import * as AddressMap from './AddressMap' import * as Derivation from './Derivation' import * as DerivationList from './DerivationList' import * as HDAccount from './HDAccount' import * as HDAccountList from './HDAccountList' import * as HDWallet from './HDWallet' import * as HDWalletList from './HDWalletList' import * as Options from './Options' import * as TXNames from './TXNames' import * as TXNotes from './TXNotes' import Type from './Type' import { shift, shiftIProp } from './util'

/* Wallet :: { guid :: String sharedKey :: String double_encryption :: Bool metadataHDNode :: String options :: Options address_book :: [{ [addr]: String }] tx_notes :: [{ txhash: String }] tx_names :: [] addresses :: {Address} hd_wallets :: [HDWallet] } */

export class Wallet extends Type {}

export const isWallet = is(Wallet)

export const guid = Wallet.define('guid') export const sharedKey = Wallet.define('sharedKey') export const doubleEncryption = Wallet.define('double_encryption') export const metadataHDNode = Wallet.define('metadataHDNode') export const options = Wallet.define('options') export const addresses = Wallet.define('addresses') export const dpasswordhash = Wallet.define('dpasswordhash') export const hdWallets = Wallet.define('hd_wallets') export const txNotes = Wallet.define('tx_notes') export const txNames = Wallet.define('tx_names') export const addressBook = Wallet.define('address_book')

export const hdwallet = compose(hdWallets, HDWalletList.hdwallet) export const accounts = compose(hdwallet, HDWallet.accounts)

export const selectGuid = view(guid) export const selectSharedKey = view(sharedKey) export const selectOptions = view(options) export const selectmetadataHDNode = view(metadataHDNode) export const selectTxNotes = view(txNotes) export const selectTxNames = view(txNames) export const selectAddressBook = view(addressBook) export const selectIterations = compose(Options.selectPbkdf2Iterations, selectOptions)

export const selectHdWallets = view(hdWallets) export const selectAddresses = compose(AddressMap.selectSpendable, view(addresses)) export const isDoubleEncrypted = compose(Boolean, view(doubleEncryption))

export const selectAddrContext = compose( AddressMap.selectContext, AddressMap.selectActive, selectAddresses ) export const selectXpubsContextGrouped = compose( HDWallet.selectContextGrouped, HDWalletList.selectHDWallet, selectHdWallets ) export const selectXpubsContext = compose( HDWallet.selectContext, HDWalletList.selectHDWallet, selectHdWallets ) export const selectSpendableAddrContext = compose( AddressMap.selectContext, AddressMap.selectSpendable, selectAddresses ) export const selectContextGrouped = (w) => ({ addresses: selectAddrContext(w).toJS(), ...selectXpubsContextGrouped(w) }) export const selectContext = (w) => selectAddrContext(w).concat(selectXpubsContext(w)) export const selectHDAccounts = (w) => selectHdWallets(w).flatMap(HDWallet.selectAccounts) export const selectSpendableContext = (w) => selectSpendableAddrContext(w).concat(selectXpubsContext(w))

const shiftWallet = compose(shiftIProp('keys', 'addresses'), shift)

export const fromJS = (x) => { if (is(Wallet, x)) { return x } const walletCons = compose( over(hdWallets, HDWalletList.fromJS), over(addresses, AddressMap.fromJS), over(options, Options.fromJS), over(txNames, TXNames.fromJS), over(txNotes, TXNotes.fromJS), over(addressBook, AddressBook.fromJS), (w) => shiftWallet(w).forward() ) return walletCons(new Wallet(x)) }

export const toJS = pipe(Wallet.guard, (wallet) => { const walletDecons = compose( (w) => shiftWallet(w).back(), over(options, Options.toJS), over(txNotes, TXNotes.toJS), over(txNames, TXNames.toJS), over(hdWallets, HDWalletList.toJS), over(addresses, AddressMap.toJS), over(addressBook, AddressBook.toJS) ) return walletDecons(wallet).toJS() })

export const reviver = (jsObject) => { return new Wallet(jsObject) }

export const spendableActiveAddresses = (wallet) => { const isSpendableActive = (a) => !Address.isWatchOnly(a) && !Address.isArchived(a) return selectAddresses(wallet) .filter(isSpendableActive) .map((a) => a.addr) }

// fromEncryptedPayload :: String -> String -> Task Error Wallet export const fromEncryptedPayload = curry((password, payload) => { return Task.of(payload).chain(crypto.decryptWallet(password)).map(fromJS) })

// toEncryptedPayload :: String -> Wallet -> Task Error String export const toEncryptedPayload = curry((password, pbkdf2Iterations, version, wallet) => { Wallet.guard(wallet) return compose( crypto.encryptWallet(__, password, pbkdf2Iterations, version), JSON.stringify, toJS )(wallet) })

// isValidSecondPwd :: String -> Wallet -> Bool export const isValidSecondPwd = curry((password, wallet) => { if (isDoubleEncrypted(wallet)) { if (!is(String, password)) { return false } // 5000 is fallback for v1 wallets that are missing // Pbkdf2 Iterations in the inner wrapper of JSON const iter = selectIterations(wallet) || 5000 const sk = view(sharedKey, wallet) const storedHash = view(dpasswordhash, wallet) const computedHash = crypto.hashNTimes(iter, concat(sk, password)).toString('hex') return storedHash === computedHash } return true })

// getAddress :: String -> Wallet -> Maybe Address export const getAddress = curry((addr, wallet) => { const address = AddressMap.selectAddress(addr, wallet.addresses) return Maybe.fromNullable(address) })

// getAccount :: Integer -> Wallet -> Maybe HDAccount export const getAccount = curry((index, wallet) => compose( Maybe.fromNullable, selectHdWallets )(wallet) .chain(compose(Maybe.fromNullable, HDWalletList.selectHDWallet)) .chain(compose(Maybe.fromNullable, HDWallet.selectAccount(index))) )

// applyCipher :: Wallet -> String -> Cipher -> a -> Task Error a const applyCipher = curry((wallet, password, f, value) => { const it = selectIterations(wallet) const sk = view(sharedKey, wallet) switch (true) { case !isDoubleEncrypted(wallet): return Task.of(value) case isValidSecondPwd(password, wallet): return f(it, sk, password, value) default: return Task.rejected(new Error('INVALID_SECOND_PASSWORD')) } })

// importLegacyAddress :: Wallet -> String -> Number -> String? -> { Network, Api } -> Task Error Wallet export const importLegacyAddress = curry( (wallet, key, createdTime, password, bipPass, label, { api, network }) => { const checkIfExists = (address) => getAddress(address.addr, wallet) .map((existing) => Address.isWatchOnly(existing) && !Address.isWatchOnly(address) ? Task.of(existing) : Task.rejected(new Error('present_in_wallet')) ) .map((aE) => aE.map(set(Address.priv, address.priv))) .getOrElse(Task.of(address))

const appendAddress = (address) =>
  over(addresses, (as) => as.set(address.addr, address), wallet)

return Address.fromString(key, createdTime, label, bipPass, {
  api,
  network
})
  .chain(checkIfExists)
  .chain(applyCipher(wallet, password, Address.encrypt))
  .map(appendAddress)

} )

// upgradeToV4 :: String -> String -> Network -> Wallet -> Task Error Wallet export const upgradeToV4 = curry((seedHex, password, network, wallet) => { const encryptDerivation = applyCipher(wallet, password, Derivation.encrypt) const upgradeAccount = (account) => { const migratedAccount = HDAccount.fromJS(HDAccount.toJS(account), account.index) const addDerivationToAccount = (derivation) => over(HDAccount.derivations, (derivations) => derivations.push(derivation), migratedAccount) const derivation = HDWallet.generateDerivation( HDAccount.DEFAULT_DERIVATION_TYPE, HDAccount.DEFAULT_DERIVATION_PURPOSE, migratedAccount.index, network, seedHex )

return encryptDerivation(derivation).map(addDerivationToAccount)

}

const traverseAllAccounts = compose(hdwallet, HDWallet.accounts, traversed)

return traverseOf(traverseAllAccounts, Task.of, upgradeAccount, wallet) })

// newHDWallet :: String -> String? -> Wallet -> Task Error Wallet export const newHDWallet = curry((mnemonic, password, wallet) => { const hdWallet = HDWallet.createNew(mnemonic) const appendHdWallet = curry((w, hd) => over(hdWallets, (list) => list.push(hd), w)) return applyCipher(wallet, password, HDWallet.encrypt, hdWallet).map(appendHdWallet(wallet)) })

// newHDAccount :: String -> String? -> Wallet -> Task Error Wallet export const newHDAccount = curry((label, password, network, payloadV, wallet) => { const hdWallet = HDWalletList.selectHDWallet(selectHdWallets(wallet)) const index = hdWallet.accounts.size const appendAccount = curry((w, account) => { const accountsLens = compose(hdWallets, HDWalletList.hdwallet, HDWallet.accounts) const accountWithIndex = set(HDAccount.index, index, account) return over(accountsLens, (accounts) => accounts.push(accountWithIndex), w) }) return applyCipher(wallet, password, flip(crypto.decryptSecPass), hdWallet.seedHex) .map(HDWallet.generateAccount(index, label, network, payloadV)) .chain(applyCipher(wallet, password, HDAccount.encrypt)) .map(appendAccount(wallet)) })

// upgradeToV3 :: String -> String -> String? -> Task Error Wallet export const upgradeToV3 = curry((mnemonic, firstLabel, password, network, wallet) => { return newHDWallet(mnemonic, password, wallet).chain( newHDAccount(firstLabel, password, network, 3) ) })

// setLegacyAddressLabel :: String -> String -> Wallet -> Wallet export const setLegacyAddressLabel = curry((address, label, wallet) => { const addressLens = compose(addresses, AddressMap.address(address)) const eitherW = Either.try(over(addressLens, Address.setLabel(label)))(wallet) return eitherW.getOrElse(wallet) })

// getPrivateKeyForAddress :: Wallet -> String? -> String -> Task Error String export const getPrivateKeyForAddress = curry((wallet, password, addr) => { const address = AddressMap.selectAddress(addr, selectAddresses(wallet)) return applyCipher(wallet, password, Address.decrypt, address).map((a) => a.priv) })

// setLegacyAddressLabel :: String -> Bool -> Wallet -> Wallet export const setAddressArchived = curry((address, archived, wallet) => { const addressLens = compose(addresses, AddressMap.address(address)) return over(addressLens, Address.setArchived(archived), wallet) })

// deleteLegacyAddress :: String -> Wallet -> Wallet export const deleteLegacyAddress = curry((address, wallet) => { return over(addresses, AddressMap.deleteAddress(address), wallet) })

// deleteHdAddressLabel :: Number -> Number -> String -> Wallet -> Wallet export const deleteHdAddressLabel = curry((accountIdx, addressIdx, derivationType, wallet) => { const lens = compose( hdWallets, HDWalletList.hdwallet, HDWallet.accounts, HDAccountList.account(accountIdx), HDAccount.derivations, DerivationList.derivationOfType(derivationType), Derivation.addressLabels ) const eitherW = Either.try(over(lens, AddressLabelMap.deleteLabel(addressIdx)))(wallet) return eitherW.getOrElse(wallet) })

// setHdAddressLabel :: Number -> Number -> String -> Wallet -> Wallet export const setHdAddressLabel = curry((accountIdx, addressIdx, derivationType, label, wallet) => { const lens = compose( hdWallets, HDWalletList.hdwallet, HDWallet.accounts, HDAccountList.account(accountIdx), HDAccount.derivations, DerivationList.derivationOfType(derivationType), Derivation.addressLabels ) const eitherW = Either.try(over(lens, AddressLabelMap.setLabel(addressIdx, label)))(wallet) return eitherW.getOrElse(wallet) })

// setAccountLabel :: Number -> String -> Wallet -> Wallet export const setAccountLabel = curry((accountIdx, label, wallet) => { const lens = compose(accounts, HDAccountList.account(accountIdx), HDAccount.label) return set(lens, label, wallet) })

// setAccountArchived :: Number -> Bool -> Wallet -> Wallet export const setAccountArchived = curry((index, archived, wallet) => { const lens = compose(accounts, HDAccountList.account(index), HDAccount.archived) return set(lens, archived, wallet) })

// setAccountDerivations :: Number -> Derivations -> Wallet -> Wallet export const setAccountDerivations = curry((index, derivations, wallet) => { const lens = compose(accounts, HDAccountList.account(index), HDAccount.derivations) return set(lens, derivations, wallet) })

// setDefaultDerivation :: Number -> derivationType -> Wallet -> Wallet export const setDefaultDerivation = curry((index, derivationType, wallet) => { const lens = compose(accounts, HDAccountList.account(index), HDAccount.defaultDerivation) return set(lens, derivationType, wallet) })

// setDefaultAccountIdx :: Number -> Wallet -> Wallet export const setDefaultAccountIdx = curry((index, wallet) => { return set(compose(hdwallet, HDWallet.defaultAccountIdx), index, wallet) }) export const setTxNote = curry((txHash, txNote, wallet) => { return set(compose(txNotes, TXNotes.note(txHash)), txNote, wallet) })

// traversePrivValues :: Monad m => (a -> m a) -> (String -> m String) -> Wallet -> m Wallet export const traverseKeyValues = curry((of, f, wallet) => { const trAddr = traverseOf(compose(addresses, traversed, Address.priv), of, f) const trSeed = traverseOf(compose(hdWallets, traversed, HDWallet.seedHex), of, f) const trXpriv = traverseOf(compose(hdWallets, traversed, HDWallet.secretsLens), of, f) return of(wallet).chain(trAddr).chain(trSeed).chain(trXpriv) })

// encryptMonadic :: Monad m => (a -> m a) -> (String -> m String) -> String -> Wallet -> m Wallet export const encryptMonadic = curry((of, cipher, password, wallet) => { if (isDoubleEncrypted(wallet)) { return of(wallet) } const iter = selectIterations(wallet) const enc = cipher(wallet.sharedKey, iter, password) const hash = crypto.hashNTimes(iter, concat(wallet.sharedKey, password)).toString('hex') const setFlag = over(doubleEncryption, () => true) const setHash = over(dpasswordhash, () => hash) return traverseKeyValues(of, enc, wallet).map(compose(setHash, setFlag)) })

// encrypt :: String -> Wallet -> Task Error Wallet export const encrypt = encryptMonadic(Task.of, crypto.encryptSecPass)

// decryptMonadic :: Monad m => (a -> m a) -> (String -> m String) -> (String -> m Wallet) -> String -> Wallet -> m Wallet export const decryptMonadic = curry((of, cipher, verify, password, wallet) => { if (isDoubleEncrypted(wallet)) { const iter = selectIterations(wallet) const dec = cipher(wallet.sharedKey, iter, password)

const setFlag = over(doubleEncryption, () => false)
const setHash = over(Wallet.lens, (x) => x.delete('dpasswordhash'))

return verify(password, wallet).chain(traverseKeyValues(of, dec)).map(compose(setHash, setFlag))

} return of(wallet) })

// validateSecondPwd :: (a -> m a) -> (a -> m b) -> String -> Wallet export const validateSecondPwd = curry((pass, fail, password, wallet) => isValidSecondPwd(password, wallet) ? pass(wallet) : fail(new Error('INVALID_SECOND_PASSWORD')) )

// decrypt :: String -> Wallet -> Task Error Wallet export const decrypt = decryptMonadic( Task.of, crypto.decryptSecPass, validateSecondPwd(Task.of, Task.rejected) )

const _derivePrivateKey = (network, xpriv, chain, index) => Bitcoin.bip32.fromBase58(xpriv, network).derive(chain).derive(index)

export const derivePrivateKey = memoize(_derivePrivateKey)

export const getHDPrivateKeyWIF = curry((coin, secondPassword, network, wallet) => { const type = coin.type() === 'P2PKH' ? 'legacy' : 'bech32' const [accId, chain, index] = map(parseInt, split('/', coin.path)) if (isNil(accId) || isNil(chain) || isNil(index)) { return Task.rejected('WRONG_PATH_KEY') } const xpriv = compose( HDAccount.selectXpriv(type), HDWallet.selectAccount(accId), HDWalletList.selectHDWallet, selectHdWallets )(wallet) if (isDoubleEncrypted(wallet)) { return validateSecondPwd(Task.of, Task.rejected)(secondPassword, wallet) .chain(() => crypto.decryptSecPass( selectSharedKey(wallet), selectIterations(wallet), secondPassword, xpriv ) ) .map((xp) => { const node = derivePrivateKey(network, xp, chain, index) return Bitcoin.ECPair.fromPrivateKey(node.privateKey).toWIF() }) } return Task.of(xpriv).map((xp) => { const node = derivePrivateKey(network, xp, chain, index) return Bitcoin.ECPair.fromPrivateKey(node.privateKey).toWIF() }) })

// TODO :: find a proper place for that const fromBase58toKey = (string, address, network) => { const key = Bitcoin.ECPair.fromPrivateKey(Base58.decode(string)) if (keyPairToAddress(key) === address) return key key.compressed = !key.compressed return key }

export const getLegacyPrivateKey = curry((address, secondPassword, network, wallet) => { const priv = compose( Address.selectPriv, AddressMap.selectAddress(address), selectAddresses )(wallet) if (isDoubleEncrypted(wallet)) { return validateSecondPwd(Task.of, Task.rejected)(secondPassword, wallet) .chain(() => crypto.decryptSecPass( selectSharedKey(wallet), selectIterations(wallet), secondPassword, priv ) ) .map((pk) => fromBase58toKey(pk, address, network)) } return Task.of(priv).map((pk) => fromBase58toKey(pk, address, network)) })

export const getLegacyPrivateKeyWIF = curry((address, secondPassword, network, wallet) => { return getLegacyPrivateKey(address, secondPassword, network, wallet).map((ecpair) => ecpair.toWIF() ) })

// getSeedHex :: String -> Wallet -> Task Error String export const getSeedHex = curry((secondPassword, wallet) => { const seedHex = compose( HDWallet.selectSeedHex, HDWalletList.selectHDWallet, selectHdWallets )(wallet) if (isDoubleEncrypted(wallet)) { return validateSecondPwd(Task.of, Task.rejected)(secondPassword, wallet).chain(() => crypto.decryptSecPass( selectSharedKey(wallet), selectIterations(wallet), secondPassword, seedHex ) ) } return Task.of(seedHex) })

// getMnemonic :: String -> Wallet -> Task Error String export const getMnemonic = curry((secondPassword, wallet) => { const eitherToTask = (e) => e.fold(Task.rejected, Task.of) const entropyToMnemonic = compose(eitherToTask, Either.try(BIP39.entropyToMnemonic)) const seedHex = getSeedHex(secondPassword, wallet) return seedHex.chain(entropyToMnemonic) })

export const js = (guid, sharedKey, label, mnemonic, nAccounts, network) => ({ address_book: [], double_encryption: false, guid, hd_wallets: [HDWallet.js(label, mnemonic, nAccounts, network)], keys: [], options: Options.js(), sharedKey, tx_names: [], tx_notes: {} })export type ImportedAddrType = { addr: string created_device_name: string created_device_version: string created_time: number info: { address: string final_balance: number n_tx: number total_received: number total_sent: number } label?: string priv: null | string tag: number }import { ECPair } from 'bitcoinjs-lib' import Base58 from 'bs58' import Either from 'data.either' import Task from 'data.task' import { compose, curry, equals, is, isNil, not, pipe } from 'ramda' import { set, traverseOf, view } from 'ramda-lens'

import * as utils from '../utils' import * as crypto from '../walletCrypto' import { parseBIP38toECPair } from '../walletCrypto/importExport' import Type from './Type' import { iToJS } from './util'

const eitherToTask = (e) => e.fold(Task.rejected, Task.of) const wrapPromiseInTask = (fP) => new Task((reject, resolve) => fP().then(resolve, reject))

/* Address :: { priv :: String addr :: String label :: String tag :: Number created_time :: Number created_device_name :: String created_device_version :: String } */

export class Address extends Type {}

export const isAddress = is(Address)

export const priv = Address.define('priv') export const addr = Address.define('addr') export const label = Address.define('label') export const tag = Address.define('tag') export const createdTime = Address.define('created_time') export const createdDeviceName = Address.define('created_device_name') export const createdDeviceVersion = Address.define('created_device_version')

export const selectPriv = view(priv) export const selectAddr = view(addr) export const selectLabel = view(label) export const selectTag = view(tag) export const selectCreatedTime = view(createdTime) export const selectCreatedDeviceName = view(createdDeviceName) export const selectCreatedDeviceVersion = view(createdDeviceVersion)

export const isArchived = compose(equals(2), view(tag)) export const isActive = compose(not, isArchived) export const isWatchOnly = compose(isNil, view(priv)) export const isNotWatchOnly = compose(not, isWatchOnly)

export const fromJS = (x) => (is(Address, x) ? x : new Address(x))

export const toJS = pipe(Address.guard, iToJS)

export const reviver = (jsObject) => { return new Address(jsObject) }

// setLabel :: String -> Address -> Address export const setLabel = set(label)

// archive :: Address -> Address export const archive = set(tag, 2)

// unArchive :: Address -> Address export const unArchive = set(tag, 0)

export const setArchived = curry((archived, address) => set(tag, archived ? 2 : 0, address))

// encrypt :: Number -> String -> String -> Address -> Task Error Address export const encrypt = curry((iterations, sharedKey, password, address) => { const cipher = crypto.encryptSecPass(sharedKey, iterations, password) return traverseOf(priv, Task.of, cipher, address) })

// decrypt :: Number -> String -> String -> Address -> Task Error Address export const decrypt = curry((iterations, sharedKey, password, address) => { const cipher = crypto.decryptSecPass(sharedKey, iterations, password) return traverseOf(priv, Task.of, cipher, address) })

// importAddress :: String|ECPair -> String? -> Number -> Network -> Address export const importAddress = (key, createdTime, label, network) => { const object = { addr: null, created_device_name: 'wallet-web', created_device_version: 'v4', created_time: createdTime, label, priv: null, tag: 0 }

switch (true) { case utils.btc.isValidBtcAddress(key, network): object.addr = key object.priv = null break case utils.btc.isKey(key): object.addr = utils.btc.keyPairToAddress(key) object.priv = Base58.encode(key.privateKey) break case utils.btc.isValidBtcPrivateKey(key, network): key = ECPair.fromWIF(key, network) object.addr = utils.btc.keyPairToAddress(key) object.priv = Base58.encode(key.privateKey) break default: throw new Error('unsupported_address_import_format') }

return fromJS(object) }

// fromString :: String -> Number -> String? -> String? -> { Network, API } -> Task Error Address export const fromString = (keyOrAddr, createdTime, label, bipPass, { api, network }) => { if (utils.btc.isValidBtcAddress(keyOrAddr)) { return Task.of(importAddress(keyOrAddr, createdTime, label, network)) } const format = utils.btc.detectPrivateKeyFormat(keyOrAddr) const okFormats = ['base58', 'base64', 'hex', 'mini', 'sipa', 'compsipa'] if (format === 'bip38') { if (bipPass == null || bipPass === '') { return Task.rejected(new Error('needs_bip38')) } const tryParseBIP38toECPair = Either.try(parseBIP38toECPair) const keyE = tryParseBIP38toECPair(keyOrAddr, bipPass, network) return eitherToTask(keyE).map((key) => importAddress(key, createdTime, label, network)) } if (format === 'mini' || format === 'base58') { let key try { key = utils.btc.privateKeyStringToKey(keyOrAddr, format) } catch (e) { return Task.rejected(e) } key.compressed = true const cad = utils.btc.keyPairToAddress(key) key.compressed = false const uad = utils.btc.keyPairToAddress(key) return wrapPromiseInTask(() => api.getBalances([cad, uad])).fold( () => { key.compressed = true return importAddress(key, createdTime, label, network) }, (o) => { const compBalance = o[cad].final_balance const ucompBalance = o[uad].final_balance key.compressed = !(compBalance === 0 && ucompBalance > 0) return importAddress(key, createdTime, label, network) } ) } if (okFormats.indexOf(format) > -1) { const key = utils.btc.privateKeyStringToKey(keyOrAddr, format) return Task.of(importAddress(key, createdTime, label, network)) } return Task.rejected(new Error('unknown_key_format')) }import { map } from 'ramda'

import * as Coin from './coin.js' import * as cs from './index'

describe('Coin Selection', () => { describe('byte sizes', () => { const legacyInput = { type: () => 'P2PKH' } const legacyOutput = { type: () => 'P2PKH' } const segwitInput = { type: () => 'P2WPKH' } const segwitOutput = { type: () => 'P2WPKH' }

describe('0x0 transactions', () => {
  it('should return the right transaction size (empty tx)', () => {
    // No witness => 10 vbytes
    expect(cs.transactionBytes([], [])).toEqual(10)
  })
})

describe('1x1 transactions', () => {
  it('should return the right transaction size (1 P2PKH, 1 P2PKH)', () => {
    // 10 + 148 + 34 = 192
    expect(cs.transactionBytes([legacyInput], [legacyOutput])).toEqual(192)
  })
  it('should return the right transaction size (1 P2PKH, 1 P2WPKH)', () => {
    // 10 + 148 + 31 = 189
    expect(cs.transactionBytes([legacyInput], [segwitOutput])).toEqual(189)
  })
  it('should return the right transaction size (1 P2WPKH, 1 P2PKH)', () => {
    // 10.75 + 67.75 + 34 = 112.5
    expect(cs.transactionBytes([segwitInput], [legacyOutput])).toEqual(112.5)
  })
  it('should return the right transaction size (1 P2WPKH, 1 P2WPKH)', () => {
    // 10.75 + 67.75 + 31 = 109.5
    expect(cs.transactionBytes([segwitInput], [segwitOutput])).toEqual(109.5)
  })
})

describe('1x2 transactions', () => {
  it('should return the right transaction size (1 P2PKH, 2 P2PKH)', () => {
    // 10 + 148 + 34*2 = 226
    expect(cs.transactionBytes([legacyInput], [legacyOutput, legacyOutput])).toEqual(226)
  })
  it('should return the right transaction size (1 P2PKH, 2 P2WPKH)', () => {
    // 10 + 148 + 31*2 = 220
    expect(cs.transactionBytes([legacyInput], [segwitOutput, segwitOutput])).toEqual(220)
  })
  it('should return the right transaction size (1 P2PKH, 1 P2PKH + 1 P2WPKH)', () => {
    // 10 + 148 + 31 + 34 = 223
    expect(cs.transactionBytes([legacyInput], [legacyOutput, segwitOutput])).toEqual(223)
  })
  it('should return the right transaction size (1 P2WPKH, 2 P2PKH)', () => {
    // 10.75 + 67.75 + 34*2 = 146.5
    expect(cs.transactionBytes([segwitInput], [legacyOutput, legacyOutput])).toEqual(146.5)
  })
  it('should return the right transaction size (1 P2WPKH, 2 P2WPKH)', () => {
    // 10.75 + 67.75 + 31*2 = 140.5
    expect(cs.transactionBytes([segwitInput], [segwitOutput, segwitOutput])).toEqual(140.5)
  })
  it('should return the right transaction size (1 P2WPKH, 1 P2PKH + 1 P2WPKH)', () => {
    // 10.75 + 67.75 + 31 + 34 = 143.5
    expect(cs.transactionBytes([segwitInput], [legacyOutput, segwitOutput])).toEqual(143.5)
  })
})

describe('2x1 transactions', () => {
  it('should return the right transaction size (2 P2PKH, 1 P2PKH)', () => {
    // 10 + 148*2 + 34 = 340
    expect(cs.transactionBytes([legacyInput, legacyInput], [legacyOutput])).toEqual(340)
  })
  it('should return the right transaction size (2 P2PKH, 1 P2WPKH)', () => {
    // 10 + 148*2 + 31 = 337
    expect(cs.transactionBytes([legacyInput, legacyInput], [segwitOutput])).toEqual(337)
  })
  it('should return the right transaction size (1 P2PKH + P2WPKH, 1 P2PKH)', () => {
    // 10.75 + 67.75 + 148 + 34 = 260.5
    expect(cs.transactionBytes([legacyInput, segwitInput], [legacyOutput])).toEqual(260.5)
  })
  it('should return the right transaction size (2 P2WPKH, 1 P2PKH)', () => {
    // 10.75 + 67.75*2 + 34 = 180.25
    expect(cs.transactionBytes([segwitInput, segwitInput], [legacyOutput])).toEqual(180.25)
  })
  it('should return the right transaction size (2 P2WPKH, 1 P2WPKH)', () => {
    // 10.75 + 67.75*2 + 31 = 177.25
    expect(cs.transactionBytes([segwitInput, segwitInput], [segwitOutput])).toEqual(177.25)
  })
  it('should return the right transaction size (1 P2PKH + 1 P2WPKH, 1 P2WPKH)', () => {
    // 10.75 + 67.75 + 148 + 31 = 257.5
    expect(cs.transactionBytes([legacyInput, segwitInput], [segwitOutput])).toEqual(257.5)
  })
})

describe('2x2 transactions', () => {
  it('should return the right transaction size (2 P2PKH, 2 P2PKH)', () => {
    // 10 + 148*2 + 34*2 = 374
    expect(
      cs.transactionBytes([legacyInput, legacyInput], [legacyOutput, legacyOutput])
    ).toEqual(374)
  })
  it('should return the right transaction size (2 P2PKH, 2 P2WPKH)', () => {
    // 10 + 148*2 + 31*2 = 368
    expect(
      cs.transactionBytes([legacyInput, legacyInput], [segwitOutput, segwitOutput])
    ).toEqual(368)
  })
  it('should return the right transaction size (1 P2PKH + 1 P2WPKH, 2 P2PKH)', () => {
    // 10.75 + 148 + 67.75 + 34*2 = 294.5
    expect(
      cs.transactionBytes([legacyInput, segwitInput], [legacyOutput, legacyOutput])
    ).toEqual(294.5)
  })
  it('should return the right transaction size (2 P2PKH, 1 P2PKH + 1 P2WPKH)', () => {
    // 10 + 148*2 + 31 + 34 = 371
    expect(
      cs.transactionBytes([legacyInput, legacyInput], [legacyOutput, segwitOutput])
    ).toEqual(371)
  })
  it('should return the right transaction size (1 P2PKH + 1 P2PWKH, 1 P2PKH + 1 P2WPKH)', () => {
    // 10.75 + 67.75 + 148 + 31 + 34 = 291.5
    expect(
      cs.transactionBytes([legacyInput, segwitInput], [legacyOutput, segwitOutput])
    ).toEqual(291.5)
  })
  it('should return the right transaction size (2 P2WPKH, 2 P2PKH)', () => {
    // 10.75 + 67.75*2 + 34*2 = 214.25
    expect(
      cs.transactionBytes([segwitInput, segwitInput], [legacyOutput, legacyOutput])
    ).toEqual(214.25)
  })
  it('should return the right transaction size (2 P2WPKH, 2 P2WPKH)', () => {
    // 10.75 + 67.75*2 + 31*2 = 208.25
    expect(
      cs.transactionBytes([segwitInput, segwitInput], [segwitOutput, segwitOutput])
    ).toEqual(208.25)
  })
  it('should return the right transaction size (2 P2WPKH, 1 P2PKH + 1 P2WPKH)', () => {
    // 10.75 + 67.75*2 + 31 + 34 = 211.25
    expect(
      cs.transactionBytes([segwitInput, segwitInput], [legacyOutput, segwitOutput])
    ).toEqual(211.25)
  })
  it('should return the right transaction size (1 P2PKH + 1 P2WPKH, 2 P2WPKH)', () => {
    // 10.75 + 67.75 + 148 + 31*2 = 288.5
    expect(
      cs.transactionBytes([legacyInput, segwitInput], [segwitOutput, segwitOutput])
    ).toEqual(288.5)
  })
})

})

describe('effective Balances', () => { it('should return the right effective max balance with no value and empty valued outputs', () => { const inputs = map(Coin.fromJS, [{ value: 15000 }, { value: 10000 }, { value: 20000 }]) const outputs = map(Coin.fromJS, [{ value: 0 }, { value: 0 }])

  // sum of inputs - transactionBytes * feePerByte
  expect(cs.effectiveBalance(0, inputs, outputs).value).toEqual(45000)
})
it('should return the right effective max balance with value and empty valued outputs', () => {
  const inputs = map(Coin.fromJS, [{ value: 15000 }, { value: 10000 }, { value: 20000 }])

  const outputs = map(Coin.fromJS, [{ value: 0 }, { value: 0 }])

  // sum of inputs - transactionBytes * feePerByte
  // 45000 - 55 * (10 + 3*148 + 2*34) = 45000 - ceil(28710) = 16290
  expect(cs.effectiveBalance(55, inputs, outputs).value).toEqual(16290)
})
it('should return the right effective max balance with value and empty valued outputs (segwit)', () => {
  const inputs = map(Coin.fromJS, [
    { address: 'bc1qxddx2wmn97swgznpkthv940ktg8ycxg0ygxxp9', value: 15000 },
    { address: 'bc1qxddx2wmn97swgznpkthv940ktg8ycxg0ygxxp9', value: 10000 },
    { value: 20000 }
  ])

  const outputs = map(Coin.fromJS, [{ value: 0 }, { value: 0 }])

  // sum of inputs - transactionBytes * feePerByte
  // 45000 - 55 * (10.75 + 2*67.75 + 148 + 2*34) = 45000 - ceil(19923.75) = 25076
  expect(cs.effectiveBalance(55, inputs, outputs).value).toEqual(25076)
})
it('should return the right effective max balance w/ no inputs or outputs', () => {
  expect(cs.effectiveBalance(55, [], []).value).toEqual(0)
})
it('should return the right effective max balance w/ no value, inputs or outputs', () => {
  expect(cs.effectiveBalance(0, [], []).value).toEqual(0)
})

})

describe('findTarget', () => { it('should return the right selection with empty inputs and targets,', () => { const selection = cs.findTarget([], 0, []) expect(selection.fee).toEqual(0) expect(selection.inputs).toEqual([]) expect(selection.outputs).toEqual([]) }) it('should return the right selection without feePerByte set', () => { const inputs = map(Coin.fromJS, [{ value: 1 }, { value: 2 }, { value: 3 }]) const targets = map(Coin.fromJS, [{ value: 10000 }]) const selection = cs.findTarget(targets, 0, inputs) expect(selection.fee).toEqual(0) expect(selection.inputs).toEqual([]) expect(selection.outputs).toEqual(targets) }) it('should return the right selection with feePerByte set', () => { const inputs = map(Coin.fromJS, [{ value: 1 }, { value: 20000 }, { value: 300000 }]) const targets = map(Coin.fromJS, [{ value: 10000 }]) const feePerByte = 55 const selection = cs.findTarget(targets, feePerByte, inputs)

  // Overhead + 2 Inputs + 2 Outputs (target + change)
  const expectedFee = (10 + 2 * 148 + 2 * 34) * feePerByte // 20570
  // Inputs - Target - Expected Fee
  const expectedChange = 300000 + 20000 - 10000 - expectedFee
  expect(selection.fee).toEqual(expectedFee)
  expect(selection.inputs.map((x) => x.value)).toEqual([20000, 300000])
  expect(selection.outputs.map((x) => x.value)).toEqual([10000, expectedChange])
})

})

describe('selectAll', () => { it('should return the right selection with inputs', () => { const inputs = map(Coin.fromJS, [ { value: 1 }, { value: 20000 }, { value: 0 }, { value: 0 }, { value: 300000 } ])

  const selection = cs.selectAll(55, inputs)
  expect(selection.inputs.map((x) => x.value)).toEqual([20000, 300000])

  // overhead + inputs + outputs
  // 55 * (10 + 148 * 2 + 34 * 1) = 55 * 340 = 18700
  expect(selection.fee).toEqual(18700)

  // change = inputs - outputs - fee
  // 20000 + 300000 - 18700 = 301300
  expect(selection.outputs.map((x) => x.value)).toEqual([301300])
})
it('should return the right selection without inputs', () => {
  const inputs = map(Coin.fromJS, [])
  const selection = cs.selectAll(55, inputs)
  expect(selection.fee).toEqual(0)
  expect(selection.inputs.map((x) => x.value)).toEqual([])
  expect(selection.outputs.map((x) => x.value)).toEqual([0])
})

})

describe('compare', () => { it('should return the right selection for descentDraw', () => { const inputs = map(Coin.fromJS, [ { confirmations: 1, value: 1 }, { confirmations: 1, value: 20000 }, { confirmations: 1, value: 0 }, { confirmations: 1, value: 0 }, { confirmations: 1, value: 300000 }, { confirmations: 1, value: 50000 }, { confirmations: 1, value: 30000 } ]) const result = inputs.sort((a, b) => a.descentCompareWeighted(b)) const expected = [300000, 50000, 30000, 20000, 1, 0, 0] expect(result.map((x) => x.value)).toEqual(expected) }) it('should return the right selection with demoted coins for descentDraw', () => { const inputs = map(Coin.fromJS, [ { confirmations: 1, value: 1 }, { confirmations: 1, value: 20000 }, { confirmations: 1, value: 0 }, { confirmations: 1, value: 0 }, { confirmations: 1, value: 300000 }, { confirmations: 0, value: 50000 }, { confirmations: 1, value: 30000 } ]) // const result = inputs.sort((a, b) => a.descentCompareWeighted(b)) const expected = [300000, 30000, 20000, 1, 0, 0, 50000] expect(result.map((x) => x.value)).toEqual(expected) }) it('should return the right selection for ascentDraw', () => { const inputs = map(Coin.fromJS, [ { confirmations: 1, value: 1 }, { confirmations: 1, value: 20000 }, { confirmations: 1, value: 0 }, { confirmations: 1, value: 0 }, { confirmations: 1, value: 300000 }, { confirmations: 1, value: 50000 }, { confirmations: 1, value: 30000 } ]) const result = inputs.sort((a, b) => a.ascentCompareWeighted(b)) const expected = [0, 0, 1, 20000, 30000, 50000, 300000] expect(result.map((x) => x.value)).toEqual(expected) }) it('should return the right selection with demoted coins for ascentDraw', () => { const inputs = map(Coin.fromJS, [ { confirmations: 1, value: 1 }, { confirmations: 1, value: 20000 }, { confirmations: 1, value: 0 }, { confirmations: 1, value: 0 }, { confirmations: 1, value: 300000 }, { confirmations: 0, value: 50000 }, { confirmations: 1, value: 30000 } ]) const result = inputs.sort((a, b) => a.ascentCompareWeighted(b)) const expected = [0, 0, 1, 20000, 30000, 300000, 50000] expect(result.map((x) => x.value)).toEqual(expected) }) })

describe('descentDraw', () => { it('should return the right selection', () => { const inputs = map(Coin.fromJS, [ { value: 1 }, { value: 20000 }, { value: 0 }, { value: 0 }, { value: 300000 }, { value: 50000 }, { value: 30000 } ]) const targets = map(Coin.fromJS, [{ value: 100000 }]) const selection = cs.descentDraw(targets, 55, inputs, 'change-address') expect(selection.inputs.map((x) => x.value)).toEqual([300000])

  // (overhead + inputs + outputs) * feePerByte
  // (10 + (1 * 148) + (2 * 34)) * 55 = 12430
  expect(selection.fee).toEqual(12430)
  // change = inputs - outputs - fee
  //          300000 - 100000 - 12430 = 187570
  expect(selection.outputs.map((x) => x.value)).toEqual([100000, 187570])
})
it('should demote unconfirmed coins', () => {
  const inputs = map(Coin.fromJS, [
    { confirmations: 1, value: 1 },
    { confirmations: 1, value: 20000 },
    { confirmations: 1, value: 0 },
    { confirmations: 1, value: 0 },
    { confirmations: 0, value: 300000 },
    { confirmations: 1, value: 50000 },
    { confirmations: 1, value: 30000 }
  ])
  const targets = map(Coin.fromJS, [{ value: 1000 }])
  const selection = cs.descentDraw(targets, 55, inputs, 'change-address')
  expect(selection.inputs.map((x) => x.value)).toEqual([50000])

  // (overhead + inputs + outputs) * feePerByte
  // (10 + (1 * 148) + (2 * 34)) * 55 = 12430
  expect(selection.fee).toEqual(12430)
  // change = inputs - outputs - fee
  //          50000 - 1000 - 12430 = 36570
  expect(selection.outputs.map((x) => x.value)).toEqual([1000, 36570])
})

})

describe('ascentDraw', () => { it('should return the right selection', () => { const inputs = map(Coin.fromJS, [ { value: 1 }, { value: 20000 }, { value: 0 }, { value: 0 }, { value: 300000 }, { value: 50000 }, { value: 30000 } ]) const targets = map(Coin.fromJS, [{ value: 100000 }]) const selection = cs.ascentDraw(targets, 55, inputs, 'change-address') expect(selection.inputs.map((x) => x.value)).toEqual([20000, 30000, 50000, 300000])

  // (overhead + inputs + outputs) * feePerByte
  // (10 + (4 * 148) + (2 * 34)) * 55 = 36850
  expect(selection.fee).toEqual(36850)
  // change = inputs - outputs - fee
  //          400000 - 100000 - 36850 = 263150
  expect(selection.outputs.map((x) => x.value)).toEqual([100000, 263150])
})

})

describe('singleRandomDraw', () => { it('should return the right selection', () => { const seed = 'test-seed' const inputs = map(Coin.fromJS, [ { value: 1 }, { value: 20000 }, { value: 0 }, { value: 0 }, { value: 300000 }, { value: 50000 }, { value: 30000 } ]) const targets = map(Coin.fromJS, [{ value: 60000 }]) const selection = cs.singleRandomDraw(targets, 55, inputs, 'change-address', seed) expect(selection.fee).toEqual(20000) expect(selection.inputs.map((x) => x.value)).toEqual([30000, 50000]) expect(selection.outputs.map((x) => x.value)).toEqual([60000]) }) }) })import * as Coin from './coinSelection/coin' import * as Exchange from './exchange' import * as Network from './network' import * as pairing from './pairing' import * as coreActions from './redux/actions' import * as coreActionsTypes from './redux/actionTypes' import * as coreMiddleware from './redux/middleware' import * as paths from './redux/paths' import * as coreReducers from './redux/reducers' import coreRootSagaFactory from './redux/rootSaga' import coreSagasFactory from './redux/sagas' import * as coreSelectors from './redux/selectors' import Remote from './remote' import * as transactions from './transactions' import * as Types from './types' import * as utils from './utils' import * as crypto from './walletCrypto'

export { Coin, coreActions, coreActionsTypes, coreMiddleware, coreReducers, coreRootSagaFactory, coreSagasFactory, coreSelectors, crypto, Exchange, Network, pairing, paths, Remote, transactions, Types, utils }import { format, getUnixTime, isSameYear } from 'date-fns' import { curry, equals, includes, lift, map, toLower } from 'ramda'

import { EthRawTxType } from '@core/network/api/eth/types' import { calculateFee } from '@core/utils/eth'

import { getDefaultAddress, getDefaultLabel, getErc20TxNote, getEthTxNote } from '../redux/kvStore/eth/selectors' import Remote from '../remote'

// // Shared Utils // export const getTime = (timeStamp: number | Date) => { const date = new Date(getUnixTime(timeStamp) * 1000) return isSameYear(date, new Date()) ? format(date, 'MMMM d @ h:mm a') : format(date, 'MMMM d yyyy @ h:mm a') }

const getType = (tx, addresses) => { const lowerAddresses = map(toLower, addresses)

switch (true) { case includes(tx.from, lowerAddresses) && includes(tx.to, lowerAddresses): return 'Transferred' case includes(tx.from, lowerAddresses): return 'Sent' case includes(tx.to, lowerAddresses): return 'Received' default: return 'Unknown' } }

// // ETH //

export const getLabel = (address, state) => { const defaultLabelR = getDefaultLabel(state) const defaultAddressR = getDefaultAddress(state) const transform = (defaultLabel, defaultAddress) => { switch (true) { case equals(toLower(defaultAddress), toLower(address)): return defaultLabel default: return address } } const labelR = lift(transform)(defaultLabelR, defaultAddressR) return labelR.getOrElse(address) }

export const _transformTx = curry((addresses, erc20Contracts, state, tx: EthRawTxType) => { const fee = calculateFee(tx.gasPrice, tx.state === 'CONFIRMED' ? tx.gasUsed : tx.gasLimit, false) const type = toLower(getType(tx, addresses)) const amount = type === 'sent' ? parseInt(tx.value, 10) + parseInt(fee, 10) : parseInt(tx.value, 10) // @ts-ignore const time = tx.timestamp || tx.timeStamp const isErc20 = includes(tx.to, erc20Contracts.map(toLower))

return { amount, blockHeight: tx.state === 'CONFIRMED' ? tx.blockNumber : undefined, data: isErc20 ? tx.data : null, description: getEthTxNote(state, tx.hash).getOrElse(''), erc20: isErc20, fee: Remote.Success(fee), from: getLabel(tx.from, state), hash: tx.hash, insertedAt: Number(time) * 1000, state: tx.state, time, timeFormatted: getTime(new Date(time * 1000)), to: getLabel(tx.to, state), type } })

// // ERC20 // export const getErc20Label = (address, token, state) => { const ethAddressR = getDefaultAddress(state) const transform = (ethAddress) => { if (equals(toLower(ethAddress), toLower(address))) { return ${token} DeFi Wallet } return address } const labelR = lift(transform)(ethAddressR) return labelR.getOrElse(address) }

export const _transformErc20Tx = curry((addresses, state, token, tx) => { const type = toLower(getType(tx, addresses)) const time = tx.timestamp || tx.timeStamp

return { amount: parseInt(tx.value, 10), blockHeight: tx.blockNumber, coin: token, description: getErc20TxNote(state, token, tx.transactionHash).getOrElse(''), fee: Remote.NotAsked, from: getErc20Label(tx.from, token, state), hash: tx.transactionHash, insertedAt: Number(time) * 1000, state: tx.state, time, timeFormatted: getTime(new Date(time * 1000)), to: getErc20Label(tx.to, token, state), type } })

export const transformTx = _transformTx export const transformErc20Tx = _transformErc20Tximport { format, getUnixTime, isSameYear } from 'date-fns' import { allPass, always, compose, curry, equals, find, findIndex, ifElse, isNil, lensIndex, lensProp, mapAccum, not, over, prop, propEq, propOr, propSatisfies, toLower, view } from 'ramda'

import Remote from '../remote' import { Address, AddressBook, AddressBookEntry, AddressMap, HDAccount, HDAccountList, HDWallet, HDWalletList, TXNotes, Wallet } from '../types'

const unpackInput = prop('prev_out') const isLegacy = (wallet, coin) => compose(not, isNil, AddressMap.selectAddress(prop('addr', coin)), Wallet.selectAddresses)(wallet) const isAccount = (coin) => !!coin.xpub const isAccountChange = (x) => isAccount(x) && x.xpub.path.split('/')[1] === '1' const accountPath = (index, coin) => index + coin.xpub.path.substr(1) const receiveIndex = (coin) => { if (!coin || !coin.xpub || !coin.xpub.path) return if (!coin.xpub.path.split('/').length === 3) return return parseInt(coin.xpub.path.substr(1).split('/')[2]) } const isCoinBase = (inputs) => inputs.length === 1 && inputs[0].prev_out == null

const tagCoin = curry((wallet, accountList, coin) => { switch (true) { case isAccount(coin): const account = compose( HDAccountList.selectByXpub(coin.xpub.m), HDWallet.selectAccounts, HDWalletList.selectHDWallet, Wallet.selectHdWallets )(wallet) || compose(HDAccountList.selectByXpub(coin.xpub.m))(accountList) const index = HDAccount.selectIndex(account) return { accountIndex: index, address: coin.addr, amount: coin.value, change: isAccountChange(coin), coinType: accountPath(index, coin), label: HDAccount.selectLabel(account), // TODO: SEGWIT, is this needed? // isWatchOnly: HDAccount.isWatchOnly(account), receiveIndex: receiveIndex(coin) // only if change? } case isLegacy(wallet, coin): const address = compose(AddressMap.selectAddress(coin.addr), Wallet.selectAddresses)(wallet) return { address: coin.addr, amount: coin.value, change: false, coinType: 'legacy', isWatchOnly: Address.isWatchOnly(address), label: Address.selectLabel(address) } default: const bookEntry = compose( AddressBook.selectAddressLabel(coin.addr), Wallet.selectAddressBook )(wallet) return { address: coin.addr, amount: coin.value, change: false, coinType: 'external', isWatchOnly: false, label: bookEntry ? AddressBookEntry.selectLabel(bookEntry) : null } } })

const txtype = (result, fee) => { const impact = result + fee switch (true) { case impact === 0: return 'Transferred' case result < 0: return 'Sent' case result > 0: return 'Received' default: return 'Unknown' } }

// amount is what we show on the transaction feed // result is internalreceive - internalspend const computeAmount = (type, inputData, outputData) => { switch (type) { case 'Transferred': return propOr(0, 'internal', outputData) - propOr(0, 'change', outputData) case 'Sent': return -propOr(0, 'internal', outputData) + propOr(0, 'internal', inputData) case 'Received': return propOr(0, 'internal', outputData) - propOr(0, 'internal', inputData) default: return propOr(0, 'internal', outputData) - propOr(0, 'internal', inputData) } }

const init = { change: 0, internal: 0, isWatchOnly: false, total: 0 }

// internalAmount :: taggedCoin -> Integer const internalAmount = ifElse( propSatisfies((x) => x !== 'external', 'coinType'), prop('amount'), always(0) )

const changeAmount = ifElse(propEq('change', true), prop('amount'), always(0))

const reduceCoins = (acc, taggedCoin) => { return { change: acc.change + changeAmount(taggedCoin), internal: acc.internal + internalAmount(taggedCoin), isWatchOnly: acc.isWatchOnly || taggedCoin.isWatchOnly, total: acc.total + taggedCoin.amount } }

const appender = curry((tagger, acc, coin) => { const taggedCoin = tagger(coin) return [reduceCoins(acc, taggedCoin), taggedCoin] })

const selectFromAndto = (inputs, outputs, type) => { const preceived = compose(not, propEq('coinType', 'external')) const psent = compose(not, propEq('address', inputs[0].address)) const predicate = type === 'Sent' ? psent : preceived const myOutput = find(allPass([propEq('change', false), predicate]))(outputs) || outputs[0] return { from: inputs[0].label || inputs[0].address, to: myOutput.label || myOutput.address, toAddress: myOutput.address } }

const findLegacyChanges = (inputs, inputData, outputs, outputData) => { if (inputs && inputs[0].coinType === 'legacy' && inputData.internal === inputData.total) { const { address } = inputs[0] const index = findIndex(propEq('address', address))(outputs) if (index < 0) return [outputData, outputs] // no change const newOutputs = over(compose(lensIndex(index), lensProp('change')), not, outputs) const change = view(compose(lensIndex(index), lensProp('amount')), outputs) const newOutputData = over(lensProp('change'), (c) => c + change, outputData) return [newOutputData, newOutputs] } return [outputData, outputs] }

const CoinbaseCoin = (total) => ({ address: 'Coinbase', amount: total, change: false, coinType: 'external', isWatchOnly: false, label: 'Coinbase' })

const CoinBaseData = (total) => ({ change: 0, internal: 0, isWatchOnly: false, total })

const getDescription = (hash, txNotes, addressLabels, toAddress) => { const txNote = TXNotes.selectNote(hash, txNotes) return txNote || propOr('', [toAddress], addressLabels) }

export const getTime = (tx) => { const date = new Date(getUnixTime(tx.time) * 1000) return isSameYear(date, new Date()) ? format(date, 'MMMM d @ h:mm a') : format(date, 'MMMM d yyyy @ h:mm a') }

export const _transformTx = (wallet, accountList, txNotes, addressLabels, tx) => { const type = txtype(tx.result, tx.fee) const inputTagger = compose(tagCoin(wallet, accountList), unpackInput) const outputTagger = tagCoin(wallet, accountList) const [oData, outs] = mapAccum(appender(outputTagger), init, prop('out', tx)) const [inputData, inputs] = ifElse( compose(isCoinBase, prop('inputs')), always([CoinBaseData(oData.total), [CoinbaseCoin(oData.total)]]), (t) => mapAccum(appender(inputTagger), init, prop('inputs', t)) )(tx)

const [outputData, outputs] = findLegacyChanges(inputs, inputData, outs, oData) const { from, to, toAddress } = selectFromAndto(inputs, outputs, type)

return { amount: computeAmount(type, inputData, outputData), blockHeight: tx.block_height, coin: 'BTC', description: getDescription(tx.hash, txNotes, addressLabels, toAddress), double_spend: tx.double_spend, fee: Remote.Success(tx.fee), from, fromWatchOnly: inputData.isWatchOnly, hash: tx.hash, inputs, insertedAt: tx.time * 1000, outputs, rbf: tx.rbf, time: tx.time, timeFormatted: getTime(tx), to, toAddress, toWatchOnly: outputData.isWatchOnly, type: toLower(type) } }

export const transformTx = _transformTximport { format, getUnixTime, isSameYear } from 'date-fns' import { allPass, always, any, compose, curry, find, findIndex, ifElse, isNil, lensIndex, lensProp, mapAccum, not, over, pathOr, prop, propEq, propOr, propSatisfies, reject, toLower, view } from 'ramda'

import Remote from '../remote' import { Address, AddressBook, AddressBookEntry, AddressMap, HDAccount, HDAccountList, HDWallet, HDWalletList, Wallet } from '../types'

const unpackInput = prop('prev_out') const isLegacy = (wallet, coin) => compose(not, isNil, AddressMap.selectAddress(prop('addr', coin)), Wallet.selectAddresses)(wallet) const isAccount = (coin) => !!coin.xpub const isAccountChange = (x) => isAccount(x) && x.xpub.path.split('/')[1] === '1' const accountPath = (index, coin) => index + coin.xpub.path.substr(1) const receiveIndex = (coin) => { if (!coin || !coin.xpub || !coin.xpub.path) return if (!coin.xpub.path.split('/').length === 3) return return parseInt(coin.xpub.path.substr(1).split('/')[2]) } const isDust = propEq('amount', 546) const isCoinBase = (inputs) => inputs.length === 1 && inputs[0].prev_out == null

const tagCoin = curry((wallet, accountList, coin) => { switch (true) { case isAccount(coin): const account = compose( HDAccountList.selectByXpub(coin.xpub.m), HDWallet.selectAccounts, HDWalletList.selectHDWallet, Wallet.selectHdWallets )(wallet) || compose(HDAccountList.selectByXpub(coin.xpub.m))(accountList) const index = HDAccount.selectIndex(account) return { accountIndex: index, address: coin.addr, amount: coin.value, change: isAccountChange(coin), coinType: accountPath(index, coin), isWatchOnly: HDAccount.isWatchOnly(account), label: HDAccount.selectLabel(account), receiveIndex: receiveIndex(coin) // only if change? } case isLegacy(wallet, coin): const address = compose(AddressMap.selectAddress(coin.addr), Wallet.selectAddresses)(wallet) return { address: coin.addr, amount: coin.value, change: false, coinType: 'legacy', isWatchOnly: Address.isWatchOnly(address), label: Address.selectLabel(address) } default: const bookEntry = compose( AddressBook.selectAddressLabel(coin.addr), Wallet.selectAddressBook )(wallet) return { address: coin.addr, amount: coin.value, change: false, coinType: 'external', isWatchOnly: false, label: bookEntry ? AddressBookEntry.selectLabel(bookEntry) : null } } })