edge-currency-accountbased 2.2.4 → 2.4.0

package/lib/{zcash → piratechain}/piratechainInfo.js

@@ -14,41 +14,45 @@ const networkInfo = {
   },
   defaultBirthday: 2040000,
   defaultNetworkFee: '10000',
-  nativeSdk: 'piratechain',
   transactionQueryLimit: 999
 }
 
 const currencyInfo = {
-  // Basic currency information:
   currencyCode: 'ARRR',
   displayName: 'Pirate Chain',
   pluginId: 'piratechain',
   requiredConfirmations: 10,
+  unsafeBroadcastTx: true,
   walletType: 'wallet:piratechain',
 
-  defaultSettings: {},
-
+  // Explorers:
   addressExplorer: '',
   transactionExplorer: 'https://explorer.pirate.black/tx/%s',
 
   denominations: [
-    // An array of Objects of the possible denominations for this currency
     {
       name: 'ARRR',
       multiplier: '100000000',
       symbol: 'P'
     }
   ],
-  metaTokens: [], // Deprecated
 
-  unsafeBroadcastTx: true
+  // Copied from Zcash:
+  memoOptions: [{ type: 'text', maxLength: 512 }],
+
+  // Deprecated:
+  defaultSettings: {},
+  metaTokens: []
 }
 
- const piratechain = _innerPlugin.makeOuterPlugin({
+ const piratechain = _innerPlugin.makeOuterPlugin
+
+
+({
   currencyInfo,
   networkInfo,
 
   async getInnerPlugin() {
-    return await Promise.resolve().then(() => require('./ZcashTools'))
+    return await Promise.resolve().then(() => require('./PiratechainTools'))
   }
 }); exports.piratechain = piratechain

package/lib/piratechain/piratechainTypes.js

@@ -0,0 +1,177 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+var _cleaners = require('cleaners');
+
+
+var _types = require('../common/types');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Block range is inclusive
+ const asPiratechainBlockRange = _cleaners.asObject.call(void 0, {
+  first: _cleaners.asNumber,
+  last: _cleaners.asNumber
+}); exports.asPiratechainBlockRange = asPiratechainBlockRange
+
+
+
+ const asPiratechainWalletOtherData = _cleaners.asObject.call(void 0, {
+  alias: _cleaners.asMaybe.call(void 0, _cleaners.asString),
+  blockRange: _cleaners.asMaybe.call(void 0, exports.asPiratechainBlockRange, {
+    first: 0,
+    last: 0
+  })
+}); exports.asPiratechainWalletOtherData = asPiratechainWalletOtherData
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ const asArrrPublicKey = _cleaners.asObject.call(void 0, {
+  birthdayHeight: _cleaners.asNumber,
+  publicKey: _cleaners.asString,
+  unifiedViewingKeys: _cleaners.asObject.call(void 0, {
+    extfvk: _cleaners.asString,
+    extpub: _cleaners.asString
+  })
+}); exports.asArrrPublicKey = asArrrPublicKey
+
+
+
+
+ const asSafePiratechainWalletInfo = _types.asWalletInfo.call(void 0, exports.asArrrPublicKey); exports.asSafePiratechainWalletInfo = asSafePiratechainWalletInfo
+
+
+
+
+
+
+ const asPiratechainPrivateKeys = (
+  pluginId
+) => {
+  const asKeys = _cleaners.asObject.call(void 0, {
+    [`${pluginId}Mnemonic`]: _cleaners.asString,
+    [`${pluginId}SpendKey`]: _cleaners.asString,
+    [`${pluginId}BirthdayHeight`]: _cleaners.asNumber
+  })
+
+  return _cleaners.asCodec.call(void 0, 
+    raw => {
+      const clean = asKeys(raw)
+      return {
+        mnemonic: clean[`${pluginId}Mnemonic`] ,
+        spendKey: clean[`${pluginId}SpendKey`] ,
+        birthdayHeight: clean[`${pluginId}BirthdayHeight`] 
+      }
+    },
+    clean => {
+      return {
+        [`${pluginId}Mnemonic`]: clean.mnemonic,
+        [`${pluginId}SpendKey`]: clean.spendKey,
+        [`${pluginId}BirthdayHeight`]: clean.birthdayHeight
+      }
+    }
+  )
+}; exports.asPiratechainPrivateKeys = asPiratechainPrivateKeys

package/lib/polkadot/PolkadotEngine.js

@@ -20,6 +20,7 @@ var _rfc4648 = require('rfc4648');
 var _CurrencyEngine = require('../common/CurrencyEngine');
 
 var _tokenHelpers = require('../common/tokenHelpers');
+var _upgradeMemos = require('../common/upgradeMemos');
 
 
 
@@ -189,15 +190,16 @@ const queryTxMutex = _utils.makeMutex.call(void 0, )
     }
 
     const edgeTransaction = {
-      txid: hash,
-      date,
-      currencyCode: this.currencyInfo.currencyCode,
       blockHeight,
-      nativeAmount,
+      currencyCode: this.currencyInfo.currencyCode,
+      date,
       isSend: nativeAmount.startsWith('-'),
+      memos: [],
+      nativeAmount,
       networkFee: fee,
       ourReceiveAddresses,
       signedTx: '',
+      txid: hash,
       walletId: this.walletId
     }
     this.addTransaction(this.currencyInfo.currencyCode, edgeTransaction)
@@ -320,6 +322,7 @@ const queryTxMutex = _utils.makeMutex.call(void 0, )
   }
 
   async getMaxSpendable(spendInfo) {
+    spendInfo = _upgradeMemos.upgradeMemos.call(void 0, spendInfo, this.currencyInfo)
     if (
       spendInfo.spendTargets.length === 0 ||
       spendInfo.spendTargets[0].publicAddress == null
@@ -385,7 +388,9 @@ const queryTxMutex = _utils.makeMutex.call(void 0, )
   }
 
   async makeSpend(edgeSpendInfoIn) {
+    edgeSpendInfoIn = _upgradeMemos.upgradeMemos.call(void 0, edgeSpendInfoIn, this.currencyInfo)
     const { edgeSpendInfo, currencyCode } = this.makeSpendCheck(edgeSpendInfoIn)
+    const { memos = [] } = edgeSpendInfo
 
     if (edgeSpendInfo.spendTargets.length !== 1) {
       throw new Error('Error: only one output allowed')
@@ -482,16 +487,17 @@ const queryTxMutex = _utils.makeMutex.call(void 0, )
     // **********************************
     // Create the unsigned EdgeTransaction
     const edgeTransaction = {
-      txid: '',
-      date: 0,
-      currencyCode,
       blockHeight: 0,
-      nativeAmount: _biggystring.mul.call(void 0, totalTxAmount, '-1'),
+      currencyCode,
+      date: 0,
       isSend: true,
+      memos,
+      nativeAmount: _biggystring.mul.call(void 0, totalTxAmount, '-1'),
       networkFee: nativeNetworkFee,
+      otherParams,
       ourReceiveAddresses: [],
       signedTx: '',
-      otherParams,
+      txid: '',
       walletId: this.walletId
     }
 

package/lib/polkadot/info/liberlandInfo.js

@@ -30,6 +30,7 @@ const networkInfo = {
   pluginId: 'liberland',
   walletType: 'wallet:liberland',
 
+  // Explorers:
   addressExplorer: '',
   transactionExplorer:
     'https://polkadot.js.org/apps/?rpc=wss%%3A%%2F%%2Fmainnet.liberland.org%%2F#/explorer/query/%s',
@@ -42,9 +43,9 @@ const networkInfo = {
     }
   ],
 
-  // Deprecated
+  // Deprecated:
   defaultSettings: {},
-  metaTokens: _tokenHelpers.makeMetaTokens.call(void 0, builtinTokens) // Deprecated
+  metaTokens: _tokenHelpers.makeMetaTokens.call(void 0, builtinTokens)
 }; exports.currencyInfo = currencyInfo
 
  const liberland = _innerPlugin.makeOuterPlugin({

package/lib/polkadot/info/liberlandTestnetInfo.js

@@ -30,6 +30,7 @@ const networkInfo = {
   pluginId: 'liberlandtestnet',
   walletType: 'wallet:liberlandtestnet',
 
+  // Explorers:
   addressExplorer: '',
   transactionExplorer:
     'https://polkadot.js.org/apps/?rpc=wss%%3A%%2F%%2Ftestchain.liberland.org%%2F#/explorer/query/%s',
@@ -42,9 +43,9 @@ const networkInfo = {
     }
   ],
 
-  // Deprecated
+  // Deprecated:
   defaultSettings: {},
-  metaTokens: _tokenHelpers.makeMetaTokens.call(void 0, builtinTokens) // Deprecated
+  metaTokens: _tokenHelpers.makeMetaTokens.call(void 0, builtinTokens)
 }; exports.currencyInfo = currencyInfo
 
  const liberlandtestnet = _innerPlugin.makeOuterPlugin

package/lib/polkadot/info/polkadotInfo.js

@@ -13,26 +13,29 @@ const networkInfo = {
 }
 
  const currencyInfo = {
-  // Basic currency information:
   currencyCode: 'DOT',
   displayName: 'Polkadot',
   pluginId: 'polkadot',
   walletType: 'wallet:polkadot',
 
-  defaultSettings: {},
-
+  // Explorers:
   addressExplorer: 'https://polkadot.subscan.io/account/%s',
   transactionExplorer: 'https://polkadot.subscan.io/extrinsic/%s',
 
   denominations: [
-    // An array of Objects of the possible denominations for this currency
     {
       name: 'DOT',
       multiplier: '10000000000',
       symbol: ''
     }
   ],
-  metaTokens: [] // Deprecated
+
+  // No memo support:
+  memoOptions: [],
+
+  // Deprecated:
+  defaultSettings: {},
+  metaTokens: []
 }; exports.currencyInfo = currencyInfo
 
  const polkadot = _innerPlugin.makeOuterPlugin({

package/lib/react-native.js

@@ -1,12 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 var _reactnative = require('react-native');
-
-
-
-
-
-var _reactnativepiratechain = require('react-native-piratechain');
-
+// import {
+//   AddressTool as PiratechainAddressTool,
+//   KeyTool as PiratechainKeyTool,
+//   makeSynchronizer as PiratechainMakeSynchronizer,
+//   Synchronizer as PirateSynchronizer
+// } from 'react-native-piratechain'
 
 
 
@@ -14,6 +13,7 @@ var _reactnativepiratechain = require('react-native-piratechain');
 var _reactnativezcash = require('react-native-zcash');
 var _yaob = require('yaob');
 
+// import { PiratechainInitializerConfig } from './piratechain/piratechainTypes'
 
 
 const { EdgeCurrencyAccountbasedModule } = _reactnative.NativeModules
@@ -22,63 +22,88 @@ const { sourceUri } = EdgeCurrencyAccountbasedModule.getConstants()
  const pluginUri = sourceUri; exports.pluginUri = pluginUri
  const debugUri = 'http://localhost:8082/edge-currency-accountbased.js'; exports.debugUri = debugUri
 
-
-
-const makePluginSynchronizer = (pluginId) => {
-  return async (config) => {
-    let realSynchronizer
-
-    switch (pluginId) {
-      case 'piratechain':
-        realSynchronizer = await _reactnativepiratechain.makeSynchronizer.call(void 0, config)
-        break
-      case 'zcash':
-        realSynchronizer = await _reactnativezcash.makeSynchronizer.call(void 0, config)
-        break
-      default:
-        throw new Error(`${pluginId} makeSynchronizer does not exist`)
+// const makePiratechainSynchronizer = async (
+//   config: PiratechainInitializerConfig
+// ): Promise<PirateSynchronizer> => {
+//   const realSynchronizer = await PiratechainMakeSynchronizer(config)
+
+//   realSynchronizer.subscribe({
+//     onStatusChanged(status): void {
+//       emit(out, 'statusChanged', status)
+//     },
+//     onUpdate(event): void {
+//       emit(out, 'update', event)
+//     }
+//   })
+
+//   const out: PirateSynchronizer = bridgifyObject({
+//     // @ts-expect-error
+//     on: onMethod,
+//     start: async () => {
+//       return await realSynchronizer.start()
+//     },
+//     getTransactions: async blockRange => {
+//       return await realSynchronizer.getTransactions(blockRange)
+//     },
+//     rescan: height => {
+//       return realSynchronizer.rescan(height)
+//     },
+//     sendToAddress: async spendInfo => {
+//       return await realSynchronizer.sendToAddress(spendInfo)
+//     },
+//     getShieldedBalance: async () => {
+//       return await realSynchronizer.getShieldedBalance()
+//     },
+//     stop: async () => {
+//       return await realSynchronizer.stop()
+//     }
+//   })
+//   return out
+// }
+
+const makeZcashSynchronizer = async (
+  config
+) => {
+  const realSynchronizer = await _reactnativezcash.makeSynchronizer.call(void 0, config)
+
+  realSynchronizer.subscribe({
+    onStatusChanged(status) {
+      _yaob.emit.call(void 0, out, 'statusChanged', status)
+    },
+    onUpdate(event) {
+      _yaob.emit.call(void 0, out, 'update', event)
     }
+  })
 
-    realSynchronizer.subscribe({
-      onStatusChanged(status) {
-        _yaob.emit.call(void 0, out, 'statusChanged', status)
-      },
-      onUpdate(event) {
-        _yaob.emit.call(void 0, out, 'update', event)
-      }
-    })
-
-    const out = _yaob.bridgifyObject.call(void 0, {
-      // @ts-expect-error
-      on: _yaob.onMethod,
-      start: async () => {
-        return await realSynchronizer.start()
-      },
-      getTransactions: async blockRange => {
-        return await realSynchronizer.getTransactions(blockRange)
-      },
-      rescan: height => {
-        return realSynchronizer.rescan(height)
-      },
-      sendToAddress: async spendInfo => {
-        return await realSynchronizer.sendToAddress(spendInfo)
-      },
-      getShieldedBalance: async () => {
-        return await realSynchronizer.getShieldedBalance()
-      },
-      stop: async () => {
-        return await realSynchronizer.stop()
-      }
-    })
-    return out
-  }
+  const out = _yaob.bridgifyObject.call(void 0, {
+    // @ts-expect-error
+    on: _yaob.onMethod,
+    deriveUnifiedAddress: async () => {
+      return await realSynchronizer.deriveUnifiedAddress()
+    },
+    getTransactions: async blockRange => {
+      return await realSynchronizer.getTransactions(blockRange)
+    },
+    rescan: () => {
+      return realSynchronizer.rescan()
+    },
+    sendToAddress: async spendInfo => {
+      return await realSynchronizer.sendToAddress(spendInfo)
+    },
+    getBalance: async () => {
+      return await realSynchronizer.getBalance()
+    },
+    stop: async () => {
+      return await realSynchronizer.stop()
+    }
+  })
+  return out
 }
 
  function makePluginIo() {
-  _yaob.bridgifyObject.call(void 0, _reactnativepiratechain.KeyTool)
-  _yaob.bridgifyObject.call(void 0, _reactnativepiratechain.AddressTool)
-  _yaob.bridgifyObject.call(void 0, _reactnativezcash.KeyTool)
-  _yaob.bridgifyObject.call(void 0, _reactnativezcash.AddressTool)
+  // bridgifyObject(PiratechainKeyTool)
+  // bridgifyObject(PiratechainAddressTool)
+  _yaob.bridgifyObject.call(void 0, _reactnativezcash.Tools)
 
   return {
     async fetchText(uri, opts) {
@@ -93,18 +118,17 @@ const makePluginSynchronizer = (pluginId) => {
           }))
       )
     },
-    piratechain: _yaob.bridgifyObject.call(void 0, {
-      KeyTool: _reactnativepiratechain.KeyTool,
-      AddressTool: _reactnativepiratechain.AddressTool,
-      async makeSynchronizer(config) {
-        return await makePluginSynchronizer('piratechain')(config)
-      }
-    }),
+    // piratechain: bridgifyObject({
+    //   KeyTool: PiratechainKeyTool,
+    //   AddressTool: PiratechainAddressTool,
+    //   async makeSynchronizer(config: PiratechainInitializerConfig) {
+    //     return await makePiratechainSynchronizer(config)
+    //   }
+    // }),
     zcash: _yaob.bridgifyObject.call(void 0, {
-      KeyTool: _reactnativezcash.KeyTool,
-      AddressTool: _reactnativezcash.AddressTool,
+      Tools: _reactnativezcash.Tools,
       async makeSynchronizer(config) {
-        return await makePluginSynchronizer('zcash')(config)
+        return await makeZcashSynchronizer(config)
       }
     })
   }