@portal-hq/web 3.15.0-alpha.2 → 3.16.0-alpha.0

package/lib/commonjs/index.js

@@ -429,6 +429,14 @@ class Portal {
             return solAddress;
         });
     }
+    getTronAddress() {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield ((_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getClient());
+            const tronAddress = ((_d = (_c = (_b = client === null || client === void 0 ? void 0 : client.metadata) === null || _b === void 0 ? void 0 : _b.namespaces) === null || _c === void 0 ? void 0 : _c.tron) === null || _d === void 0 ? void 0 : _d.address) || '';
+            return tronAddress;
+        });
+    }
     doesWalletExist(chainId) {
         var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
@@ -551,6 +559,18 @@ class Portal {
                         });
                         break;
                     }
+                    case 'tron': {
+                        const tronTx = buildTxResponse;
+                        response = yield this.request({
+                            chainId,
+                            method: 'tron_sendTransaction',
+                            params: [tronTx.transaction.id],
+                            sponsorGas: params.sponsorGas,
+                            signatureApprovalMemo: params.signatureApprovalMemo,
+                            traceId,
+                        });
+                        break;
+                    }
                     default: {
                         throw new Error(`Unsupported chain namespace: ${chainNamespace}`);
                     }
@@ -570,6 +590,9 @@ class Portal {
      * - **Solana (`solana:*`):** Polls `getSignatureStatuses` until the
      *   commitment level from `options.commitment`
      *   is met (default `confirmed`).
+     * - **TRON (`tron:*`):** Confirmation polling is not supported.
+     *   Always returns `false`. Transaction status must be verified
+     *   directly via TRON RPC using the transaction ID returned by `sendAsset`.
      * - **Other networks:** Returns `false` (unsupported for polling).
      *
      * Optional `options` tune poll/timeout for all polled chains; EVM also accepts
@@ -1164,5 +1187,6 @@ var ChainNamespace;
 (function (ChainNamespace) {
     ChainNamespace["EIP155"] = "eip155";
     ChainNamespace["SOLANA"] = "solana";
+    ChainNamespace["TRON"] = "tron";
 })(ChainNamespace = exports.ChainNamespace || (exports.ChainNamespace = {}));
 exports.default = Portal;

package/lib/commonjs/index.test.js

@@ -444,6 +444,12 @@ describe('Portal', () => {
             expect(res).toBe(constants_1.mockSolanaAddress);
         }));
     });
+    describe('getTronAddress', () => {
+        it("should return the wallet's TRON address correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield portal.getTronAddress();
+            expect(res).toBe(constants_1.mockTronAddress);
+        }));
+    });
     describe('doesWalletExist', () => {
         it('should successfully return if wallets exist', () => __awaiter(void 0, void 0, void 0, function* () {
             const res = yield portal.doesWalletExist();
@@ -617,6 +623,53 @@ describe('Portal', () => {
             });
         }));
     });
+    describe('sendAsset (TRON)', () => {
+        const tronChainId = 'tron:nile';
+        const tronRpcUrl = 'https://test-tron-rpc';
+        beforeEach(() => {
+            portal = new _1.default({
+                rpcConfig: Object.assign(Object.assign({}, constants_1.mockRpcConfig), { [tronChainId]: tronRpcUrl }),
+            });
+            portal.mpc = mpc_1.default;
+            portal.provider = provider_1.default;
+        });
+        it('should build the transaction and sign it via tron_sendTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.buildTransaction.mockResolvedValueOnce(constants_1.mockBuiltTronTransaction);
+            portal.provider.request.mockResolvedValueOnce(constants_1.mockSignedHash);
+            const result = yield portal.sendAsset(tronChainId, {
+                to: constants_1.mockBuiltTronTransaction.metadata.toAddress,
+                token: 'NATIVE',
+                amount: '1',
+            });
+            expect(result).toBe(constants_1.mockSignedHash);
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledWith(tronChainId, constants_1.mockBuiltTronTransaction.metadata.toAddress, 'NATIVE', '1', expect.any(String));
+            expect(portal.provider.request).toHaveBeenCalledWith(expect.objectContaining({
+                chainId: tronChainId,
+                method: 'tron_sendTransaction',
+                params: [constants_1.mockBuiltTronTransaction.transaction.id],
+            }));
+        }));
+        it('should propagate build errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.buildTransaction.mockRejectedValueOnce(new Error('Build failed'));
+            yield expect(portal.sendAsset(tronChainId, {
+                to: constants_1.mockBuiltTronTransaction.metadata.toAddress,
+                token: 'NATIVE',
+                amount: '1',
+            })).rejects.toThrow('Failed to send asset: Build failed');
+        }));
+        it('should propagate signing errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.buildTransaction.mockResolvedValueOnce(constants_1.mockBuiltTronTransaction);
+            portal.provider.request.mockRejectedValueOnce(new Error('Signing failed'));
+            yield expect(portal.sendAsset(tronChainId, {
+                to: constants_1.mockBuiltTronTransaction.metadata.toAddress,
+                token: 'NATIVE',
+                amount: '1',
+            })).rejects.toThrow('Failed to send asset: Signing failed');
+        }));
+    });
     describe('getBalances', () => {
         it('should correctly call mpc.getBalances', () => __awaiter(void 0, void 0, void 0, function* () {
             yield portal.getBalances('eip155:1');

package/lib/commonjs/mpc/index.js

@@ -14,7 +14,7 @@ const errors_1 = require("./errors");
 const logger_1 = require("../logger");
 const index_1 = require("../index");
 const trace_1 = require("../shared/trace");
-const WEB_SDK_VERSION = '3.15.0-alpha.2';
+const WEB_SDK_VERSION = '3.16.0-alpha.0';
 class Mpc {
     get ready() {
         return this._ready;
@@ -42,15 +42,14 @@ class Mpc {
             if (!requestId) {
                 return;
             }
+            const forceRefresh = (data === null || data === void 0 ? void 0 : data.forceRefresh) === true;
             const getter = this.firebaseGetToken;
             void (() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     if (!getter) {
                         throw new Error('Firebase storage is not configured (getToken missing)');
                     }
-                    const token = yield getter({
-                        forceRefresh: (data === null || data === void 0 ? void 0 : data.forceRefresh) === true,
-                    });
+                    const token = yield getter({ forceRefresh });
                     this.postMessage({
                         type: 'portal:firebase:requestTokenResult',
                         data: { requestId, token },

package/lib/commonjs/provider/index.js

@@ -132,6 +132,8 @@ var RequestMethod;
     RequestMethod["sol_signAndSendTransaction"] = "sol_signAndSendTransaction";
     RequestMethod["sol_signMessage"] = "sol_signMessage";
     RequestMethod["sol_signTransaction"] = "sol_signTransaction";
+    // TRON Wallet Methods
+    RequestMethod["tron_sendTransaction"] = "tron_sendTransaction";
 })(RequestMethod = exports.RequestMethod || (exports.RequestMethod = {}));
 const passiveSignerMethods = [
     RequestMethod.eth_accounts,
@@ -153,6 +155,7 @@ const signerMethods = [
     RequestMethod.sol_signAndSendTransaction,
     RequestMethod.sol_signMessage,
     RequestMethod.sol_signTransaction,
+    RequestMethod.tron_sendTransaction,
 ];
 const iframeProxiedMethodStrings = [
     'eth_getTransactionReceipt',
@@ -177,6 +180,14 @@ class Provider {
                 throw new Error(`[PortalProvider] Chain ID must be prefixed with "solana:" for the operation, got ${chainId}`);
             }
         };
+        this.enforceTronChainId = (chainId) => {
+            if (!chainId) {
+                throw new Error('[PortalProvider] Chain ID is required for the operation');
+            }
+            if (!chainId.startsWith('tron:')) {
+                throw new Error(`[PortalProvider] Chain ID must be prefixed with "tron:" for the operation, got ${chainId}`);
+            }
+        };
         this.buildParams = (method, txParams) => {
             let params = txParams;
             switch (method) {
@@ -470,6 +481,14 @@ class Provider {
                     })));
                     return result;
                 }
+                case RequestMethod.tron_sendTransaction: {
+                    this.enforceTronChainId(chainId);
+                    const result = yield this.portal.mpc.sign(Object.assign({ chainId: chainId, method, params: this.buildParams(method, params), rpcUrl: this.portal.getRpcUrl(chainId), sponsorGas,
+                        traceId }, (signatureApprovalMemo !== undefined && {
+                        signatureApprovalMemo,
+                    })));
+                    return result;
+                }
                 default:
                     throw new Error('[PortalProvider] Method "' + method + '" not supported');
             }

package/lib/commonjs/provider/index.test.js

@@ -549,6 +549,44 @@ describe('Provider', () => {
                     });
                 }));
             });
+            describe('tron_sendTransaction', () => {
+                it('should throw an error if no chainId is provided alongside tron_sendTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+                    yield expect(provider.request({
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    })).rejects.toThrow(new Error(`[PortalProvider] Chain ID is required for the operation`));
+                }));
+                it('should throw an error if malformed chainId is provided alongside tron_sendTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    yield expect(provider.request({
+                        chainId,
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    })).rejects.toThrow(new Error(`[PortalProvider] Chain ID must be prefixed with "tron:" for the operation, got ${chainId}`));
+                }));
+                it('should successfully handle a tron_sendTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: 'test',
+                        rpcUrl: constants_1.mockRpcUrl,
+                        sponsorGas: undefined,
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'tron:nile',
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
         });
         describe('Signer methods without auto-approval', () => {
             const mockSigningRequestedHandler = jest.fn();
@@ -1200,6 +1238,59 @@ describe('Provider', () => {
                     expect(mockConsoleWarn).toHaveBeenCalledWith("[PortalProvider] Request for signing method 'sol_signTransaction' could not be completed because it was not approved by the user.");
                 }));
             });
+            describe('tron_sendTransaction', () => {
+                it('should successfully handle an approved tron_sendTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: __1.RequestMethod.tron_sendTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(constants_1.mockSignedHash);
+                    expect(portal_1.default.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: 'test',
+                        rpcUrl: constants_1.mockRpcUrl,
+                        sponsorGas: undefined,
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected tron_sendTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: __1.RequestMethod.tron_sendTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: __1.RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(undefined);
+                    expect(mockConsoleWarn).toHaveBeenCalledWith("[PortalProvider] Request for signing method 'tron_sendTransaction' could not be completed because it was not approved by the user.");
+                }));
+            });
         });
         describe('Non-signer methods', () => {
             beforeAll(() => {

package/lib/esm/index.js

@@ -400,6 +400,14 @@ class Portal {
             return solAddress;
         });
     }
+    getTronAddress() {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield ((_a = this.mpc) === null || _a === void 0 ? void 0 : _a.getClient());
+            const tronAddress = ((_d = (_c = (_b = client === null || client === void 0 ? void 0 : client.metadata) === null || _b === void 0 ? void 0 : _b.namespaces) === null || _c === void 0 ? void 0 : _c.tron) === null || _d === void 0 ? void 0 : _d.address) || '';
+            return tronAddress;
+        });
+    }
     doesWalletExist(chainId) {
         var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
@@ -522,6 +530,18 @@ class Portal {
                         });
                         break;
                     }
+                    case 'tron': {
+                        const tronTx = buildTxResponse;
+                        response = yield this.request({
+                            chainId,
+                            method: 'tron_sendTransaction',
+                            params: [tronTx.transaction.id],
+                            sponsorGas: params.sponsorGas,
+                            signatureApprovalMemo: params.signatureApprovalMemo,
+                            traceId,
+                        });
+                        break;
+                    }
                     default: {
                         throw new Error(`Unsupported chain namespace: ${chainNamespace}`);
                     }
@@ -541,6 +561,9 @@ class Portal {
      * - **Solana (`solana:*`):** Polls `getSignatureStatuses` until the
      *   commitment level from `options.commitment`
      *   is met (default `confirmed`).
+     * - **TRON (`tron:*`):** Confirmation polling is not supported.
+     *   Always returns `false`. Transaction status must be verified
+     *   directly via TRON RPC using the transaction ID returned by `sendAsset`.
      * - **Other networks:** Returns `false` (unsupported for polling).
      *
      * Optional `options` tune poll/timeout for all polled chains; EVM also accepts
@@ -1131,5 +1154,6 @@ export var ChainNamespace;
 (function (ChainNamespace) {
     ChainNamespace["EIP155"] = "eip155";
     ChainNamespace["SOLANA"] = "solana";
+    ChainNamespace["TRON"] = "tron";
 })(ChainNamespace || (ChainNamespace = {}));
 export default Portal;

package/lib/esm/index.test.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import Portal, { BackupMethods, GetTransactionsOrder } from '.';
-import { mockAddress, mockBackupConfig, mockBlockHashResponse, mockCipherText, mockClientResponse, mockEip155Address, mockEjectResult, mockEjectPrivateKeysResult, mockEthRpcUrl, mockEthTransaction, mockMpcBackupResponse, mockOrgBackupShare, mockOrgBackupShares, mockQuoteArgs, mockRpcConfig, mockSharesOnDevice, mockSignedHash, mockSolanaAddress, mockSolRpcUrl, } from './__mocks/constants';
+import { mockAddress, mockBackupConfig, mockBlockHashResponse, mockBuiltTronTransaction, mockCipherText, mockClientResponse, mockEip155Address, mockEjectResult, mockEjectPrivateKeysResult, mockEthRpcUrl, mockEthTransaction, mockMpcBackupResponse, mockOrgBackupShare, mockOrgBackupShares, mockQuoteArgs, mockRpcConfig, mockSharesOnDevice, mockSignedHash, mockSolanaAddress, mockSolRpcUrl, mockTronAddress, } from './__mocks/constants';
 import mpcMock from './__mocks/portal/mpc';
 import providerMock from './__mocks/portal/provider';
 /**
@@ -416,6 +416,12 @@ describe('Portal', () => {
             expect(res).toBe(mockSolanaAddress);
         }));
     });
+    describe('getTronAddress', () => {
+        it("should return the wallet's TRON address correctly", () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield portal.getTronAddress();
+            expect(res).toBe(mockTronAddress);
+        }));
+    });
     describe('doesWalletExist', () => {
         it('should successfully return if wallets exist', () => __awaiter(void 0, void 0, void 0, function* () {
             const res = yield portal.doesWalletExist();
@@ -589,6 +595,53 @@ describe('Portal', () => {
             });
         }));
     });
+    describe('sendAsset (TRON)', () => {
+        const tronChainId = 'tron:nile';
+        const tronRpcUrl = 'https://test-tron-rpc';
+        beforeEach(() => {
+            portal = new Portal({
+                rpcConfig: Object.assign(Object.assign({}, mockRpcConfig), { [tronChainId]: tronRpcUrl }),
+            });
+            portal.mpc = mpcMock;
+            portal.provider = providerMock;
+        });
+        it('should build the transaction and sign it via tron_sendTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.buildTransaction.mockResolvedValueOnce(mockBuiltTronTransaction);
+            portal.provider.request.mockResolvedValueOnce(mockSignedHash);
+            const result = yield portal.sendAsset(tronChainId, {
+                to: mockBuiltTronTransaction.metadata.toAddress,
+                token: 'NATIVE',
+                amount: '1',
+            });
+            expect(result).toBe(mockSignedHash);
+            expect(portal.mpc.buildTransaction).toHaveBeenCalledWith(tronChainId, mockBuiltTronTransaction.metadata.toAddress, 'NATIVE', '1', expect.any(String));
+            expect(portal.provider.request).toHaveBeenCalledWith(expect.objectContaining({
+                chainId: tronChainId,
+                method: 'tron_sendTransaction',
+                params: [mockBuiltTronTransaction.transaction.id],
+            }));
+        }));
+        it('should propagate build errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.buildTransaction.mockRejectedValueOnce(new Error('Build failed'));
+            yield expect(portal.sendAsset(tronChainId, {
+                to: mockBuiltTronTransaction.metadata.toAddress,
+                token: 'NATIVE',
+                amount: '1',
+            })).rejects.toThrow('Failed to send asset: Build failed');
+        }));
+        it('should propagate signing errors', () => __awaiter(void 0, void 0, void 0, function* () {
+            ;
+            portal.mpc.buildTransaction.mockResolvedValueOnce(mockBuiltTronTransaction);
+            portal.provider.request.mockRejectedValueOnce(new Error('Signing failed'));
+            yield expect(portal.sendAsset(tronChainId, {
+                to: mockBuiltTronTransaction.metadata.toAddress,
+                token: 'NATIVE',
+                amount: '1',
+            })).rejects.toThrow('Failed to send asset: Signing failed');
+        }));
+    });
     describe('getBalances', () => {
         it('should correctly call mpc.getBalances', () => __awaiter(void 0, void 0, void 0, function* () {
             yield portal.getBalances('eip155:1');

package/lib/esm/mpc/index.js

@@ -11,7 +11,7 @@ import { PortalMpcError } from './errors';
 import { sdkLogger } from '../logger';
 import { BackupMethods, } from '../index';
 import { generateTraceId } from '../shared/trace';
-const WEB_SDK_VERSION = '3.15.0-alpha.2';
+const WEB_SDK_VERSION = '3.16.0-alpha.0';
 class Mpc {
     get ready() {
         return this._ready;
@@ -39,15 +39,14 @@ class Mpc {
             if (!requestId) {
                 return;
             }
+            const forceRefresh = (data === null || data === void 0 ? void 0 : data.forceRefresh) === true;
             const getter = this.firebaseGetToken;
             void (() => __awaiter(this, void 0, void 0, function* () {
                 try {
                     if (!getter) {
                         throw new Error('Firebase storage is not configured (getToken missing)');
                     }
-                    const token = yield getter({
-                        forceRefresh: (data === null || data === void 0 ? void 0 : data.forceRefresh) === true,
-                    });
+                    const token = yield getter({ forceRefresh });
                     this.postMessage({
                         type: 'portal:firebase:requestTokenResult',
                         data: { requestId, token },

package/lib/esm/provider/index.js

@@ -129,6 +129,8 @@ export var RequestMethod;
     RequestMethod["sol_signAndSendTransaction"] = "sol_signAndSendTransaction";
     RequestMethod["sol_signMessage"] = "sol_signMessage";
     RequestMethod["sol_signTransaction"] = "sol_signTransaction";
+    // TRON Wallet Methods
+    RequestMethod["tron_sendTransaction"] = "tron_sendTransaction";
 })(RequestMethod || (RequestMethod = {}));
 const passiveSignerMethods = [
     RequestMethod.eth_accounts,
@@ -150,6 +152,7 @@ const signerMethods = [
     RequestMethod.sol_signAndSendTransaction,
     RequestMethod.sol_signMessage,
     RequestMethod.sol_signTransaction,
+    RequestMethod.tron_sendTransaction,
 ];
 const iframeProxiedMethodStrings = [
     'eth_getTransactionReceipt',
@@ -174,6 +177,14 @@ class Provider {
                 throw new Error(`[PortalProvider] Chain ID must be prefixed with "solana:" for the operation, got ${chainId}`);
             }
         };
+        this.enforceTronChainId = (chainId) => {
+            if (!chainId) {
+                throw new Error('[PortalProvider] Chain ID is required for the operation');
+            }
+            if (!chainId.startsWith('tron:')) {
+                throw new Error(`[PortalProvider] Chain ID must be prefixed with "tron:" for the operation, got ${chainId}`);
+            }
+        };
         this.buildParams = (method, txParams) => {
             let params = txParams;
             switch (method) {
@@ -467,6 +478,14 @@ class Provider {
                     })));
                     return result;
                 }
+                case RequestMethod.tron_sendTransaction: {
+                    this.enforceTronChainId(chainId);
+                    const result = yield this.portal.mpc.sign(Object.assign({ chainId: chainId, method, params: this.buildParams(method, params), rpcUrl: this.portal.getRpcUrl(chainId), sponsorGas,
+                        traceId }, (signatureApprovalMemo !== undefined && {
+                        signatureApprovalMemo,
+                    })));
+                    return result;
+                }
                 default:
                     throw new Error('[PortalProvider] Method "' + method + '" not supported');
             }

package/lib/esm/provider/index.test.js

@@ -544,6 +544,44 @@ describe('Provider', () => {
                     });
                 }));
             });
+            describe('tron_sendTransaction', () => {
+                it('should throw an error if no chainId is provided alongside tron_sendTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+                    yield expect(provider.request({
+                        method: RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    })).rejects.toThrow(new Error(`[PortalProvider] Chain ID is required for the operation`));
+                }));
+                it('should throw an error if malformed chainId is provided alongside tron_sendTransaction', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const chainId = 'unsupported:chain';
+                    yield expect(provider.request({
+                        chainId,
+                        method: RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    })).rejects.toThrow(new Error(`[PortalProvider] Chain ID must be prefixed with "tron:" for the operation, got ${chainId}`));
+                }));
+                it('should successfully handle a tron_sendTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(mockSignedHash);
+                    expect(portal.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_sendTransaction,
+                        params: 'test',
+                        rpcUrl: mockRpcUrl,
+                        sponsorGas: undefined,
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(provider.emit).toHaveBeenCalledWith('portal_signatureReceived', {
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+            });
         });
         describe('Signer methods without auto-approval', () => {
             const mockSigningRequestedHandler = jest.fn();
@@ -1195,6 +1233,59 @@ describe('Provider', () => {
                     expect(mockConsoleWarn).toHaveBeenCalledWith("[PortalProvider] Request for signing method 'sol_signTransaction' could not be completed because it was not approved by the user.");
                 }));
             });
+            describe('tron_sendTransaction', () => {
+                it('should successfully handle an approved tron_sendTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingApproved', {
+                            method: RequestMethod.tron_sendTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(mockSignedHash);
+                    expect(portal.mpc.sign).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_sendTransaction,
+                        params: 'test',
+                        rpcUrl: mockRpcUrl,
+                        sponsorGas: undefined,
+                        traceId: 'mock-trace-id-12345',
+                    });
+                    expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                        signature: result,
+                    });
+                }));
+                it('should successfully handle a rejected tron_sendTransaction request', () => __awaiter(void 0, void 0, void 0, function* () {
+                    provider.on('portal_signingRequested', () => {
+                        provider.emit('portal_signingRejected', {
+                            method: RequestMethod.tron_sendTransaction,
+                            params: ['test'],
+                        });
+                    });
+                    const result = yield provider.request({
+                        chainId: 'tron:nile',
+                        method: RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+                        method: RequestMethod.tron_sendTransaction,
+                        params: ['test'],
+                    });
+                    expect(result).toEqual(undefined);
+                    expect(mockConsoleWarn).toHaveBeenCalledWith("[PortalProvider] Request for signing method 'tron_sendTransaction' could not be completed because it was not approved by the user.");
+                }));
+            });
         });
         describe('Non-signer methods', () => {
             beforeAll(() => {

package/package.json

@@ -3,7 +3,7 @@
   "description": "Portal MPC Support for Web",
   "author": "Portal Labs, Inc.",
   "homepage": "https://portalhq.io/",
-  "version": "3.15.0-alpha.2",
+  "version": "3.16.0-alpha.0",
   "license": "MIT",
   "main": "lib/commonjs/index",
   "module": "lib/esm/index",

package/src/__mocks/constants.ts

@@ -46,6 +46,7 @@ export const mockMpcBackupResponse = {
 
 export const mockEip155Address = 'test-eip155-address'
 export const mockSolanaAddress = 'CqQMFUCEMbK9Cp9yMonmthKqzc59Ta48JpZMZsh1bDqf'
+export const mockTronAddress = 'TQvGkCH57KBBgGRiMpKNbZnqMHRb1x9p9X'
 export const mockClientResponse = {
   createdAt: '2023-02-20T00:00:00.000Z',
   custodian: {
@@ -71,6 +72,10 @@ export const mockClientResponse = {
         address: mockSolanaAddress,
         curve: 'ED25519',
       },
+      tron: {
+        address: mockTronAddress,
+        curve: 'SECP256K1',
+      },
     },
   },
   wallets: [
@@ -212,6 +217,10 @@ export const mockClient: ClientResponse = {
         curve: PortalCurve.ED25519,
         address: mockAddress,
       },
+      [ChainNamespace.TRON]: {
+        curve: PortalCurve.SECP256K1,
+        address: mockAddress,
+      },
     },
   },
   wallets: [
@@ -436,6 +445,20 @@ export const mockBuiltTransaction = {
   },
 }
 
+export const mockBuiltTronTransaction = {
+  transaction: {
+    id: 'mock-tron-tx-id-abc123',
+    network: 'nile',
+  },
+  metadata: {
+    amount: '1',
+    fromAddress: mockTronAddress,
+    toAddress: 'TAKAgsfLknBjAupezWMPosnjruGnjAnhin',
+    tokenSymbol: 'TRX',
+    contractAddress: null,
+  },
+}
+
 export const mockNFTs = [
   {
     contract: {
@@ -803,6 +826,7 @@ export const mockClientMetadata = {
   addresses: {
     [ChainNamespace.EIP155]: 'test',
     [ChainNamespace.SOLANA]: 'test',
+    [ChainNamespace.TRON]: 'test',
   },
   custodian: {
     id: 'test',
@@ -817,6 +841,10 @@ export const mockClientMetadata = {
       ...mockClient.wallets[1],
       publicKey: { X: 'test', Y: 'test' },
     },
+    [ChainNamespace.TRON]: {
+      ...mockClient.wallets[0],
+      publicKey: { X: 'test', Y: 'test' },
+    },
   },
 }
 

package/src/index.test.ts

@@ -7,6 +7,7 @@ import {
   mockAddress,
   mockBackupConfig,
   mockBlockHashResponse,
+  mockBuiltTronTransaction,
   mockCipherText,
   mockClientResponse,
   mockEip155Address,
@@ -23,6 +24,7 @@ import {
   mockSignedHash,
   mockSolanaAddress,
   mockSolRpcUrl,
+  mockTronAddress,
 } from './__mocks/constants'
 import mpcMock from './__mocks/portal/mpc'
 import providerMock from './__mocks/portal/provider'
@@ -708,6 +710,13 @@ describe('Portal', () => {
     })
   })
 
+  describe('getTronAddress', () => {
+    it("should return the wallet's TRON address correctly", async () => {
+      const res = await portal.getTronAddress()
+      expect(res).toBe(mockTronAddress)
+    })
+  })
+
   describe('doesWalletExist', () => {
     it('should successfully return if wallets exist', async () => {
       const res = await portal.doesWalletExist()
@@ -953,6 +962,86 @@ describe('Portal', () => {
     })
   })
 
+  describe('sendAsset (TRON)', () => {
+    const tronChainId = 'tron:nile'
+    const tronRpcUrl = 'https://test-tron-rpc'
+
+    beforeEach(() => {
+      portal = new Portal({
+        rpcConfig: {
+          ...mockRpcConfig,
+          [tronChainId]: tronRpcUrl,
+        },
+      })
+      portal.mpc = mpcMock
+      portal.provider = providerMock
+    })
+
+    it('should build the transaction and sign it via tron_sendTransaction', async () => {
+      ;(portal.mpc.buildTransaction as jest.Mock).mockResolvedValueOnce(
+        mockBuiltTronTransaction,
+      )
+      ;(portal.provider.request as jest.Mock).mockResolvedValueOnce(
+        mockSignedHash,
+      )
+
+      const result = await portal.sendAsset(tronChainId, {
+        to: mockBuiltTronTransaction.metadata.toAddress,
+        token: 'NATIVE',
+        amount: '1',
+      })
+
+      expect(result).toBe(mockSignedHash)
+
+      expect(portal.mpc.buildTransaction).toHaveBeenCalledWith(
+        tronChainId,
+        mockBuiltTronTransaction.metadata.toAddress,
+        'NATIVE',
+        '1',
+        expect.any(String),
+      )
+
+      expect(portal.provider.request).toHaveBeenCalledWith(
+        expect.objectContaining({
+          chainId: tronChainId,
+          method: 'tron_sendTransaction',
+          params: [mockBuiltTronTransaction.transaction.id],
+        }),
+      )
+    })
+
+    it('should propagate build errors', async () => {
+      ;(portal.mpc.buildTransaction as jest.Mock).mockRejectedValueOnce(
+        new Error('Build failed'),
+      )
+
+      await expect(
+        portal.sendAsset(tronChainId, {
+          to: mockBuiltTronTransaction.metadata.toAddress,
+          token: 'NATIVE',
+          amount: '1',
+        }),
+      ).rejects.toThrow('Failed to send asset: Build failed')
+    })
+
+    it('should propagate signing errors', async () => {
+      ;(portal.mpc.buildTransaction as jest.Mock).mockResolvedValueOnce(
+        mockBuiltTronTransaction,
+      )
+      ;(portal.provider.request as jest.Mock).mockRejectedValueOnce(
+        new Error('Signing failed'),
+      )
+
+      await expect(
+        portal.sendAsset(tronChainId, {
+          to: mockBuiltTronTransaction.metadata.toAddress,
+          token: 'NATIVE',
+          amount: '1',
+        }),
+      ).rejects.toThrow('Failed to send asset: Signing failed')
+    })
+  })
+
   describe('getBalances', () => {
     it('should correctly call mpc.getBalances', async () => {
       await portal.getBalances('eip155:1')

package/src/index.ts

@@ -8,6 +8,7 @@ import {
 import {
   GetAssetsResponse,
   BuiltTransaction,
+  BuiltTronTransaction,
   EvaluateTransactionOperationType,
   EvaluateTransactionParam,
   EvaluatedTransaction,
@@ -581,6 +582,12 @@ class Portal {
     return solAddress
   }
 
+  public async getTronAddress(): Promise<string> {
+    const client = await this.mpc?.getClient()
+    const tronAddress = client?.metadata?.namespaces?.tron?.address || ''
+    return tronAddress
+  }
+
   public async doesWalletExist(chainId?: string): Promise<boolean> {
     const client = await this.mpc?.getClient()
 
@@ -738,6 +745,19 @@ class Portal {
           })
           break
         }
+        case 'tron': {
+          const tronTx = buildTxResponse as BuiltTronTransaction
+          response = await this.request({
+            chainId,
+            method: 'tron_sendTransaction',
+            params: [tronTx.transaction.id],
+            sponsorGas: params.sponsorGas,
+            signatureApprovalMemo: params.signatureApprovalMemo,
+            traceId,
+          })
+          break
+        }
+
         default: {
           throw new Error(`Unsupported chain namespace: ${chainNamespace}`)
         }
@@ -757,6 +777,9 @@ class Portal {
    * - **Solana (`solana:*`):** Polls `getSignatureStatuses` until the
    *   commitment level from `options.commitment`
    *   is met (default `confirmed`).
+   * - **TRON (`tron:*`):** Confirmation polling is not supported.
+   *   Always returns `false`. Transaction status must be verified
+   *   directly via TRON RPC using the transaction ID returned by `sendAsset`.
    * - **Other networks:** Returns `false` (unsupported for polling).
    *
    * Optional `options` tune poll/timeout for all polled chains; EVM also accepts
@@ -1617,6 +1640,7 @@ export enum PortalCurve {
 export enum ChainNamespace {
   EIP155 = 'eip155',
   SOLANA = 'solana',
+  TRON = 'tron',
 }
 
 export default Portal

package/src/mpc/index.ts

@@ -134,7 +134,7 @@ import {
 } from '../../hypernative'
 import { generateTraceId } from '../shared/trace'
 
-const WEB_SDK_VERSION = '3.15.0-alpha.2'
+const WEB_SDK_VERSION = '3.16.0-alpha.0'
 
 class Mpc {
   public iframe?: HTMLIFrameElement
@@ -162,6 +162,7 @@ class Mpc {
     if (!requestId) {
       return
     }
+    const forceRefresh = data?.forceRefresh === true
     const getter = this.firebaseGetToken
     void (async () => {
       try {
@@ -170,9 +171,7 @@ class Mpc {
             'Firebase storage is not configured (getToken missing)',
           )
         }
-        const token = await getter({
-          forceRefresh: data?.forceRefresh === true,
-        })
+        const token = await getter({ forceRefresh })
         this.postMessage({
           type: 'portal:firebase:requestTokenResult',
           data: { requestId, token },

package/src/provider/index.test.ts

@@ -812,6 +812,63 @@ describe('Provider', () => {
           )
         })
       })
+
+      describe('tron_sendTransaction', () => {
+        it('should throw an error if no chainId is provided alongside tron_sendTransaction', async () => {
+          await expect(
+            provider.request({
+              method: RequestMethod.tron_sendTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID is required for the operation`,
+            ),
+          )
+        })
+
+        it('should throw an error if malformed chainId is provided alongside tron_sendTransaction', async () => {
+          const chainId = 'unsupported:chain'
+          await expect(
+            provider.request({
+              chainId,
+              method: RequestMethod.tron_sendTransaction,
+              params: ['test'],
+            }),
+          ).rejects.toThrow(
+            new Error(
+              `[PortalProvider] Chain ID must be prefixed with "tron:" for the operation, got ${chainId}`,
+            ),
+          )
+        })
+
+        it('should successfully handle a tron_sendTransaction request', async () => {
+          const result = await provider.request({
+            chainId: 'tron:nile',
+            method: RequestMethod.tron_sendTransaction,
+            params: ['test'],
+          })
+
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'tron:nile',
+            method: RequestMethod.tron_sendTransaction,
+            params: 'test',
+            rpcUrl: mockRpcUrl,
+            sponsorGas: undefined,
+            traceId: 'mock-trace-id-12345',
+          })
+          expect(provider.emit).toHaveBeenCalledWith(
+            'portal_signatureReceived',
+            {
+              chainId: 'tron:nile',
+              method: RequestMethod.tron_sendTransaction,
+              params: ['test'],
+              signature: result,
+            },
+          )
+        })
+      })
     })
 
     describe('Signer methods without auto-approval', () => {
@@ -1539,6 +1596,65 @@ describe('Provider', () => {
           )
         })
       })
+
+      describe('tron_sendTransaction', () => {
+        it('should successfully handle an approved tron_sendTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingApproved', {
+              method: RequestMethod.tron_sendTransaction,
+              params: ['test'],
+            })
+          })
+          const result = await provider.request({
+            chainId: 'tron:nile',
+            method: RequestMethod.tron_sendTransaction,
+            params: ['test'],
+          })
+
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.tron_sendTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(mockSignedHash)
+          expect(portal.mpc.sign).toHaveBeenCalledWith({
+            chainId: 'tron:nile',
+            method: RequestMethod.tron_sendTransaction,
+            params: 'test',
+            rpcUrl: mockRpcUrl,
+            sponsorGas: undefined,
+            traceId: 'mock-trace-id-12345',
+          })
+          expect(mockSignatureReceivedHandler).toHaveBeenCalledWith({
+            chainId: 'tron:nile',
+            method: RequestMethod.tron_sendTransaction,
+            params: ['test'],
+            signature: result,
+          })
+        })
+
+        it('should successfully handle a rejected tron_sendTransaction request', async () => {
+          provider.on('portal_signingRequested', () => {
+            provider.emit('portal_signingRejected', {
+              method: RequestMethod.tron_sendTransaction,
+              params: ['test'],
+            })
+          })
+
+          const result = await provider.request({
+            chainId: 'tron:nile',
+            method: RequestMethod.tron_sendTransaction,
+            params: ['test'],
+          })
+          expect(mockSigningRequestedHandler).toHaveBeenCalledWith({
+            method: RequestMethod.tron_sendTransaction,
+            params: ['test'],
+          })
+          expect(result).toEqual(undefined)
+          expect(mockConsoleWarn).toHaveBeenCalledWith(
+            "[PortalProvider] Request for signing method 'tron_sendTransaction' could not be completed because it was not approved by the user.",
+          )
+        })
+      })
     })
 
     describe('Non-signer methods', () => {

package/src/provider/index.ts

@@ -134,6 +134,9 @@ export enum RequestMethod {
   sol_signAndSendTransaction = 'sol_signAndSendTransaction',
   sol_signMessage = 'sol_signMessage',
   sol_signTransaction = 'sol_signTransaction',
+
+  // TRON Wallet Methods
+  tron_sendTransaction = 'tron_sendTransaction',
 }
 
 const passiveSignerMethods = [
@@ -157,6 +160,7 @@ const signerMethods = [
   RequestMethod.sol_signAndSendTransaction,
   RequestMethod.sol_signMessage,
   RequestMethod.sol_signTransaction,
+  RequestMethod.tron_sendTransaction,
 ]
 
 const iframeProxiedMethodStrings: string[] = [
@@ -540,6 +544,21 @@ class Provider {
         })
         return result
       }
+      case RequestMethod.tron_sendTransaction: {
+        this.enforceTronChainId(chainId)
+        const result = await this.portal.mpc.sign({
+          chainId: chainId as string,
+          method,
+          params: this.buildParams(method, params),
+          rpcUrl: this.portal.getRpcUrl(chainId),
+          sponsorGas,
+          traceId,
+          ...(signatureApprovalMemo !== undefined && {
+            signatureApprovalMemo,
+          }),
+        })
+        return result
+      }
       default:
         throw new Error(
           '[PortalProvider] Method "' + method + '" not supported',
@@ -571,6 +590,18 @@ class Provider {
     }
   }
 
+  private enforceTronChainId = (chainId?: string) => {
+    if (!chainId) {
+      throw new Error('[PortalProvider] Chain ID is required for the operation')
+    }
+
+    if (!chainId.startsWith('tron:')) {
+      throw new Error(
+        `[PortalProvider] Chain ID must be prefixed with "tron:" for the operation, got ${chainId}`,
+      )
+    }
+  }
+
   private buildParams = (method: string, txParams: any) => {
     let params = txParams
 

package/src/shared/types/common.ts

@@ -334,7 +334,7 @@ export type GetTransactionHistoryResponse =
   | UnifiedTransactionsResponse
 
 // Built transaction types
-export type BuiltTransaction = BuiltEip155Transaction | BuiltSolanaTransaction
+export type BuiltTransaction = BuiltEip155Transaction | BuiltSolanaTransaction | BuiltTronTransaction
 
 export interface BuiltEip155Transaction {
   transaction: {
@@ -402,6 +402,20 @@ export interface BuiltSolanaTransaction {
   }
 }
 
+export interface BuiltTronTransaction {
+  transaction: {
+    id: string
+    network: string
+  }
+  metadata: {
+    amount: string
+    fromAddress: string
+    toAddress: string
+    tokenSymbol: string
+    contractAddress: string | null
+  }
+}
+
 // Simulation types
 export interface SimulateTransactionParam {
   to: string