Alpha

.eslintrc.json

@@ -4,7 +4,11 @@
         "es2021": true,
         "node": true
     },
-    "extends": ["standard-with-typescript", "plugin:prettier/recommended"],
+    "extends": [
+        "plugin:jsdoc/recommended-typescript-error",
+        "standard-with-typescript",
+        "plugin:prettier/recommended"
+    ],
     "overrides": [
         {
             "env": {
@@ -21,7 +25,7 @@
         "ecmaVersion": "latest",
         "sourceType": "module"
     },
-    "plugins": ["prettier", "filenames"],
+    "plugins": ["jsdoc", "prettier", "filenames"],
     "rules": {
         "@typescript-eslint/no-misused-promises": [
             "error",

package.json

@@ -21,6 +21,7 @@
     "eslint-config-standard-with-typescript": "^43.0.1",
     "eslint-plugin-filenames": "^1.3.2",
     "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsdoc": "^48.2.9",
     "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-promise": "^6.1.1",

packages/networks/bitcoin/src/assets/Coin.ts

@@ -17,36 +17,36 @@ export class Coin implements CoinInterface<TransactionSigner> {
     provider: Provider
 
     /**
-     * @param {Provider} provider network provider
+     * @param provider network provider
      */
     constructor(provider?: Provider) {
         this.provider = provider ?? Provider.instance
     }
 
     /**
-     * @returns {string} Coin name
+     * @returns Coin name
      */
     getName(): string {
         return 'Bitcoin'
     }
 
     /**
-     * @returns {string} Coin symbol
+     * @returns Coin symbol
      */
     getSymbol(): string {
         return 'BTC'
     }
 
     /**
-     * @returns {number} Decimal value of the coin
+     * @returns Decimal value of the coin
      */
     getDecimals(): number {
         return 8
     }
 
     /**
-     * @param {WalletAddress} owner Wallet address
-     * @returns {Promise<number>} Wallet balance as currency of COIN
+     * @param owner Wallet address
+     * @returns Wallet balance as currency of COIN
      */
     async getBalance(owner: WalletAddress): Promise<number> {
         const addressStatsApi = this.provider.createEndpoint('address/' + owner)
@@ -57,10 +57,10 @@ export class Coin implements CoinInterface<TransactionSigner> {
     }
 
     /**
-     * @param {WalletAddress} sender Sender wallet address
-     * @param {WalletAddress} receiver Receiver wallet address
-     * @param {TransferAmount} amount Amount of assets that will be transferred
-     * @returns {Promise<TransactionSigner>} Transaction signer
+     * @param sender Sender wallet address
+     * @param receiver Receiver wallet address
+     * @param amount Amount of assets that will be transferred
+     * @returns Transaction signer
      */
     async transfer(
         sender: WalletAddress,

packages/networks/bitcoin/src/browser/Wallet.ts

@@ -43,53 +43,53 @@ export class Wallet implements WalletInterface<Provider, WalletProvider, Transac
     networkProvider: Provider
 
     /**
-     * @param {WalletAdapter} adapter
-     * @param {Provider} provider
+     * @param adapter - Wallet adapter
+     * @param provider - Network provider
      */
     constructor(adapter: WalletAdapter, provider?: Provider) {
         this.adapter = adapter
         this.networkProvider = provider ?? Provider.instance
     }
 
     /**
-     * @returns {string}
+     * @returns Wallet ID
      */
     getId(): string {
         return this.adapter.id
     }
 
     /**
-     * @returns {string}
+     * @returns Wallet name
      */
     getName(): string {
         return this.adapter.name
     }
 
     /**
-     * @returns {string}
+     * @returns Wallet icon
      */
     getIcon(): string {
         return this.adapter.icon
     }
 
     /**
-     * @returns {WalletPlatformEnum[]}
+     * @returns Wallet platforms
      */
     getPlatforms(): WalletPlatformEnum[] {
         return this.adapter.platforms
     }
 
     /**
-     * @returns {string}
+     * @returns Wallet download link
      */
     getDownloadLink(): string | undefined {
         return this.adapter.downloadLink
     }
 
     /**
-     * @param {string} url
-     * @param {UnknownConfig} config
-     * @returns {string}
+     * @param url url for deep linking
+     * @param config configuration for deep linking
+     * @returns deep link
      */
     createDeepLink(url: string, config?: UnknownConfig): string | null {
         if (this.adapter.createDeepLink === undefined) {
@@ -100,8 +100,8 @@ export class Wallet implements WalletInterface<Provider, WalletProvider, Transac
     }
 
     /**
-     * @param {ConnectConfig} config
-     * @returns {Promise<WalletAddress>}
+     * @param config connection configuration
+     * @returns WalletAddress
      */
     async connect(config?: ConnectConfig): Promise<WalletAddress> {
         return await new Promise((resolve, reject) => {
@@ -125,29 +125,29 @@ export class Wallet implements WalletInterface<Provider, WalletProvider, Transac
     }
 
     /**
-     * @returns {boolean}
+     * @returns wallet detection status
      */
     async isDetected(): Promise<boolean> {
         return await this.adapter.isDetected()
     }
 
     /**
-     * @returns {boolean}
+     * @returns connection status
      */
     async isConnected(): Promise<boolean> {
         return await this.adapter.isConnected()
     }
 
     /**
-     * @returns {Promise<WalletAddress>}
+     * @returns wallet address
      */
     async getAddress(): Promise<WalletAddress> {
         return await this.walletProvider.getAddress()
     }
 
     /**
-     * @param {string} message
-     * @returns {Promise<SignedMessage>}
+     * @param message message to sign
+     * @returns signed message
      */
     async signMessage(message: string): Promise<SignedMessage> {
         return await new Promise((resolve, reject) => {
@@ -163,8 +163,8 @@ export class Wallet implements WalletInterface<Provider, WalletProvider, Transac
     }
 
     /**
-     * @param {TransactionSigner} transactionSigner
-     * @returns {Promise<TransactionId>}
+     * @param transactionSigner transaction signer
+     * @returns transaction id
      */
     async sendTransaction(transactionSigner: TransactionSigner): Promise<TransactionId> {
         const data = transactionSigner.getRawData()
@@ -181,9 +181,8 @@ export class Wallet implements WalletInterface<Provider, WalletProvider, Transac
     }
 
     /**
-     * @param {string} eventName
-     * @param {Function} callback
-     * @returns {void}
+     * @param eventName event name
+     * @param callback event callback
      */
     on(eventName: string, callback: (...args: any[]) => void): void {
         this.walletProvider.on(eventName, callback)

packages/networks/bitcoin/src/models/CoinTransaction.ts

@@ -5,33 +5,33 @@ import type { WalletAddress, CoinTransactionInterface, TransferAmount } from '@m
 
 export class CoinTransaction extends Transaction implements CoinTransactionInterface {
     /**
-     * @returns {Promise<WalletAddress>} Wallet address of the receiver of transaction
+     * @returns Wallet address of the receiver of transaction
      */
     async getReceiver(): Promise<WalletAddress> {
         const data = await this.getData()
         return data?.vout[0].scriptpubkey_address ?? ''
     }
 
     /**
-     * @returns {Promise<WalletAddress>} Wallet address of the sender of transaction
+     * @returns Wallet address of the sender of transaction
      */
     async getSender(): Promise<WalletAddress> {
         return await this.getSigner()
     }
 
     /**
-     * @returns {Promise<TransferAmount>} Amount of coin that will be transferred
+     * @returns Amount of coin that will be transferred
      */
     async getAmount(): Promise<TransferAmount> {
         const data = await this.getData()
         return fromSatoshi(data?.vout[0].value ?? 0)
     }
 
     /**
-     * @param {AssetDirectionEnum} direction - Direction of the transaction (asset)
-     * @param {WalletAddress} address - Wallet address of the receiver or sender of the transaction, dependant on direction
-     * @param {TransferAmount} amount Amount of assets that will be transferred
-     * @returns {Promise<TransactionStatusEnum>} Status of the transaction
+     * @param direction - Direction of the transaction (asset)
+     * @param address - Wallet address of the receiver or sender of the transaction, dependant on direction
+     * @param amount Amount of assets that will be transferred
+     * @returns Status of the transaction
      */
     async verifyTransfer(
         direction: AssetDirectionEnum,

packages/networks/bitcoin/src/models/Transaction.ts

@@ -74,16 +74,16 @@ export class Transaction implements TransactionInterface<TransactionData> {
     data: TransactionData | null = null
 
     /**
-     * @param {TransactionId} id Transaction id
-     * @param {Provider} provider Blockchain network provider
+     * @param id Transaction id
+     * @param provider Blockchain network provider
      */
     constructor(id: TransactionId, provider?: Provider) {
         this.id = id
         this.provider = provider ?? Provider.instance
     }
 
     /**
-     * @returns {Promise<TransactionData | null>} Transaction data
+     * @returns Transaction data
      */
     async getData(): Promise<TransactionData | null> {
         if (this.data !== null) {
@@ -113,8 +113,8 @@ export class Transaction implements TransactionInterface<TransactionData> {
     }
 
     /**
-     * @param {number} ms - Milliseconds to wait for the transaction to be confirmed. Default is 4000ms
-     * @returns {Promise<TransactionStatusEnum>} Status of the transaction
+     * @param ms - Milliseconds to wait for the transaction to be confirmed. Default is 4000ms
+     * @returns Status of the transaction
      */
     async wait(ms: number = 4000): Promise<TransactionStatusEnum> {
         return await new Promise((resolve, reject) => {
@@ -138,60 +138,60 @@ export class Transaction implements TransactionInterface<TransactionData> {
     }
 
     /**
-     * @returns {TransactionId} Transaction ID
+     * @returns Transaction ID
      */
     getId(): TransactionId {
         return this.id
     }
 
     /**
-     * @returns {Promise<TransactionTypeEnum>} Transaction type
+     * @returns Transaction type
      */
     async getType(): Promise<TransactionTypeEnum> {
         return TransactionTypeEnum.COIN
     }
 
     /**
-     * @returns {string} Transaction URL
+     * @returns Transaction URL
      */
     getUrl(): string {
         return this.provider.explorer + 'tx/' + this.id
     }
 
     /**
-     * @returns {Promise<WalletAddress>} Wallet address of the sender of transaction
+     * @returns Wallet address of the sender of transaction
      */
     async getSigner(): Promise<WalletAddress> {
         const data = await this.getData()
         return data?.vin[0].prevout.scriptpubkey_address ?? ''
     }
 
     /**
-     * @returns {Promise<TransactionFee>} Transaction fee
+     * @returns Transaction fee
      */
     async getFee(): Promise<TransactionFee> {
         const data = await this.getData()
         return fromSatoshi(data?.fee ?? 0)
     }
 
     /**
-     * @returns {Promise<BlockNumber>} Block number that transaction
+     * @returns Block number that transaction
      */
     async getBlockNumber(): Promise<BlockNumber> {
         const data = await this.getData()
         return data?.status?.block_height ?? 0
     }
 
     /**
-     * @returns {Promise<BlockTimestamp>} Block timestamp that transaction
+     * @returns Block timestamp that transaction
      */
     async getBlockTimestamp(): Promise<BlockTimestamp> {
         const data = await this.getData()
         return data?.status?.block_time ?? 0
     }
 
     /**
-     * @returns {Promise<BlockConfirmationCount>} Confirmation count of the block
+     * @returns Confirmation count of the block
      */
     async getBlockConfirmationCount(): Promise<BlockConfirmationCount> {
         const data = await this.getData()
@@ -203,7 +203,7 @@ export class Transaction implements TransactionInterface<TransactionData> {
     }
 
     /**
-     * @returns {Promise<TransactionStatusEnum>} Status of the transaction
+     * @returns Status of the transaction
      */
     async getStatus(): Promise<TransactionStatusEnum> {
         const data = await this.getData()