Merge pull request #120 from Juneo-io/dev

v0.0.98

package.json

@@ -1,6 +1,6 @@
 {
   "name": "juneojs",
-  "version": "0.0.97",
+  "version": "0.0.98",
   "description": "Juneo JS Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/api/data.ts

@@ -1,4 +1,4 @@
-import { now } from '../utils'
+import { TimeUtils } from '../utils'
 import { type JsonRpcRequest, type JsonRpcResponse, type JuneoClient } from './client'
 
 export class CachedResponse<T> {
@@ -30,7 +30,7 @@ export class CachedResponse<T> {
     if (this.duration === undefined) {
       return false
     }
-    const currentTime: bigint = now()
+    const currentTime: bigint = TimeUtils.now()
     const update: boolean = currentTime >= this.lastUpdate + this.duration
     if (update) {
       this.lastUpdate = currentTime

src/chain/chain.ts

@@ -1,16 +1,10 @@
 import { type TokenAsset } from '../asset'
-import { type MCNProvider } from '../juneo'
-
-export enum VMAccountType {
-  Utxo = 'Utxo',
-  Nonce = 'Nonce',
-}
+import { type ChainVM, type MCNProvider } from '../juneo'
 
 export interface Blockchain {
   name: string
   id: string
-  vmId: string
-  accountType: VMAccountType
+  vm: ChainVM
   asset: TokenAsset
   assetId: string
   aliases: string[]
@@ -27,8 +21,7 @@ export interface Blockchain {
 export abstract class AbstractBlockchain implements Blockchain {
   name: string
   id: string
-  vmId: string
-  accountType: VMAccountType
+  vm: ChainVM
   asset: TokenAsset
   assetId: string
   aliases: string[]
@@ -37,16 +30,14 @@ export abstract class AbstractBlockchain implements Blockchain {
   constructor (
     name: string,
     id: string,
-    vmId: string,
-    accountType: VMAccountType,
+    vm: ChainVM,
     asset: TokenAsset,
     aliases: string[] = [],
     registeredAssets: TokenAsset[] = []
   ) {
     this.name = name
     this.id = id
-    this.vmId = vmId
-    this.accountType = accountType
+    this.vm = vm
     this.asset = asset
     this.assetId = asset.assetId
     this.aliases = aliases

src/chain/index.ts

@@ -3,3 +3,4 @@ export * from './jevm'
 export * from './jvm'
 export * from './platform'
 export * from './solidity'
+export * from './vm'

src/chain/jevm.ts

@@ -1,15 +1,18 @@
 import { ethers } from 'ethers'
-import { ChainError, fetchJNT, isContractAddress } from '../utils'
-import { AssetId } from '../transaction'
 import { type JEVMAPI } from '../api'
-import { ERC20TokenHandler, ContractManager, type SolidityTokenHandler } from './solidity'
-import { type TokenAsset, type JRC20Asset, type JEVMGasToken, TokenType, type WrappedAsset } from '../asset'
-import { AbstractBlockchain, VMAccountType } from './chain'
+import { type JEVMGasToken, type JRC20Asset, type TokenAsset, TokenType, type WrappedAsset } from '../asset'
 import { type MCNProvider } from '../juneo'
+import { AssetId } from '../transaction'
+import { ChainError, fetchJNT, isContractAddress } from '../utils'
+import { AbstractBlockchain } from './chain'
+import { ContractManager, ERC20TokenHandler, type SolidityTokenHandler } from './solidity'
+import { ChainVM, VMWalletType } from './vm'
 
 export const JEVM_ID: string = 'orkbbNQVf27TiBe6GqN5dm8d8Lo3rutEov8DUWZaKNUjckwSk'
 export const EVM_ID: string = 'mgj786NP7uDwBCcq6YwThhaN8FLyybkCa4zBWTQbNgmK6k9A6'
 
+const HD_PATH = 60
+
 export const NativeAssetBalanceContract: string = '0x0100000000000000000000000000000000000001'
 export const NativeAssetCallContract: string = '0x0100000000000000000000000000000000000002'
 
@@ -37,7 +40,7 @@ export class JEVMBlockchain extends AbstractBlockchain {
     jrc20Assets: JRC20Asset[] = [],
     wrappedAsset?: WrappedAsset | undefined
   ) {
-    super(name, id, JEVM_ID, VMAccountType.Nonce, asset, aliases, registeredAssets)
+    super(name, id, new ChainVM(JEVM_ID, VMWalletType.Nonce, HD_PATH), asset, aliases, registeredAssets)
     this.asset = asset
     this.chainId = chainId
     this.baseFee = baseFee

src/chain/jvm.ts

@@ -1,13 +1,16 @@
-import { fetchJNT, validateBech32 } from '../utils'
-import { type TokenAsset, type JNTAsset } from '../asset'
-import { AbstractBlockchain, VMAccountType } from './chain'
+import { type JNTAsset, type TokenAsset } from '../asset'
 import { type MCNProvider } from '../juneo'
+import { fetchJNT, validateBech32 } from '../utils'
+import { AbstractBlockchain } from './chain'
+import { ChainVM, VMWalletType } from './vm'
 
 export const JVM_ID: string = 'otSmSxFRBqdRX7kestRW732n3WS2MrLAoWwHZxHnmMGMuLYX8'
 
+const HD_PATH = 9000
+
 export class JVMBlockchain extends AbstractBlockchain {
   constructor (name: string, id: string, asset: JNTAsset, aliases?: string[], registeredAssets: TokenAsset[] = []) {
-    super(name, id, JVM_ID, VMAccountType.Utxo, asset, aliases, registeredAssets)
+    super(name, id, new ChainVM(JVM_ID, VMWalletType.Utxo, HD_PATH), asset, aliases, registeredAssets)
   }
 
   protected async fetchAsset (provider: MCNProvider, assetId: string): Promise<TokenAsset> {

src/chain/platform.ts

@@ -1,10 +1,13 @@
-import { fetchJNT, now, RewardCalculator, validateBech32 } from '../utils'
-import { type TokenAsset, type JNTAsset } from '../asset'
-import { AbstractBlockchain, VMAccountType } from './chain'
+import { type JNTAsset, type TokenAsset } from '../asset'
 import { type MCNProvider } from '../juneo'
+import { fetchJNT, RewardCalculator, TimeUtils, validateBech32 } from '../utils'
+import { AbstractBlockchain } from './chain'
+import { ChainVM, VMWalletType } from './vm'
 
 export const PLATFORMVM_ID: string = '11111111111111111111111111111111LpoYY'
 
+const HD_PATH = 9000
+
 const BaseShare: number = 100_0000 // 100%
 
 export class PlatformBlockchain extends AbstractBlockchain {
@@ -21,7 +24,7 @@ export class PlatformBlockchain extends AbstractBlockchain {
     aliases?: string[],
     registeredAssets: TokenAsset[] = []
   ) {
-    super(name, id, PLATFORMVM_ID, VMAccountType.Utxo, asset, aliases, registeredAssets)
+    super(name, id, new ChainVM(PLATFORMVM_ID, VMWalletType.Utxo, HD_PATH), asset, aliases, registeredAssets)
     this.stakeConfig = stakeConfig
     this.rewardConfig = rewardConfig
     this.rewardCalculator = new RewardCalculator(rewardConfig)
@@ -36,11 +39,11 @@ export class PlatformBlockchain extends AbstractBlockchain {
   }
 
   estimatePrimaryValidationReward (stakePeriod: bigint, stakeAmount: bigint): bigint {
-    return this.rewardCalculator.calculatePrimary(stakePeriod, now(), stakeAmount)
+    return this.rewardCalculator.calculatePrimary(stakePeriod, TimeUtils.now(), stakeAmount)
   }
 
   estimatePrimaryDelegationReward (stakePeriod: bigint, stakeAmount: bigint): bigint {
-    const rewards: bigint = this.rewardCalculator.calculatePrimary(stakePeriod, now(), stakeAmount)
+    const rewards: bigint = this.rewardCalculator.calculatePrimary(stakePeriod, TimeUtils.now(), stakeAmount)
     return (rewards * BigInt(BaseShare - this.stakeConfig.minDelegationFee)) / BigInt(BaseShare)
   }
 }

src/chain/solidity/abi.ts

@@ -29,10 +29,3 @@ export const WrappedABI: string[] = ERC20ABI.concat([
   'event Deposit(address indexed dst, uint wad)',
   'event Withdrawal(address indexed src, uint wad)'
 ])
-
-export const AuctionABI: string[] = ['function redeemAuction(uint256 auctionId)']
-
-export const StreamABI: string[] = [
-  'function withdrawFromStream(uint256 streamId, uint256 amount) returns (bool)',
-  'function cancelStream(uint256 streamId) returns (bool)'
-]

src/chain/solidity/contract.ts

@@ -1,7 +1,7 @@
 import { ethers } from 'ethers'
-import * as abi from './abi'
-import { AssetId } from '../../transaction'
 import { ERC20Asset, type TokenAsset } from '../../asset'
+import { AssetId } from '../../transaction'
+import * as abi from './abi'
 
 export class ContractManager {
   private readonly handlers: SolidityTokenHandler[] = []
@@ -120,27 +120,3 @@ export class WrappedContractAdapter extends EVMCallAdapter {
     return this.getFunctionData('deposit')
   }
 }
-
-export class AuctionContractAdapter extends EVMCallAdapter {
-  constructor (contractAddress: string) {
-    super(contractAddress, abi.AuctionABI)
-  }
-
-  getRedeemAuctionData (auctionId: bigint): string {
-    return this.getFunctionData('redeemAuction', [auctionId])
-  }
-}
-
-export class StreamContractAdapter extends EVMCallAdapter {
-  constructor (contractAddress: string) {
-    super(contractAddress, abi.StreamABI)
-  }
-
-  getWithdrawFromStreamData (streamId: bigint, amount: bigint): string {
-    return this.getFunctionData('withdrawFromStream', [streamId, amount])
-  }
-
-  getCancelStreamData (streamId: bigint): string {
-    return this.getFunctionData('cancelStream', [streamId])
-  }
-}

src/chain/vm.ts

@@ -0,0 +1,16 @@
+export enum VMWalletType {
+  Utxo = 'Utxo',
+  Nonce = 'Nonce',
+}
+
+export class ChainVM {
+  id: string
+  walletType: VMWalletType
+  hdPath: number
+
+  constructor (id: string, walletType: VMWalletType, hdPath: number) {
+    this.id = id
+    this.walletType = walletType
+    this.hdPath = hdPath
+  }
+}

src/juneo.ts

@@ -27,7 +27,7 @@ export class MCNProvider {
     this.juneApi = new JEVMAPI(client, this.juneChain)
     for (const supernet of this.mcn.supernets) {
       for (const chain of supernet.chains) {
-        if (chain.vmId === JEVM_ID) {
+        if (chain.vm.id === JEVM_ID) {
           this.jevmApi[chain.id] = new JEVMAPI(client, chain as JEVMBlockchain)
         }
       }

src/transaction/builder.ts

@@ -1,9 +1,8 @@
-import { InputError, OutputError } from '../utils'
+import { InputError, OutputError, TimeUtils } from '../utils'
 import { Secp256k1Input, type Spendable, TransferableInput, type UserInput } from './input'
 import { Secp256k1Output, Secp256k1OutputTypeId, type TransactionOutput, UserOutput, type Utxo } from './output'
-import * as time from '../utils/time'
-import { Address, AssetId } from './types'
 import { type TransactionFee } from './transaction'
+import { Address, AssetId } from './types'
 
 export function buildTransactionInputs (
   userInputs: UserInput[],
@@ -47,7 +46,7 @@ export function buildTransactionInputs (
     }
     const output: Secp256k1Output = utxo.output as Secp256k1Output
     // output cannot be consumed because it is timelocked
-    if (output.locktime > time.now()) {
+    if (output.locktime > TimeUtils.now()) {
       continue
     }
     // The utxo will be added as an input in any case

src/transaction/jevm/status.ts

@@ -1,5 +1,5 @@
 import { type JEVMAPI } from '../../api'
-import { sleep } from '../../utils'
+import { TimeUtils } from '../../utils'
 import { type TransactionStatusFetcher, TransactionStatusFetchDelay } from '../transaction'
 
 export enum JEVMTransactionStatus {
@@ -23,7 +23,7 @@ export class JEVMTransactionStatusFetcher implements TransactionStatusFetcher {
   async fetch (timeout: number, delay: number = TransactionStatusFetchDelay): Promise<string> {
     const maxAttempts: number = timeout / delay
     while (this.attempts < maxAttempts && !this.isCurrentStatusSettled()) {
-      await sleep(delay)
+      await TimeUtils.sleep(delay)
       await this.jevmApi.getTxStatus(this.transactionId).then(
         (value) => {
           this.currentStatus = value.status
@@ -68,7 +68,7 @@ export class EVMTransactionStatusFetcher implements TransactionStatusFetcher {
     const maxAttempts: number = timeout / delay
     this.currentStatus = EVMTransactionStatus.Pending
     while (this.attempts < maxAttempts && !this.isCurrentStatusSettled()) {
-      await sleep(delay)
+      await TimeUtils.sleep(delay)
       const receipt: any = await this.jevmApi.eth_getTransactionReceipt(this.transactionHash).catch(() => {
         return null
       })

src/transaction/jvm/status.ts

@@ -1,5 +1,5 @@
 import { type JVMAPI } from '../../api'
-import { sleep } from '../../utils'
+import { TimeUtils } from '../../utils'
 import { type TransactionStatusFetcher, TransactionStatusFetchDelay } from '../transaction'
 
 export enum JVMTransactionStatus {
@@ -23,7 +23,7 @@ export class JVMTransactionStatusFetcher implements TransactionStatusFetcher {
     const maxAttempts: number = timeout / delay
     this.currentStatus = JVMTransactionStatus.Processing
     while (this.attempts < maxAttempts && !this.isCurrentStatusSettled()) {
-      await sleep(delay)
+      await TimeUtils.sleep(delay)
       await this.jvmApi.getTx(this.transactionId).then(
         () => {
           this.currentStatus = JVMTransactionStatus.Accepted