[Archive] Feature/polkadot plugin mvp

README.md

@@ -78,6 +78,7 @@ Just install the chainjs library to get started
 ```
 
 To run ts files (and examples), use ts-node (with the --files option to include local customTypes)
+Important: Node version 13 or greater is required to run polkadot examples - Hint: Use nvm to run run node on your local machine
 ```bash
  $ ts-node --files mycode.ts
 ```

package.json

@@ -40,6 +40,11 @@
   },
   "dependencies": {
     "@aikon/sjcl": "^0.1.8",
+    "@polkadot/api": "^4.0.3",
+    "@polkadot/keyring": "^6.0.5",
+    "@polkadot/types": "^4.0.3",
+    "@polkadot/util": "^6.0.5",
+    "@polkadot/util-crypto": "^6.0.5",
     "@types/bignumber.js": "^5.0.0",
     "@types/bn.js": "^4.11.6",
     "@types/bs58": "^4.0.1",

parachains

@@ -0,0 +1,50 @@
+
+
+
+ParachainA Manifest
+- DPOS 
+- curve type
+- Account palate Type 1
+- Currency ABC 
+- Fee palate type 1
+
+ParachainB 
+- POW 
+- curve type
+- Account palate Type 2
+- Currency XYZ 
+- No Fees
+
+ParachainC 
+- POW 
+- curve type
+- No Accounts 
+- No Currency
+
+
+Developer Code 
+
+- CreateAccount on chain
+- Transfer Currency on chain 
+- ...
+- compose transaction type X on chain
+- sign transaction
+- send transaction to chain 
+- wait for transaction confirmation 
+
+chainJS != Poladot chain standard  (parachains are diff)
+
+
+para
+
+new ChainFactory(PolkaDotV1, options: {parachainManifest})
+
+
+
+Developer App - Game 
+
+(TX GAME123) -> Parachain X - general purpose contract chain (game contracts go here)
+  (tx 123) -> Parachain A - Marketplace for NFTs 
+  (tx 456) -> Parachain B - Bridge to ETH (send 721)
+  Parachain C - service XYC 
+

src/chainFactory.ts

@@ -1,6 +1,7 @@
 import { ChainEosV2 } from './chains/eos_2/ChainEosV2'
 import { ChainEthereumV1 } from './chains/ethereum_1/ChainEthereumV1'
 import { ChainAlgorandV1 } from './chains/algorand_1/ChainAlgorandV1'
+import { ChainPolkadotV1 } from './chains/polkadot_1/ChainPolkadotV1'
 import { Chain } from './interfaces'
 import { ChainType, ChainEndpoint } from './models'
 import { throwNewError } from './errors'
@@ -16,6 +17,8 @@ export class ChainFactory {
         return new ChainEthereumV1(endpoints, settings)
       case ChainType.AlgorandV1:
         return new ChainAlgorandV1(endpoints, settings)
+      case ChainType.PolkadotV1:
+        return new ChainPolkadotV1(endpoints, settings)
       default:
         throwNewError(`Chain type ${chainType} is not supported`)
     }

src/chains/algorand_1/algoAction.ts

@@ -2,13 +2,18 @@ import * as algosdk from 'algosdk'
 import { isNullOrEmpty, toBuffer, bufferToString, isAUint8Array, isAString, isAUint8ArrayArray } from '../../helpers'
 import { throwNewError } from '../../errors'
 import {
+  AlgorandTransactionOptions,
   AlgorandTxAction,
   AlgorandTxActionRaw,
   AlgorandTxActionSdkEncoded,
   AlgorandTxActionSdkEncodedFields,
 } from './models/transactionModels'
 import { AlgorandTxHeaderParams, AlgorandChainTransactionParamsStruct } from './models'
-import { ALGORAND_TRX_COMFIRMATION_ROUNDS, ALGORAND_EMPTY_CONTRACT_NAME } from './algoConstants'
+import {
+  ALGORAND_CHAIN_BLOCK_FREQUENCY,
+  ALGORAND_DEFAULT_TRANSACTION_VALID_BLOCKS,
+  ALGORAND_EMPTY_CONTRACT_NAME,
+} from './algoConstants'
 import { toAlgorandAddressFromRaw, toRawAddressFromAlgoAddr } from './helpers'
 
 /** Helper class to ensure transaction actions properties are set correctly
@@ -212,12 +217,20 @@ export class AlgorandActionHelper {
 
   /** Adds the latest transaction header fields (firstRound, etc.) from chain
    *  Applies any that are not already provided in the action */
-  applyCurrentTxHeaderParamsWhereNeeded(chainTxParams: AlgorandChainTransactionParamsStruct) {
+  applyCurrentTxHeaderParamsWhereNeeded(
+    chainTxParams: AlgorandChainTransactionParamsStruct,
+    transactionOptions?: AlgorandTransactionOptions,
+  ) {
     const rawAction = this.raw
+    // calculate last block
+    const numberOfBlockValidFor = transactionOptions?.expireSeconds
+      ? transactionOptions?.expireSeconds * ALGORAND_CHAIN_BLOCK_FREQUENCY
+      : ALGORAND_DEFAULT_TRANSACTION_VALID_BLOCKS
+    const lastValidBlock = rawAction.firstRound + numberOfBlockValidFor
     rawAction.genesisID = rawAction.genesisID || chainTxParams.genesisID
     rawAction.genesisHash = rawAction.genesisHash || toBuffer(chainTxParams.genesisHash, 'base64')
     rawAction.firstRound = rawAction.firstRound || chainTxParams.firstRound
-    rawAction.lastRound = rawAction.lastRound || rawAction.firstRound + ALGORAND_TRX_COMFIRMATION_ROUNDS
+    rawAction.lastRound = rawAction.lastRound || lastValidBlock
     rawAction.fee = rawAction.fee || chainTxParams.minFee
     rawAction.flatFee = true // since we're setting a fee, this will always be true - flatFee is just a hint to the AlgoSDK.Tx object which will set its own fee if this is not true
   }

src/chains/algorand_1/algoConstants.ts

@@ -9,14 +9,16 @@ export const PUBLIC_KEY_LENGTH = nacl.sign.publicKeyLength
 export const ALGORAND_EMPTY_CONTRACT_NAME = 'none'
 export const ALGORAND_POST_CONTENT_TYPE = { 'content-type': 'application/x-binary' }
 /** Number of rounds to wait after the first round for the transaction confirmation */
-export const ALGORAND_TRX_COMFIRMATION_ROUNDS = 1000
+export const ALGORAND_DEFAULT_TRANSACTION_VALID_BLOCKS = 1000
 export const DEFAULT_TIMEOUT_FOR_TRX_CONFIRM = 500
 export const DEFAULT_ALGO_UNIT = AlgorandUnit.Microalgo
 
 /** number of chain blocks to poll after submitting a transaction before failing */
 export const DEFAULT_BLOCKS_TO_CHECK = 20
 /** time to wait (in ms) between checking chain for a new block (to see if transaction appears within it) */
 export const DEFAULT_CHECK_INTERVAL = 500
+/** time in seconds between blocks */
+export const ALGORAND_CHAIN_BLOCK_FREQUENCY = 2
 /** number of times to attempt to read a chain endpoint before failing the read */
 export const DEFAULT_GET_BLOCK_ATTEMPTS = 10
 

src/chains/algorand_1/algoTransaction.ts

@@ -8,6 +8,7 @@ import { throwNewError } from '../../errors'
 import {
   byteArrayToHexString,
   hexStringToByteArray,
+  isANumber,
   isArrayLengthOne,
   isNullOrEmpty,
   notImplemented,
@@ -79,7 +80,7 @@ export class AlgorandTransaction implements Transaction {
   constructor(chainState: AlgorandChainState, options?: AlgorandTransactionOptions) {
     this._chainState = chainState
     this.assertValidOptions(options)
-    this._options = options || {}
+    this.applyOptions(options)
   }
 
   /** Chain-specific values included in the transaction sent to the chain */
@@ -188,7 +189,7 @@ export class AlgorandTransaction implements Transaction {
       this._algoSdkTransaction = null
     } else {
       const chainTxHeaderParams = this._chainState.chainInfo.nativeInfo.transactionHeaderParams
-      this._actionHelper.applyCurrentTxHeaderParamsWhereNeeded(chainTxHeaderParams)
+      this._actionHelper.applyCurrentTxHeaderParamsWhereNeeded(chainTxHeaderParams, this.options)
       this._algoSdkTransaction = new AlgoTransactionClass(this._actionHelper.actionEncodedForSdk)
     }
   }
@@ -579,13 +580,26 @@ export class AlgorandTransaction implements Transaction {
 
   /** Throws if from is not null or empty algorand argument */
   private assertValidOptions(options: AlgorandTransactionOptions): void {
+    if (options?.expireSeconds && !isANumber(options.expireSeconds)) {
+      throwNewError('Invalid transaction options: ExpireSeconds is not a number')
+    }
     if (options?.multiSigOptions && options?.signerPublicKey) {
       throwNewError(
         'Invalid transaction options: Provide multiSigOptions OR signerPublicKey - not both. The signerPublicKey is for non-multisig transasctions only',
       )
     }
   }
 
+  /** apply options and/or use defaults */
+  private applyOptions(options: AlgorandTransactionOptions) {
+    const { multiSigOptions, signerPublicKey } = options || {}
+    let { expireSeconds, fee, flatFee } = options || {}
+    expireSeconds = expireSeconds ?? this._chainState?.chainSettings?.defaultTransactionSettings?.expireSeconds
+    fee = fee ?? this._chainState?.chainSettings?.defaultTransactionSettings?.fee
+    flatFee = flatFee ?? this._chainState?.chainSettings?.defaultTransactionSettings?.flatFee
+    this._options = { expireSeconds, fee, flatFee, multiSigOptions, signerPublicKey }
+  }
+
   /** Whether the transaction signature is valid for this transaction body and publicKey provided */
   private isValidTxSignatureForPublicKey(signature: AlgorandSignature, publicKey: AlgorandPublicKey): boolean {
     if (!this.rawTransaction) return false

src/chains/algorand_1/models/transactionModels.ts

@@ -56,6 +56,8 @@ export type AlgorandSuggestedParams = {
 
 /** Transaction 'header' options set to chain along with the content type */
 export type AlgorandTransactionOptions = {
+  /** Number of seconds after which transaction expires - must be submitted to the chain before then */
+  expireSeconds?: number
   fee?: AlgorandValue
   flatFee?: boolean
   multiSigOptions?: AlgorandMultiSigOptions

src/chains/ethereum_1/models/cryptoModels.ts

@@ -16,7 +16,7 @@ export type EthereumPublicKey = string & PublicKeyBrand
 /** a signature string - formatted correcly for ethereum */
 export type EthereumSignature = ECDSASignature & SignatureBrand
 
-/** key pair - in the format returned from algosdk */
+/** key pair - in the format returned from ethereum */
 export type EthereumKeyPair = {
   publicKey: EthereumPublicKey
   privateKey: EthereumPrivateKey