Beycan

.env.example

@@ -43,4 +43,43 @@ EVM_ETHER_TRANSFER_TX='0x566002399664e92f82ed654c181095bdd7ff3d3f1921d9632575858
 EVM_TOKEN_TRANSFER_TX='0xdabda3905e585db91768f2ef877f7fbef7c0e8612c0a09c7b379981bdbc48975'
 EVM_NFT_TRANSFER_TX='0x272a4698cd2062f2463481cf9eb78b68b35d59938383679b7642e6d669ac87eb'
 # Models
-# EVM CHAINS
+# EVM CHAINS
+
+#TRON
+# Assets
+TRON_COIN_TRANSFER_TEST_IS_ACTIVE=false
+TRON_TOKEN_TRANSFER_TEST_IS_ACTIVE=false
+TRON_TOKEN_APPROVE_TEST_IS_ACTIVE=false
+TRON_TOKEN_TRANSFER_FROM_TEST_IS_ACTIVE=false
+TRON_NFT_TRANSACTION_TEST_IS_ACTIVE=false
+TRON_TRANSACTION_LISTENER_TEST_IS_ACTIVE=false
+
+TRON_COIN_BALANCE_TEST_AMOUNT=10
+TRON_TOKEN_BALANCE_TEST_AMOUNT=20
+TRON_NFT_BALANCE_TEST_AMOUNT=2
+TRON_TRANSFER_TEST_AMOUNT=0.0001
+TRON_TOKEN_TRANSFER_TEST_AMOUNT=1
+TRON_TOKEN_APPROVE_TEST_AMOUNT=10
+TRON_NFT_TRANSFER_ID=7
+
+TRON_BALANCE_TEST_ADDRESS='TS1WYZNoNw32hog68m5GyhwZnkhf6HNzhi'
+TRON_SENDER_PRIVATE_KEY='aba68e5764a8bf9bdcf711f83bab9395317b8acb17298ca487c1aede3ed0e6cf'
+TRON_RECEIVER_PRIVATE_KEY='318bfadf97af289888f4a3864002322535e1ee95b5a7b5abdf76602513dd8b69'
+TRON_SENDER_TEST_ADDRESS='TNukrtF5dwy77dWKaVSKocWsGWpQ53iffj'
+TRON_RECEIVER_TEST_ADDRESS='TSVufyvTBhWPMbvAaZr6ESYszpzXfBs8WA'
+TRON_TOKEN_TEST_ADDRESS='TJkmHT9gWNyELDaCbz9ui5PPQ6EPezgegu'
+TRON_NFT_TEST_ADDRESS='TPnBfSVwZHaGUfjXNzsnHbnyJ8Ui13x27P'
+# Assets
+
+# Models
+TRON_NFT_ID=8
+TRON_TOKEN_AMOUNT=20
+TRON_COIN_AMOUNT=10
+
+TRON_MODEL_TEST_SENDER='TNukrtF5dwy77dWKaVSKocWsGWpQ53iffj'
+TRON_MODEL_TEST_RECEIVER='TS1WYZNoNw32hog68m5GyhwZnkhf6HNzhi'
+
+TRON_TRX_TRANSFER_TX='8697ad2c4e1713227c16a65a5845636458df2d3db3adf526e07e17699bc6b3c4'
+TRON_TOKEN_TRANSFER_TX='bd0ba6ebb8d2f910b27de1565c66cc89337b792dfdb6484847c817ccbd240760'
+TRON_NFT_TRANSFER_TX='d5dd97c09efdb93f36808a9f8e14642ef226880aa91a846583d4ce98c0084637'
+#TRON

.eslintrc.json

@@ -23,6 +23,12 @@
     },
     "plugins": ["prettier", "filenames"],
     "rules": {
+        "@typescript-eslint/no-misused-promises": [
+            "error",
+            {
+                "checksVoidReturn": false
+            }
+        ],
         "filenames/match-exported": ["error", "pascal"]
     },
     "ignorePatterns": [

packages/networks/boilerplate/package.json

@@ -17,6 +17,14 @@
                 "default": "./dist/index.cjs",
                 "types": "./dist/index.d.ts"
             }
+        },
+        "./node": {
+            "require": "./dist/index.cjs",
+            "types": "./dist/index.d.ts"
+        },
+        "./browser": {
+            "require": "./dist/index.umd.js",
+            "types": "./dist/browser/index.d.ts"
         }
     },
     "files": [
@@ -25,6 +33,7 @@
         "!tsconfig.tsbuildinfo"
     ],
     "scripts": {
+        "dev": "vite",
         "clean": "rm -rf dist",
         "watch": "tsc --watch",
         "build:vite": "vite build",
@@ -52,7 +61,7 @@
         "url": "https://github.com/MultipleChain/js/issues"
     },
     "dependencies": {
-        "@multiplechain/types": "^0.1.53",
+        "@multiplechain/types": "^0.1.55",
         "@multiplechain/utils": "^0.1.18"
     }
 }

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

@@ -1,6 +1,6 @@
 import { Provider } from '../services/Provider.ts'
-import { TransactionSigner } from '../services/TransactionSigner.ts'
-import type { CoinInterface, TransactionSignerInterface } from '@multiplechain/types'
+import type { CoinInterface } from '@multiplechain/types'
+import { CoinTransactionSigner } from '../services/TransactionSigner.ts'
 
 export class Coin implements CoinInterface {
     /**
@@ -54,7 +54,7 @@ export class Coin implements CoinInterface {
         sender: string,
         receiver: string,
         amount: number
-    ): Promise<TransactionSignerInterface> {
-        return new TransactionSigner('example')
+    ): Promise<CoinTransactionSigner> {
+        return new CoinTransactionSigner('example')
     }
 }

packages/networks/boilerplate/src/assets/Contract.ts

@@ -45,4 +45,14 @@ export class Contract implements ContractInterface {
     async getMethodData(method: string, ...args: any[]): Promise<any> {
         return {}
     }
+
+    /**
+     * @param {string} method Method name
+     * @param {string} from Sender wallet address
+     * @param {any[]} args Method parameters
+     * @returns {Promise<any>} Encoded method data
+     */
+    async createTransactionData(method: string, from: string, ...args: any[]): Promise<any> {
+        return ''
+    }
 }

packages/networks/boilerplate/src/assets/NFT.ts

@@ -1,6 +1,6 @@
 import { Contract } from './Contract.ts'
-import { TransactionSigner } from '../services/TransactionSigner.ts'
-import type { NftInterface, TransactionSignerInterface } from '@multiplechain/types'
+import type { NftInterface } from '@multiplechain/types'
+import { NftTransactionSigner } from '../services/TransactionSigner.ts'
 
 export class NFT extends Contract implements NftInterface {
     /**
@@ -26,71 +26,71 @@ export class NFT extends Contract implements NftInterface {
     }
 
     /**
-     * @param {number} nftId NFT ID
+     * @param {number | string} nftId NFT ID
      * @returns {Promise<string>} Wallet address of the owner of the NFT
      */
-    async getOwner(nftId: number): Promise<string> {
+    async getOwner(nftId: number | string): Promise<string> {
         return 'example'
     }
 
     /**
-     * @param {number} nftId NFT ID
+     * @param {number | string} nftId NFT ID
      * @returns {Promise<string>} URI of the NFT
      */
-    async getTokenURI(nftId: number): Promise<string> {
+    async getTokenURI(nftId: number | string): Promise<string> {
         return 'example'
     }
 
     /**
-     * @param {number} nftId ID of the NFT that will be transferred
-     * @returns {Promise<string>} Wallet address of the approved spender
+     * @param {number | string} nftId ID of the NFT that will be transferred
+     * @returns {Promise<string | null>} Wallet address of the approved spender
      */
-    async getApproved(nftId: number): Promise<string> {
+    async getApproved(nftId: number | string): Promise<string | null> {
         return 'example'
     }
 
     /**
      * @param {string} sender Sender address
      * @param {string} receiver Receiver address
-     * @param {number} nftId NFT ID
-     * @returns {Promise<TransactionSigner>} Transaction signer
+     * @param {number | string} nftId NFT ID
+     * @returns {Promise<NftTransactionSigner>} Transaction signer
      */
     async transfer(
         sender: string,
         receiver: string,
-        nftId: number
-    ): Promise<TransactionSignerInterface> {
-        return new TransactionSigner('example')
+        nftId: number | string
+    ): Promise<NftTransactionSigner> {
+        return new NftTransactionSigner('example')
     }
 
     /**
      * @param {string} spender Spender address
      * @param {string} owner Owner address
      * @param {string} receiver Receiver address
-     * @param {number} nftId NFT ID
-     * @returns {Promise<TransactionSigner>} Transaction signer
+     * @param {number | string} nftId NFT ID
+     * @returns {Promise<NftTransactionSigner>} Transaction signer
      */
     async transferFrom(
         spender: string,
         owner: string,
         receiver: string,
-        nftId: number
-    ): Promise<TransactionSignerInterface> {
-        return new TransactionSigner('example')
+        nftId: number | string
+    ): Promise<NftTransactionSigner> {
+        return new NftTransactionSigner('example')
     }
 
     /**
      * Gives permission to the spender to spend owner's tokens
      * @param {string} owner Address of owner of the tokens that will be used
      * @param {string} spender Address of the spender that will use the tokens of owner
-     * @param {number} nftId ID of the NFT that will be transferred
+     * @param {number | string} nftId ID of the NFT that will be transferred
      * @returns {Promise<TransactionSigner>} Transaction signer
      */
     async approve(
         owner: string,
         spender: string,
-        nftId: number
-    ): Promise<TransactionSignerInterface> {
-        return new TransactionSigner('example')
+        nftId: number | string
+    ): Promise<NftTransactionSigner> {
+        return new NftTransactionSigner('example')
     }
 }

packages/networks/boilerplate/src/assets/Token.ts

@@ -1,6 +1,6 @@
 import { Contract } from './Contract.ts'
-import { TransactionSigner } from '../services/TransactionSigner.ts'
-import type { TokenInterface, TransactionSignerInterface } from '@multiplechain/types'
+import type { TokenInterface } from '@multiplechain/types'
+import { TokenTransactionSigner } from '../services/TransactionSigner.ts'
 
 export class Token extends Contract implements TokenInterface {
     /**
@@ -59,24 +59,24 @@ export class Token extends Contract implements TokenInterface {
         sender: string,
         receiver: string,
         amount: number
-    ): Promise<TransactionSignerInterface> {
-        return new TransactionSigner('example')
+    ): Promise<TokenTransactionSigner> {
+        return new TokenTransactionSigner('example')
     }
 
     /**
      * @param {string} spender Address of the spender of transaction
      * @param {string} owner Sender wallet address
      * @param {string} receiver Receiver wallet address
      * @param {number} amount Amount of tokens that will be transferred
-     * @returns {Promise<TransactionSigner>} Transaction signer
+     * @returns {Promise<TokenTransactionSigner>} Transaction signer
      */
     async transferFrom(
         spender: string,
         owner: string,
         receiver: string,
         amount: number
-    ): Promise<TransactionSignerInterface> {
-        return new TransactionSigner('example')
+    ): Promise<TokenTransactionSigner> {
+        return new TokenTransactionSigner('example')
     }
 
     /**
@@ -90,7 +90,7 @@ export class Token extends Contract implements TokenInterface {
         owner: string,
         spender: string,
         amount: number
-    ): Promise<TransactionSignerInterface> {
-        return new TransactionSigner('example')
+    ): Promise<TokenTransactionSigner> {
+        return new TokenTransactionSigner('example')
     }
 }

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

@@ -2,7 +2,8 @@ import type {
     WalletInterface,
     WalletAdapterInterface,
     WalletPlatformEnum,
-    TransactionSignerInterface
+    TransactionSignerInterface,
+    ProviderInterface
 } from '@multiplechain/types'
 import { Provider } from '../services/Provider'
 
@@ -40,7 +41,7 @@ export class Wallet implements WalletInterface {
      * @returns {string}
      */
     getIcon(): string {
-        return this.adapter.name
+        return this.adapter.icon
     }
 
     /**
@@ -71,10 +72,11 @@ export class Wallet implements WalletInterface {
     }
 
     /**
-     * connect to adapter
+     * @param {ProviderInterface} provider
+     * @param {Object} ops
      * @returns {Promise<string>}
      */
-    async connect(): Promise<string> {
+    async connect(provider?: ProviderInterface, ops?: object): Promise<string> {
         await this.adapter.connect()
         return 'wallet address'
     }

packages/networks/boilerplate/src/models/NftTransaction.ts

@@ -34,7 +34,7 @@ export class NftTransaction extends ContractTransaction implements NftTransactio
     async verifyTransfer(
         direction: AssetDirectionEnum,
         address: string,
-        nftId: number
+        nftId: number | string
     ): Promise<TransactionStatusEnum> {
         return TransactionStatusEnum.PENDING
     }

packages/networks/boilerplate/src/services/TransactionListener.ts

@@ -44,10 +44,10 @@ export class TransactionListener<T extends TransactionTypeEnum>
 
     /**
      * @param {T} type - Transaction type
-     * @param {Provider} provider - Provider
      * @param {DynamicTransactionListenerFilterType<T>} filter - Transaction listener filter
+     * @param {Provider} provider - Provider
      */
-    constructor(type: T, provider?: Provider, filter?: DynamicTransactionListenerFilterType<T>) {
+    constructor(type: T, filter?: DynamicTransactionListenerFilterType<T>, provider?: Provider) {
         this.type = type
         this.filter = filter
         this.provider = provider ?? Provider.instance
@@ -87,10 +87,11 @@ export class TransactionListener<T extends TransactionTypeEnum>
     /**
      * Listen to the transaction events
      * @param {TransactionListenerCallbackType} callback - Transaction listener callback
-     * @returns {void}
+     * @returns {Promise<boolean>}
      */
-    on(callback: TransactionListenerCallbackType): void {
+    async on(callback: TransactionListenerCallbackType): Promise<boolean> {
         this.callbacks.push(callback)
+        return true
     }
 
     /**

packages/networks/evm-chains/.eslintrc.json

@@ -1,12 +1,4 @@
 {
-    "rules": {
-        "@typescript-eslint/no-misused-promises": [
-            "error",
-            {
-                "checksVoidReturn": false
-            }
-        ]
-    },
     "extends": ["plugin:require-extensions/recommended", "../../../.eslintrc.json"],
     "plugins": ["require-extensions"]
 }