From da91cee4aad46fb24d6ed7fd885c486d1c540b27 Mon Sep 17 00:00:00 2001 From: Frederic HENG Date: Wed, 19 Aug 2026 17:21:37 +0200 Subject: [PATCH 1/3] fix(tron-wallet-snap): price new-account TRX sends as 1 TRX + 100 Bandwidth Activation was billed as TransferContract byte size (~266) plus 1 TRX, which overstated Testing Day costs. Use create-account Bandwidth from chain params, staked quota only, and a 0.1 TRX shortfall instead. --- packages/tron-wallet-snap/CHANGELOG.md | 5 +- .../tron-wallet-snap/src/constants/index.ts | 13 + .../send/FeeCalculatorService.test.ts | 159 ++++++++-- .../src/services/send/FeeCalculatorService.ts | 278 ++++++++++++++---- 4 files changed, 372 insertions(+), 83 deletions(-) diff --git a/packages/tron-wallet-snap/CHANGELOG.md b/packages/tron-wallet-snap/CHANGELOG.md index 733239f5e..3b85744b9 100644 --- a/packages/tron-wallet-snap/CHANGELOG.md +++ b/packages/tron-wallet-snap/CHANGELOG.md @@ -15,9 +15,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Extract shared asset util functions and inject `SnapAssetsAdapter` from `context` into `AssetsService` ([#143](https://github.com/MetaMask/internal-snaps/pull/143)) - Rename `getByKeyringAccountId` to `getAccountAssets` (with essential-asset synthesis) and update keyring callers ([#143](https://github.com/MetaMask/internal-snaps/pull/143)) - - Bump `@metamask/utils` from `^11.9.0` to `^11.11.9` ([#161](https://github.com/MetaMask/internal-snaps/pull/161)) +### Fixed + +- Estimate native TRX/TRC-10 sends that activate a new account as 1 TRX plus 100 Bandwidth (or 0.1 TRX when staked Bandwidth is insufficient), instead of TransferContract byte size + ## [3.1.0] ### Added diff --git a/packages/tron-wallet-snap/src/constants/index.ts b/packages/tron-wallet-snap/src/constants/index.ts index 40ab2c951..bab7a8705 100644 --- a/packages/tron-wallet-snap/src/constants/index.ts +++ b/packages/tron-wallet-snap/src/constants/index.ts @@ -37,6 +37,19 @@ export const TRACK_TX_INTERVAL = 'PT3S'; */ export const TRACK_TX_MAX_ATTEMPTS = 5; +/** + * Default `getCreateAccountFee` in SUN (0.1 TRX). Burned when the sender + * lacks enough *staked* Bandwidth to activate a new account. + * + * @see https://developers.tron.network/docs/account#activating-an-account + */ +export const FALLBACK_CREATE_ACCOUNT_FEE_SUN = 100_000; + +/** + * Default `getCreateNewAccountFeeInSystemContract` in SUN (1 TRX). + */ +export const FALLBACK_CREATE_NEW_ACCOUNT_FEE_SUN = 1_000_000; + export enum Network { Mainnet = 'tron:728126428', Nile = 'tron:3448148188', diff --git a/packages/tron-wallet-snap/src/services/send/FeeCalculatorService.test.ts b/packages/tron-wallet-snap/src/services/send/FeeCalculatorService.test.ts index 3d1baed80..e943c5233 100644 --- a/packages/tron-wallet-snap/src/services/send/FeeCalculatorService.test.ts +++ b/packages/tron-wallet-snap/src/services/send/FeeCalculatorService.test.ts @@ -147,6 +147,8 @@ async function withFeeCalculatorService( getChainParameters: jest.fn().mockResolvedValue([ { key: 'getTransactionFee', value: 1000 }, { key: 'getEnergyFee', value: 100 }, + { key: 'getCreateAccountFee', value: 100_000 }, + { key: 'getCreateNewAccountFeeInSystemContract', value: 1_000_000 }, ]), getAccountInfoByAddress: jest.fn(), peekCachedChainParameters: jest.fn().mockResolvedValue(undefined), @@ -190,6 +192,29 @@ describe('FeeCalculatorService', () => { fungible: true, }, }; + const expectedMainnetActivationBandwidthFee = { + type: FeeType.Base, + asset: { + unit: 'BANDWIDTH', + type: 'tron:728126428/slip44:bandwidth', + amount: '100', + fungible: true, + }, + }; + + const mockStakedBandwidth = ( + tronHttpClient: MockTronHttpClient, + netLimit: number, + netUsed = 0, + freeNetLimit = 600, + ): void => { + tronHttpClient.getAccountResources.mockResolvedValue({ + NetLimit: netLimit, + NetUsed: netUsed, + freeNetLimit, + freeNetUsed: 0, + }); + }; const expectedMainnetContractBandwidthFee = { type: FeeType.Base, asset: { @@ -805,17 +830,23 @@ describe('FeeCalculatorService', () => { }); describe('Account activation fee scenarios', () => { - it('adds 1 TRX activation fee when recipient account is not activated', async () => { + it('adds 1 TRX activation fee and 100 Bandwidth when recipient is not activated and sender has staked Bandwidth', async () => { await withFeeCalculatorService( - async ({ feeCalculatorService, trongridApiClient }) => { - // Mock the account check to throw (account not found) + async ({ + feeCalculatorService, + trongridApiClient, + tronHttpClient, + }) => { trongridApiClient.getAccountInfoByAddress.mockRejectedValue( new TrongridAccountNotFoundError(), ); + mockStakedBandwidth(tronHttpClient, 1000); const transaction = getTransactionExample('native'); const availableEnergy = ZERO; - const availableBandwidth = BigNumber(1000000); // More than needed + // Combined free+staked quota is intentionally large; activation + // must use staked Bandwidth (100), not tx-size (~266). + const availableBandwidth = BigNumber(1000000); const result = await feeCalculatorService.computeFee({ scope: Network.Mainnet, @@ -824,7 +855,6 @@ describe('FeeCalculatorService', () => { availableBandwidth, }); - // Should have TRX first (1 TRX activation fee), then bandwidth consumption expect(result).toStrictEqual([ { type: FeeType.Base, @@ -835,12 +865,38 @@ describe('FeeCalculatorService', () => { fungible: true, }, }, + expectedMainnetActivationBandwidthFee, + ]); + }, + ); + }); + + it('ignores free Bandwidth and burns 0.1 TRX when sender has no staked Bandwidth', async () => { + await withFeeCalculatorService( + async ({ + feeCalculatorService, + trongridApiClient, + tronHttpClient, + }) => { + trongridApiClient.getAccountInfoByAddress.mockRejectedValue( + new TrongridAccountNotFoundError(), + ); + mockStakedBandwidth(tronHttpClient, 0, 0, 600); + + const result = await feeCalculatorService.computeFee({ + scope: Network.Mainnet, + transaction: getTransactionExample('native'), + availableEnergy: ZERO, + availableBandwidth: BigNumber(600), + }); + + expect(result).toStrictEqual([ { type: FeeType.Base, asset: { - unit: 'BANDWIDTH', - type: 'tron:728126428/slip44:bandwidth', - amount: '266', + unit: 'TRX', + type: 'tron:728126428/slip44:195', + amount: '1.1', fungible: true, }, }, @@ -851,10 +907,16 @@ describe('FeeCalculatorService', () => { it('does not track error when recipient account is not activated', async () => { await withFeeCalculatorService( - async ({ feeCalculatorService, trongridApiClient, snapClient }) => { + async ({ + feeCalculatorService, + trongridApiClient, + tronHttpClient, + snapClient, + }) => { trongridApiClient.getAccountInfoByAddress.mockRejectedValue( new TrongridAccountNotFoundError(), ); + mockStakedBandwidth(tronHttpClient, 1000); await feeCalculatorService.computeFee({ scope: Network.Mainnet, @@ -870,10 +932,16 @@ describe('FeeCalculatorService', () => { it('tracks unexpected errors when account activation check fails', async () => { await withFeeCalculatorService( - async ({ feeCalculatorService, trongridApiClient, snapClient }) => { + async ({ + feeCalculatorService, + trongridApiClient, + tronHttpClient, + snapClient, + }) => { const error = new Error('Account activation check failed'); trongridApiClient.getAccountInfoByAddress.mockRejectedValue(error); + mockStakedBandwidth(tronHttpClient, 1000); await feeCalculatorService.computeFee({ scope: Network.Mainnet, @@ -887,17 +955,21 @@ describe('FeeCalculatorService', () => { ); }); - it('adds activation fee to existing TRX cost when recipient is not activated', async () => { + it('adds 0.1 TRX Bandwidth shortfall instead of tx-size burn when recipient is not activated', async () => { await withFeeCalculatorService( - async ({ feeCalculatorService, trongridApiClient }) => { - // Mock the account check to throw (account not found) + async ({ + feeCalculatorService, + trongridApiClient, + tronHttpClient, + }) => { trongridApiClient.getAccountInfoByAddress.mockRejectedValue( new TrongridAccountNotFoundError(), ); + mockStakedBandwidth(tronHttpClient, 0); const transaction = getTransactionExample('native'); const availableEnergy = ZERO; - const availableBandwidth = ZERO; // Not enough bandwidth, triggers TRX cost + const availableBandwidth = ZERO; const result = await feeCalculatorService.computeFee({ scope: Network.Mainnet, @@ -906,18 +978,51 @@ describe('FeeCalculatorService', () => { availableBandwidth, }); - // Should have TRX cost for bandwidth (0.266) + activation fee (1) = 1.266 TRX expect(result).toStrictEqual([ { type: FeeType.Base, asset: { unit: 'TRX', type: 'tron:728126428/slip44:195', - amount: '1.266', + amount: '1.1', fungible: true, }, }, - expectedMainnetBandwidthFee, + ]); + }, + ); + }); + + it('uses create-account Bandwidth for TRC10 transfers to an unactivated recipient', async () => { + await withFeeCalculatorService( + async ({ + feeCalculatorService, + trongridApiClient, + tronHttpClient, + }) => { + trongridApiClient.getAccountInfoByAddress.mockRejectedValue( + new TrongridAccountNotFoundError(), + ); + mockStakedBandwidth(tronHttpClient, 1000); + + const result = await feeCalculatorService.computeFee({ + scope: Network.Mainnet, + transaction: getTransactionExample('trc10'), + availableEnergy: ZERO, + availableBandwidth: BigNumber(1000000), + }); + + expect(result).toStrictEqual([ + { + type: FeeType.Base, + asset: { + unit: 'TRX', + type: 'tron:728126428/slip44:195', + amount: '1', + fungible: true, + }, + }, + expectedMainnetActivationBandwidthFee, ]); }, ); @@ -2479,11 +2584,15 @@ describe('FeeCalculatorService', () => { it('adds memo fee combined with account activation fee', async () => { await withFeeCalculatorService( - async ({ feeCalculatorService, trongridApiClient }) => { - // Account not activated + async ({ + feeCalculatorService, + trongridApiClient, + tronHttpClient, + }) => { trongridApiClient.getAccountInfoByAddress.mockRejectedValue( new TrongridAccountNotFoundError(), ); + mockStakedBandwidth(tronHttpClient, 1000); const transaction = addMemoToTransaction( getTransactionExample('native'), @@ -2499,7 +2608,7 @@ describe('FeeCalculatorService', () => { availableBandwidth, }); - // 1 TRX activation + 1 TRX memo = 2 TRX + // 1 TRX activation + 1 TRX memo = 2 TRX, 100 create-account Bandwidth expect(result).toStrictEqual([ { type: FeeType.Base, @@ -2510,15 +2619,7 @@ describe('FeeCalculatorService', () => { fungible: true, }, }, - { - type: FeeType.Base, - asset: { - unit: 'BANDWIDTH', - type: 'tron:728126428/slip44:bandwidth', - amount: '266', - fungible: true, - }, - }, + expectedMainnetActivationBandwidthFee, ]); }, ); diff --git a/packages/tron-wallet-snap/src/services/send/FeeCalculatorService.ts b/packages/tron-wallet-snap/src/services/send/FeeCalculatorService.ts index 76ae0a679..aca2c6294 100644 --- a/packages/tron-wallet-snap/src/services/send/FeeCalculatorService.ts +++ b/packages/tron-wallet-snap/src/services/send/FeeCalculatorService.ts @@ -2,6 +2,7 @@ import { FeeType } from '@metamask/keyring-api'; import type { Logger } from '@metamask/snap-networks-utils'; import { BigNumber } from 'bignumber.js'; +import { TronWeb } from 'tronweb'; import type { Types as TronwebTypes } from 'tronweb'; import type { SnapClient } from '../../clients/snap/SnapClient'; @@ -14,8 +15,9 @@ import { TrongridAccountNotFoundError } from '../../clients/trongrid/errors'; import type { TrongridApiClient } from '../../clients/trongrid/TrongridApiClient'; import type { Network } from '../../constants'; import { - ACCOUNT_ACTIVATION_FEE_TRX, FALLBACK_ACCOUNT_UPGRADE_COST_SUN, + FALLBACK_CREATE_ACCOUNT_FEE_SUN, + FALLBACK_CREATE_NEW_ACCOUNT_FEE_SUN, FALLBACK_ENERGY_PRICE_SUN, FALLBACK_GET_ENERGY_FEE_SUN, FALLBACK_GET_TRANSACTION_FEE_SUN, @@ -29,6 +31,16 @@ import type { ComputeFeeResult } from './types'; type Transaction = TronwebTypes.Transaction; +type ActivationTransfer = { + toAddress: string; + ownerAddress: string; +}; + +type ActivationAssessment = { + unactivatedCount: number; + ownerAddress: string | undefined; +}; + /** * Bandwidth calculation constants. * @@ -624,69 +636,183 @@ export class FeeCalculatorService { } /** - * Calculate account activation fees for the transaction. - * This happens when sending native TRX to addresses that haven't been activated yet. + * Collect TRX and TRC-10 transfers that can activate a recipient. * - * @param options - The options object - * @param options.scope - The network scope to check - * @param options.transaction - The transaction to check for activation fee requirement - * @returns Promise - The total activation fees in TRX + * @param transaction - The transaction to inspect. + * @returns Transfer legs with owner and recipient addresses. */ - async #accountActivationFees({ - scope, - transaction, - }: { - scope: Network; - transaction: Transaction; - }): Promise { + #getActivationTransfers(transaction: Transaction): ActivationTransfer[] { const contracts = transaction.raw_data.contract; - if (!contracts || contracts.length === 0) { - return ZERO; + return []; } - // Collect all recipient addresses from TransferContract operations - const recipientAddresses: string[] = []; + const transfers: ActivationTransfer[] = []; for (const contract of contracts) { - if ((contract.type as string) === 'TransferContract') { - const { amount, to_address: toAddress } = contract.parameter.value as { - amount: number; - to_address: string; - }; - - if (amount > 0 && toAddress) { - recipientAddresses.push(toAddress); - } + const contractType = contract.type as string; + if ( + contractType !== 'TransferContract' && + contractType !== 'TransferAssetContract' + ) { + continue; + } + + const { + amount, + to_address: toAddress, + owner_address: ownerAddress, + } = contract.parameter.value as { + amount: number; + to_address: string; + owner_address: string; + }; + + if (amount > 0 && toAddress) { + transfers.push({ toAddress, ownerAddress }); } } - if (recipientAddresses.length === 0) { + return transfers; + } + + /** + * Convert a hex or Base58 TRON address to Base58 for FullNode APIs that + * use `visible: true`. + * + * @param address - Hex (`41…`) or Base58 (`T…`) address. + * @returns Base58 address, or the original string if conversion fails. + */ + #toBase58Address(address: string): string { + if (address.startsWith('T')) { + return address; + } + + try { + return TronWeb.address.fromHex(address); + } catch { + return address; + } + } + + /** + * Sender staked Bandwidth remaining (`NetLimit - NetUsed`). Daily free + * Bandwidth cannot pay for account activation. + * + * @param scope - Network scope. + * @param ownerAddress - Transaction owner (hex or Base58). + * @returns Staked Bandwidth remaining, or 0 if the fetch fails. + */ + async #getSenderStakedBandwidth( + scope: Network, + ownerAddress: string | undefined, + ): Promise { + if (!ownerAddress) { + return ZERO; + } + + try { + const resources = await this.#tronHttpClient.getAccountResources( + scope, + this.#toBase58Address(ownerAddress), + ); + const netLimit = resources.NetLimit ?? 0; + const netUsed = resources.NetUsed ?? 0; + return BigNumber.max(0, netLimit - netUsed); + } catch (error) { + await this.#snapClient.trackError(error as Error); + this.#logger.warn( + { error, ownerAddress }, + 'Failed to fetch sender staked Bandwidth for account activation', + ); return ZERO; } + } + + /** + * Assess whether this transaction activates any new accounts. + * + * Native TRX and TRC-10 transfers to never-funded addresses create the + * recipient on-chain. + * + * @see https://developers.tron.network/docs/account#activating-an-account + * @param options - Scope and transaction. + * @param options.scope - The network scope to check. + * @param options.transaction - The transaction that may activate recipients. + * @returns Unactivated recipient count and the sender address. + */ + async #assessAccountActivation({ + scope, + transaction, + }: { + scope: Network; + transaction: Transaction; + }): Promise { + const transfers = this.#getActivationTransfers(transaction); + if (transfers.length === 0) { + return { unactivatedCount: 0, ownerAddress: undefined }; + } - // Check all addresses in parallel const activationResults = await Promise.all( - recipientAddresses.map(async (address) => { - const isActivated = await this.#isAccountActivated(scope, address); - return { address, isActivated }; + transfers.map(async ({ toAddress, ownerAddress }) => { + const isActivated = await this.#isAccountActivated(scope, toAddress); + return { toAddress, ownerAddress, isActivated }; }), ); - // Count unactivated accounts and calculate total fees - const unactivatedCount = activationResults.filter( - ({ address, isActivated }) => { + const unactivated = activationResults.filter( + ({ toAddress, isActivated }) => { if (!isActivated) { this.#logger.log( - `Account ${address} is not activated, activation fee required`, + `Account ${toAddress} is not activated, activation fee required`, ); return true; } return false; }, - ).length; + ); - return ACCOUNT_ACTIVATION_FEE_TRX.multipliedBy(unactivatedCount); + return { + unactivatedCount: unactivated.length, + ownerAddress: unactivated[0]?.ownerAddress, + }; + } + + /** + * Chain-parameter values used to price account activation. + * + * Create-account Bandwidth = `getCreateAccountFee` / `getTransactionFee` + * (100,000 sun / 1,000 sun per byte = 100 Bandwidth on mainnet). + * + * @param chainParameters - Live or cached chain parameters. + * @returns Activation burn, Bandwidth-shortfall burn, and Bandwidth quota. + */ + #getActivationFeeParams(chainParameters: ChainParameter[]): { + activationFeeTrx: BigNumber; + createAccountFeeTrx: BigNumber; + createAccountBandwidth: BigNumber; + } { + const createNewAccountFeeSun = + chainParameters.find( + (param) => param.key === 'getCreateNewAccountFeeInSystemContract', + )?.value ?? FALLBACK_CREATE_NEW_ACCOUNT_FEE_SUN; + const createAccountFeeSun = + chainParameters.find((param) => param.key === 'getCreateAccountFee') + ?.value ?? FALLBACK_CREATE_ACCOUNT_FEE_SUN; + const transactionFeeSun = + chainParameters.find((param) => param.key === 'getTransactionFee') + ?.value ?? FALLBACK_GET_TRANSACTION_FEE_SUN; + + const bandwidthQuota = + transactionFeeSun > 0 + ? BigNumber(createAccountFeeSun).div(transactionFeeSun) + : BigNumber(createAccountFeeSun).div(FALLBACK_GET_TRANSACTION_FEE_SUN); + + return { + activationFeeTrx: BigNumber(createNewAccountFeeSun).div(SUN_IN_TRX), + createAccountFeeTrx: BigNumber(createAccountFeeSun).div(SUN_IN_TRX), + createAccountBandwidth: bandwidthQuota, + }; } /** @@ -799,21 +925,68 @@ export class FeeCalculatorService { ); // resources the transaction is expected to consume - const bandwidthNeeded = this.#calculateBandwidth(transaction); const energyNeeded = await this.#calculateEnergy( scope, transaction, feeLimit, ); - /** - * Calculate consumption and overages: - * - Bandwidth: If we don't have enough, we pay for ALL of it in TRX (no partial consumption) - * - Energy: We consume what we have available and pay TRX only for the overage - */ - const hasEnoughBandwidth = - availableBandwidth.isGreaterThanOrEqualTo(bandwidthNeeded); - const bandwidthToPayInTRX = hasEnoughBandwidth ? ZERO : bandwidthNeeded; + const activation = await this.#assessAccountActivation({ + scope, + transaction, + }); + const isActivatingAccount = activation.unactivatedCount > 0; + + let bandwidthNeeded: BigNumber; + let bandwidthToPayInTRX = ZERO; + let accountActivationFees = ZERO; + let createAccountBandwidthFee = ZERO; + + if (isActivatingAccount) { + const chainParameters = await this.#getChainParameters(scope); + const { activationFeeTrx, createAccountFeeTrx, createAccountBandwidth } = + this.#getActivationFeeParams(chainParameters); + + accountActivationFees = activationFeeTrx.multipliedBy( + activation.unactivatedCount, + ); + + const stakedBandwidth = await this.#getSenderStakedBandwidth( + scope, + activation.ownerAddress, + ); + const hasEnoughStakedBandwidth = stakedBandwidth.isGreaterThanOrEqualTo( + createAccountBandwidth, + ); + + if (hasEnoughStakedBandwidth) { + bandwidthNeeded = createAccountBandwidth; + this.#logger.log( + { + createAccountBandwidth: createAccountBandwidth.toString(), + stakedBandwidth: stakedBandwidth.toString(), + }, + 'Account activation covered by staked Bandwidth', + ); + } else { + // Free daily Bandwidth cannot pay for activation. Burn getCreateAccountFee + // instead of tx-size * getTransactionFee. + bandwidthNeeded = ZERO; + createAccountBandwidthFee = createAccountFeeTrx; + this.#logger.log( + { + createAccountFeeTrx: createAccountFeeTrx.toString(), + stakedBandwidth: stakedBandwidth.toString(), + }, + 'Account activation Bandwidth shortfall paid in TRX', + ); + } + } else { + bandwidthNeeded = this.#calculateBandwidth(transaction); + const hasEnoughBandwidth = + availableBandwidth.isGreaterThanOrEqualTo(bandwidthNeeded); + bandwidthToPayInTRX = hasEnoughBandwidth ? ZERO : bandwidthNeeded; + } const energyToPayInTRX = BigNumber.max( energyNeeded.minus(availableEnergy), @@ -853,17 +1026,16 @@ export class FeeCalculatorService { } /** - * Second, account activation fees + * Second, account activation fees (1 TRX burn + optional 0.1 TRX Bandwidth shortfall) */ - const accountActivationFees = await this.#accountActivationFees({ - scope, - transaction, - }); - if (accountActivationFees.isGreaterThan(0)) { totalTrxCost = totalTrxCost.plus(accountActivationFees); } + if (createAccountBandwidthFee.isGreaterThan(0)) { + totalTrxCost = totalTrxCost.plus(createAccountBandwidthFee); + } + /** * Third, memo/note fee */ From eb938682225adb624ae441cefa0f7ba8483d28a8 Mon Sep 17 00:00:00 2001 From: Frederic HENG Date: Wed, 19 Aug 2026 17:35:41 +0200 Subject: [PATCH 2/3] docs: update TRON CHANGELOG.MD with the PR reference --- packages/tron-wallet-snap/CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/tron-wallet-snap/CHANGELOG.md b/packages/tron-wallet-snap/CHANGELOG.md index 3b85744b9..d31823863 100644 --- a/packages/tron-wallet-snap/CHANGELOG.md +++ b/packages/tron-wallet-snap/CHANGELOG.md @@ -19,7 +19,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Fixed -- Estimate native TRX/TRC-10 sends that activate a new account as 1 TRX plus 100 Bandwidth (or 0.1 TRX when staked Bandwidth is insufficient), instead of TransferContract byte size +- Estimate native TRX/TRC-10 sends that activate a new account as 1 TRX plus 100 Bandwidth (or 0.1 TRX when staked Bandwidth is insufficient), instead of TransferContract byte size ([#175](https://github.com/MetaMask/internal-snaps/pull/175)) ## [3.1.0] From 73bc7023116c5044641ca71485af847d4e61dc1f Mon Sep 17 00:00:00 2001 From: Frederic HENG Date: Wed, 19 Aug 2026 18:21:35 +0200 Subject: [PATCH 3/3] chore(tron-wallet-snap): update snap.manifest.shasum --- packages/tron-wallet-snap/snap.manifest.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/tron-wallet-snap/snap.manifest.json b/packages/tron-wallet-snap/snap.manifest.json index fe36b7959..9b93707a0 100644 --- a/packages/tron-wallet-snap/snap.manifest.json +++ b/packages/tron-wallet-snap/snap.manifest.json @@ -7,7 +7,7 @@ "url": "https://github.com/MetaMask/internal-snaps.git" }, "source": { - "shasum": "MbqwOXbHFI83/qWOj9zDSXJizgEt5oQ+QnpHq0g/sls=", + "shasum": "Njb7OwhnQLRWPQguuGrD+RlkPKRAs0cUJkWIjgT3XKI=", "location": { "npm": { "filePath": "dist/bundle.js",