393 lines
15 KiB
JavaScript
393 lines
15 KiB
JavaScript
import { MESSAGE_TYPE } from './app';
|
|
|
|
/**
|
|
* Transaction Type is a MetaMask construct used internally
|
|
*
|
|
* @typedef {object} TransactionTypes
|
|
* @property {'transfer'} TOKEN_METHOD_TRANSFER - A token transaction where the user
|
|
* is sending tokens that they own to another address
|
|
* @property {'transferfrom'} TOKEN_METHOD_TRANSFER_FROM - A token transaction
|
|
* transferring tokens from an account that the sender has an allowance of.
|
|
* For more information on allowances, see the approve type.
|
|
* @property {'safetransferfrom'} TOKEN_METHOD_SAFE_TRANSFER_FROM - A token transaction
|
|
* transferring tokens from an account that the sender has an allowance of.
|
|
* The method is prefixed with safe because when calling this method the contract checks
|
|
* to ensure that the receiver is an address capable of handling with the token being sent.
|
|
* @property {'approve'} TOKEN_METHOD_APPROVE - A token transaction requesting an
|
|
* allowance of the token to spend on behalf of the user
|
|
* @property {'setapprovalforall'} TOKEN_METHOD_SET_APPROVAL_FOR_ALL - A token transaction requesting an
|
|
* allowance of all of a user's token to spend on behalf of the user
|
|
* @property {'incoming'} INCOMING - An incoming (deposit) transaction
|
|
* @property {'simpleSend'} SIMPLE_SEND - A transaction sending a network's native asset to a recipient
|
|
* @property {'contractInteraction'} CONTRACT_INTERACTION - A transaction that is
|
|
* interacting with a smart contract's methods that we have not treated as a special
|
|
* case, such as approve, transfer, and transferfrom
|
|
* @property {'contractDeployment'} DEPLOY_CONTRACT - A transaction that deployed
|
|
* a smart contract
|
|
* @property {'swap'} SWAP - A transaction swapping one token for another through
|
|
* MetaMask Swaps
|
|
* @property {'swapApproval'} SWAP_APPROVAL - Similar to the approve type, a swap
|
|
* approval is a special case of ERC20 approve method that requests an allowance of
|
|
* the token to spend on behalf of the user for the MetaMask Swaps contract. The first
|
|
* swap for any token will have an accompanying swapApproval transaction.
|
|
* @property {'cancel'} CANCEL - A transaction submitted with the same nonce as a
|
|
* previous transaction, a higher gas price and a zeroed out send amount. Useful
|
|
* for users who accidentally send to erroneous addresses or if they send too much.
|
|
* @property {'retry'} RETRY - When a transaction is failed it can be retried by
|
|
* resubmitting the same transaction with a higher gas fee. This type is also used
|
|
* to speed up pending transactions. This is accomplished by creating a new tx with
|
|
* the same nonce and higher gas fees.
|
|
*/
|
|
|
|
/**
|
|
* This type will work anywhere you expect a string that can be one of the
|
|
* above transaction types.
|
|
*
|
|
* @typedef {TransactionTypes[keyof TransactionTypes]} TransactionTypeString
|
|
*/
|
|
|
|
/**
|
|
* @type {TransactionTypes}
|
|
*/
|
|
export const TRANSACTION_TYPES = {
|
|
CANCEL: 'cancel',
|
|
CONTRACT_INTERACTION: 'contractInteraction',
|
|
DEPLOY_CONTRACT: 'contractDeployment',
|
|
ETH_DECRYPT: MESSAGE_TYPE.ETH_DECRYPT,
|
|
ETH_GET_ENCRYPTION_PUBLIC_KEY: MESSAGE_TYPE.ETH_GET_ENCRYPTION_PUBLIC_KEY,
|
|
INCOMING: 'incoming',
|
|
PERSONAL_SIGN: MESSAGE_TYPE.PERSONAL_SIGN,
|
|
RETRY: 'retry',
|
|
SIGN: MESSAGE_TYPE.ETH_SIGN,
|
|
SIGN_TYPED_DATA: MESSAGE_TYPE.ETH_SIGN_TYPED_DATA,
|
|
SIMPLE_SEND: 'simpleSend',
|
|
SMART: 'smart',
|
|
SWAP: 'swap',
|
|
SWAP_APPROVAL: 'swapApproval',
|
|
TOKEN_METHOD_APPROVE: 'approve',
|
|
TOKEN_METHOD_SAFE_TRANSFER_FROM: 'safetransferfrom',
|
|
TOKEN_METHOD_TRANSFER: 'transfer',
|
|
TOKEN_METHOD_TRANSFER_FROM: 'transferfrom',
|
|
TOKEN_METHOD_SET_APPROVAL_FOR_ALL: 'setapprovalforall',
|
|
};
|
|
|
|
/**
|
|
* In EIP-2718 typed transaction envelopes were specified, with the very first
|
|
* typed envelope being 'legacy' and describing the shape of the base
|
|
* transaction params that were hitherto the only transaction type sent on
|
|
* Ethereum.
|
|
*
|
|
* @typedef {object} TransactionEnvelopeTypes
|
|
* @property {'0x0'} LEGACY - A legacy transaction, the very first type.
|
|
* @property {'0x1'} ACCESS_LIST - EIP-2930 defined the access list transaction
|
|
* type that allowed for specifying the state that a transaction would act
|
|
* upon in advance and theoretically save on gas fees.
|
|
* @property {'0x2'} FEE_MARKET - The type introduced comes from EIP-1559,
|
|
* Fee Market describes the addition of a baseFee to blocks that will be
|
|
* burned instead of distributed to miners. Transactions of this type have
|
|
* both a maxFeePerGas (maximum total amount in gwei per gas to spend on the
|
|
* transaction) which is inclusive of the maxPriorityFeePerGas (maximum amount
|
|
* of gwei per gas from the transaction fee to distribute to miner).
|
|
*/
|
|
|
|
/**
|
|
* @type {TransactionEnvelopeTypes}
|
|
*/
|
|
export const TRANSACTION_ENVELOPE_TYPES = {
|
|
LEGACY: '0x0',
|
|
ACCESS_LIST: '0x1',
|
|
FEE_MARKET: '0x2',
|
|
};
|
|
|
|
/**
|
|
* Transaction Status is a mix of Ethereum and MetaMask terminology, used internally
|
|
* for transaction processing.
|
|
*
|
|
* @typedef {object} TransactionStatuses
|
|
* @property {'unapproved'} UNAPPROVED - A new transaction that the user has not
|
|
* approved or rejected
|
|
* @property {'approved'} APPROVED - The user has approved the transaction in the
|
|
* MetaMask UI
|
|
* @property {'rejected'} REJECTED - The user has rejected the transaction in the
|
|
* MetaMask UI
|
|
* @property {'signed'} SIGNED - The transaction has been signed
|
|
* @property {'submitted'} SUBMITTED - The transaction has been submitted to network
|
|
* @property {'failed'} FAILED - The transaction has failed for some reason
|
|
* @property {'dropped'} DROPPED - The transaction was dropped due to a tx with same
|
|
* nonce being accepted
|
|
* @property {'confirmed'} CONFIRMED - The transaction was confirmed by the network
|
|
*/
|
|
|
|
/**
|
|
* This type will work anywhere you expect a string that can be one of the
|
|
* above transaction statuses.
|
|
*
|
|
* @typedef {TransactionStatuses[keyof TransactionStatuses]} TransactionStatusString
|
|
*/
|
|
|
|
/**
|
|
* @type {TransactionStatuses}
|
|
*/
|
|
export const TRANSACTION_STATUSES = {
|
|
UNAPPROVED: 'unapproved',
|
|
APPROVED: 'approved',
|
|
REJECTED: 'rejected',
|
|
SIGNED: 'signed',
|
|
SUBMITTED: 'submitted',
|
|
FAILED: 'failed',
|
|
DROPPED: 'dropped',
|
|
CONFIRMED: 'confirmed',
|
|
PENDING: 'pending',
|
|
};
|
|
|
|
/**
|
|
* With this list we can detect if a transaction is still in progress.
|
|
*/
|
|
export const IN_PROGRESS_TRANSACTION_STATUSES = [
|
|
TRANSACTION_STATUSES.UNAPPROVED,
|
|
TRANSACTION_STATUSES.APPROVED,
|
|
TRANSACTION_STATUSES.SIGNED,
|
|
TRANSACTION_STATUSES.SUBMITTED,
|
|
TRANSACTION_STATUSES.PENDING,
|
|
];
|
|
|
|
/**
|
|
* Transaction Group Status is a MetaMask construct to track the status of groups
|
|
* of transactions.
|
|
*
|
|
* @typedef {object} TransactionGroupStatuses
|
|
* @property {'cancelled'} CANCELLED - A cancel type transaction in the group was
|
|
* confirmed
|
|
* @property {'pending'} PENDING - The primaryTransaction of the group has a status
|
|
* that is one of TRANSACTION_STATUSES.APPROVED, TRANSACTION_STATUSES.UNAPPROVED
|
|
* or TRANSACTION_STATUSES.SUBMITTED
|
|
*/
|
|
|
|
/**
|
|
* @type {TransactionGroupStatuses}
|
|
*/
|
|
export const TRANSACTION_GROUP_STATUSES = {
|
|
CANCELLED: 'cancelled',
|
|
PENDING: 'pending',
|
|
};
|
|
|
|
/**
|
|
* Statuses that are specific to Smart Transactions.
|
|
*
|
|
* @typedef {object} SmartTransactionStatuses
|
|
* @property {'cancelled'} CANCELLED - It can be cancelled for various reasons.
|
|
* @property {'pending'} PENDING - Smart transaction is being processed.
|
|
* @property {'success'} SUCCESS - Smart transaction was successfully mined.
|
|
*/
|
|
|
|
/**
|
|
* @type {SmartTransactionStatuses}
|
|
*/
|
|
export const SMART_TRANSACTION_STATUSES = {
|
|
CANCELLED: 'cancelled',
|
|
PENDING: 'pending',
|
|
SUCCESS: 'success',
|
|
};
|
|
|
|
/**
|
|
* Transaction Group Category is a MetaMask construct to categorize the intent
|
|
* of a group of transactions for purposes of displaying in the UI
|
|
*
|
|
* @typedef {object} TransactionGroupCategories
|
|
* @property {'send'} SEND - Transaction group representing ether being sent from
|
|
* the user.
|
|
* @property {'receive'} RECEIVE - Transaction group representing a deposit/incoming
|
|
* transaction. This category maps 1:1 with TRANSACTION_CATEGORIES.INCOMING.
|
|
* @property {'interaction'} INTERACTION - Transaction group representing
|
|
* an interaction with a smart contract's methods.
|
|
* @property {'approval'} APPROVAL - Transaction group representing a request for an
|
|
* allowance of a token to spend on the user's behalf.
|
|
* @property {'signature-request'} SIGNATURE_REQUEST - Transaction group representing
|
|
* a signature request This currently only shows up in the UI when its pending user
|
|
* approval in the UI. Once the user approves or rejects it will no longer show in
|
|
* activity.
|
|
* @property {'swap'} SWAP - Transaction group representing a token swap through
|
|
* MetaMask Swaps. This transaction group's primary currency changes depending
|
|
* on context. If the user is viewing an asset page for a token received from a swap,
|
|
* the primary currency will be the received token. Otherwise the token exchanged
|
|
* will be shown.
|
|
*/
|
|
|
|
/**
|
|
* @type {TransactionGroupCategories}
|
|
*/
|
|
export const TRANSACTION_GROUP_CATEGORIES = {
|
|
APPROVAL: 'approval',
|
|
INTERACTION: 'interaction',
|
|
RECEIVE: 'receive',
|
|
SEND: 'send',
|
|
SIGNATURE_REQUEST: 'signature-request',
|
|
SWAP: 'swap',
|
|
};
|
|
|
|
/**
|
|
* @typedef {object} TxParams
|
|
* @property {string} from - The address the transaction is sent from
|
|
* @property {string} to - The address the transaction is sent to
|
|
* @property {string} value - The amount of wei, in hexadecimal, to send
|
|
* @property {number} nonce - The transaction count for the current account/network
|
|
* @property {string} gasPrice - The amount of gwei, in hexadecimal, per unit of gas
|
|
* @property {string} gas - The max amount of gwei, in hexadecimal, the user is willing to pay
|
|
* @property {string} [data] - Hexadecimal encoded string representing calls to the EVM's ABI
|
|
*/
|
|
|
|
/**
|
|
* @typedef {object} TxError
|
|
* @property {string} message - The message from the encountered error.
|
|
* @property {any} rpc - The "value" of the error.
|
|
* @property {string} [stack] - the stack trace from the error, if available.
|
|
*/
|
|
|
|
/**
|
|
* An object representing a transaction, in whatever state it is in.
|
|
*
|
|
* @typedef {object} TransactionMeta
|
|
* @property {string} [blockNumber] - The block number this transaction was
|
|
* included in. Currently only present on incoming transactions!
|
|
* @property {number} id - An internally unique tx identifier.
|
|
* @property {number} time - Time the transaction was first suggested, in unix
|
|
* epoch time (ms).
|
|
* @property {string} contractMethodName - A string representing a name of
|
|
* transaction contract method.
|
|
* @property {TransactionTypeString} type - The type of transaction this txMeta
|
|
* represents.
|
|
* @property {TransactionStatusString} status - The current status of the
|
|
* transaction.
|
|
* @property {string} metamaskNetworkId - The transaction's network ID, used
|
|
* for EIP-155 compliance.
|
|
* @property {boolean} loadingDefaults - TODO: Document
|
|
* @property {TxParams} txParams - The transaction params as passed to the
|
|
* network provider.
|
|
* @property {object[]} history - A history of mutations to this
|
|
* TransactionMeta object.
|
|
* @property {string} origin - A string representing the interface that
|
|
* suggested the transaction.
|
|
* @property {string} originalGasEstimate - A string representing the original
|
|
* gas estimation on the transaction metadata.
|
|
* @property {boolean} userEditedGasLimit - A boolean representing when the
|
|
* user manually edited the gas limit.
|
|
* @property {object} nonceDetails - A metadata object containing information
|
|
* used to derive the suggested nonce, useful for debugging nonce issues.
|
|
* @property {string} rawTx - A hex string of the final signed transaction,
|
|
* ready to submit to the network.
|
|
* @property {string} hash - A hex string of the transaction hash, used to
|
|
* identify the transaction on the network.
|
|
* @property {number} [submittedTime] - The time the transaction was submitted to
|
|
* the network, in Unix epoch time (ms).
|
|
* @property {TxError} [err] - The error encountered during the transaction
|
|
*/
|
|
|
|
/**
|
|
* Defines the possible types
|
|
*
|
|
* @typedef {object} TransactionMetaMetricsEvents
|
|
* @property {'Transaction Added'} ADDED - All transactions, except incoming
|
|
* ones, are added to the controller state in an unapproved status. When this
|
|
* happens we fire the Transaction Added event to show that the transaction
|
|
* has been added to the user's MetaMask.
|
|
* @property {'Transaction Approved'} APPROVED - When an unapproved transaction
|
|
* is in the controller state, MetaMask will render a confirmation screen for
|
|
* that transaction. If the user approves the transaction we fire this event
|
|
* to indicate that the user has approved the transaction for submission to
|
|
* the network.
|
|
* @property {'Transaction Rejected'} REJECTED - When an unapproved transaction
|
|
* is in the controller state, MetaMask will render a confirmation screen for
|
|
* that transaction. If the user rejects the transaction we fire this event
|
|
* to indicate that the user has rejected the transaction. It will be removed
|
|
* from state as a result.
|
|
* @property {'Transaction Submitted'} SUBMITTED - After a transaction is
|
|
* approved by the user, it is then submitted to the network for inclusion in
|
|
* a block. When this happens we fire the Transaction Submitted event to
|
|
* indicate that MetaMask is submitting a transaction at the user's request.
|
|
* @property {'Transaction Finalized'} FINALIZED - All transactions that are
|
|
* submitted will finalized (eventually) by either being dropped, failing
|
|
* or being confirmed. When this happens we track this event, along with the
|
|
* status.
|
|
*/
|
|
|
|
/**
|
|
* This type will work anywhere you expect a string that can be one of the
|
|
* above transaction event types.
|
|
*
|
|
* @typedef {TransactionMetaMetricsEvents[keyof TransactionMetaMetricsEvents]} TransactionMetaMetricsEventString
|
|
*/
|
|
|
|
/**
|
|
* @type {TransactionMetaMetricsEvents}
|
|
*/
|
|
export const TRANSACTION_EVENTS = {
|
|
ADDED: 'Transaction Added',
|
|
APPROVED: 'Transaction Approved',
|
|
FINALIZED: 'Transaction Finalized',
|
|
REJECTED: 'Transaction Rejected',
|
|
SUBMITTED: 'Transaction Submitted',
|
|
};
|
|
|
|
/**
|
|
* @typedef {object} AssetTypes
|
|
* @property {'NATIVE'} NATIVE - The native asset for the current network, such
|
|
* as ETH
|
|
* @property {'TOKEN'} TOKEN - An ERC20 token.
|
|
* @property {'COLLECTIBLE'} COLLECTIBLE - An ERC721 or ERC1155 token.
|
|
* @property {'UNKNOWN'} UNKNOWN - A transaction interacting with a contract
|
|
* that isn't a token method interaction will be marked as dealing with an
|
|
* unknown asset type.
|
|
*/
|
|
|
|
/**
|
|
* This type will work anywhere you expect a string that can be one of the
|
|
* above asset types
|
|
*
|
|
* @typedef {AssetTypes[keyof AssetTypes]} AssetTypesString
|
|
*/
|
|
|
|
/**
|
|
* The types of assets that a user can send
|
|
*
|
|
* @type {AssetTypes}
|
|
*/
|
|
export const ASSET_TYPES = {
|
|
NATIVE: 'NATIVE',
|
|
TOKEN: 'TOKEN',
|
|
COLLECTIBLE: 'COLLECTIBLE',
|
|
UNKNOWN: 'UNKNOWN',
|
|
};
|
|
|
|
export const ERC20 = 'ERC20';
|
|
export const ERC721 = 'ERC721';
|
|
export const ERC1155 = 'ERC1155';
|
|
|
|
/**
|
|
* @typedef {object} TokenStandards
|
|
* @property {'ERC20'} ERC20 - A token that conforms to the ERC20 standard.
|
|
* @property {'ERC721'} ERC721 - A token that conforms to the ERC721 standard.
|
|
* @property {'ERC1155'} ERC1155 - A token that conforms to the ERC1155
|
|
* standard.
|
|
* @property {'NONE'} NONE - Not a token, but rather the base asset of the
|
|
* selected chain.
|
|
*/
|
|
|
|
/**
|
|
* This type will work anywhere you expect a string that can be one of the
|
|
* above statuses
|
|
*
|
|
* @typedef {TokenStandards[keyof TokenStandards]} TokenStandardStrings
|
|
*/
|
|
|
|
/**
|
|
* Describes the standard which a token conforms to.
|
|
*
|
|
* @type {TokenStandards}
|
|
*/
|
|
export const TOKEN_STANDARDS = {
|
|
ERC20,
|
|
ERC721,
|
|
ERC1155,
|
|
NONE: 'NONE',
|
|
};
|