edge-currency-accountbased 0.7.72

package/lib/tezos/tezosPlugin.js

@@ -0,0 +1,174 @@
+
+
+
+
+
+
+
+
+
+
+
+
+import { eztz } from 'eztz.js'
+import { decodeMainnet, encodeMainnet } from 'tezos-uri'
+
+import { CurrencyPlugin } from '../common/plugin.js'
+import { getFetchCors } from '../react-native-io.js'
+import { TezosEngine } from './tezosEngine.js'
+import { currencyInfo } from './tezosInfo.js'
+
+
+export class TezosPlugin extends CurrencyPlugin {
+  
+  
+  constructor(io, fetchCors) {
+    super(io, 'tezos', currencyInfo)
+    this.tezosRpcNodes = []
+    for (const rpcNode of currencyInfo.defaultSettings.otherSettings
+      .tezosRpcNodes) {
+      this.tezosRpcNodes.push(rpcNode)
+    }
+    this.tezosApiServers = []
+    for (const apiServer of currencyInfo.defaultSettings.otherSettings
+      .tezosApiServers) {
+      this.tezosApiServers.push(apiServer)
+    }
+  }
+
+  checkAddress(address) {
+    try {
+      const valid = eztz.crypto.checkAddress(address)
+      return valid
+    } catch (e) {
+      return false
+    }
+  }
+
+  async importPrivateKey(userInput) {
+    // check for existence of numbers
+    if (/\d/.test(userInput)) {
+      throw new Error('Input must be mnemonic phrase')
+    }
+    const wordList = userInput.split(' ')
+    const wordCount = wordList.length
+    if (wordCount !== 24) {
+      throw new Error('Mnemonic phrase must be 24 words long')
+    }
+    const keys = eztz.crypto.generateKeys(userInput, '')
+    this.derivePublicKey({
+      type: 'wallet:tezos',
+      id: 'fake',
+      keys
+    })
+    return {
+      mnemonic: keys.mnemonic,
+      privateKey: keys.sk
+    }
+  }
+
+  async createPrivateKey(walletType) {
+    const type = walletType.replace('wallet:', '')
+    if (type === 'tezos') {
+      // Use 256 bits entropy
+      const entropy = Buffer.from(this.io.random(32)).toString('hex')
+      const mnemonic = eztz.library.bip39.entropyToMnemonic(entropy)
+      const privateKey = eztz.crypto.generateKeys(mnemonic, '').sk
+      return { mnemonic, privateKey }
+    } else {
+      throw new Error('InvalidWalletType')
+    }
+  }
+
+  async derivePublicKey(walletInfo) {
+    const type = walletInfo.type.replace('wallet:', '')
+    if (type === 'tezos') {
+      const keypair = eztz.crypto.generateKeys(walletInfo.keys.mnemonic, '')
+      return { publicKey: keypair.pkh, publicKeyEd: keypair.pk }
+    } else {
+      throw new Error('InvalidWalletType')
+    }
+  }
+
+  async parseUri(uri) {
+    let address
+    let operation
+    let content
+    if (this.checkAddress(uri)) {
+      address = uri
+    } else if (uri.slice(0, 10) === 'web+tezos:') {
+      operation = decodeMainnet(uri)
+      if (!operation[0] || !operation[0].content) {
+        throw new Error('InvalidUriError')
+      }
+      content = operation[0].content
+      address = content.destination
+      if (!this.checkAddress(address)) {
+        throw new Error('InvalidPublicAddressError')
+      }
+    } else {
+      throw new Error('InvalidUriError')
+    }
+    const edgeParsedUri = {
+      publicAddress: address
+    }
+    edgeParsedUri.nativeAmount =
+      content && content.amount !== '0' ? content.amount : undefined
+    edgeParsedUri.currencyCode = 'XTZ'
+    return edgeParsedUri
+  }
+
+  async encodeUri(obj) {
+    const valid = this.checkAddress(obj.publicAddress)
+    if (!valid) {
+      throw new Error('InvalidPublicAddressError')
+    }
+    if (obj.currencyCode !== 'XTZ') {
+      throw new Error('InvalidCurrencyCodeError')
+    }
+    const amount = typeof obj.nativeAmount === 'string' ? obj.nativeAmount : '0'
+    const content = {
+      kind: 'transaction',
+      amount,
+      destination: obj.publicAddress
+    }
+    const uri = encodeMainnet([{ content }])
+    return uri
+  }
+}
+export function makeTezosPlugin(
+  opts
+) {
+  const { io } = opts
+  const fetchCors = getFetchCors(opts)
+
+  let toolsPromise
+  function makeCurrencyTools() {
+    if (toolsPromise != null) return toolsPromise
+    toolsPromise = Promise.resolve(new TezosPlugin(io, fetchCors))
+    return toolsPromise
+  }
+  async function makeCurrencyEngine(
+    walletInfo,
+    opts
+  ) {
+    const tools = await makeCurrencyTools()
+    const currencyEngine = new TezosEngine(tools, walletInfo, opts, fetchCors)
+
+    await currencyEngine.loadEngine(tools, walletInfo, opts)
+
+    // This is just to make sure otherData is Flow type checked
+    currencyEngine.otherData = currencyEngine.walletLocalData.otherData
+    if (!currencyEngine.otherData.numberTransactions) {
+      currencyEngine.otherData.numberTransaction = 0
+    }
+    const out = currencyEngine
+    return out
+  }
+
+  return {
+    currencyInfo,
+    makeCurrencyEngine,
+    makeCurrencyTools
+  }
+}

package/lib/tezos/tezosTypes.js

@@ -0,0 +1,110 @@
+// 
+
+import { asNumber, asObject, asString } from 'cleaners'
+
+
+
+
+export const asXtzGetTransaction = asObject({
+  level: asNumber,
+  timestamp: asString,
+  hash: asString,
+  sender: asObject({
+    address: asString
+  }),
+  bakerFee: asNumber,
+  allocationFee: asNumber,
+  target: asObject({
+    address: asString
+  }),
+  amount: asNumber,
+  status: asString
+})
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+