@metamask-previews/transaction-pay-middleware 0.0.0-stage → 1.0.0-preview-55fcf3ef7

package/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0]
+
+### Added
+
+- Initial release ([#10786](https://github.com/MetaMask/core/pull/10786))
+  - Add `walletPay`, the handler for the `wallet_pay` JSON-RPC method, which lets a connected dapp request a MetaMask Pay transaction and resolves with its `transactionHash`.
+  - Support the `perpsDeposit` and `perpsWithdraw` types.
+  - Gate each type per site with the `confirmations_pay_rpc` remote feature flag.
+  - Add the `TransactionPayMiddlewareMessenger`, `WalletPayHooks`, `WalletPayJsonRpcRequest` and `WalletPayResult` types.
+
+### Changed
+
+- Bump `@metamask/network-controller` from `^37.1.0` to `^37.1.1` ([#10982](https://github.com/MetaMask/core/pull/10982))
+- Bump `@metamask/perps-controller` from `^20.1.0` to `^21.0.0` ([#10988](https://github.com/MetaMask/core/pull/10988))
+
+[Unreleased]: https://github.com/MetaMask/core/compare/@metamask/transaction-pay-middleware@1.0.0...HEAD
+[1.0.0]: https://github.com/MetaMask/core/releases/tag/@metamask/transaction-pay-middleware@1.0.0

package/LICENSE

@@ -0,0 +1,6 @@
+This project is licensed under either of
+
+ * MIT license ([LICENSE.MIT](LICENSE.MIT))
+ * Apache License, Version 2.0 ([LICENSE.APACHE2](LICENSE.APACHE2))
+
+at your option.

package/LICENSE.APACHE2

@@ -0,0 +1,201 @@
+ Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/LICENSE.MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MetaMask
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,86 @@
-# Temporary Holding Version
+# `@metamask/transaction-pay-middleware`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Implements the `wallet_pay` JSON-RPC method, which lets dapps request MetaMask Pay transactions.
+
+## Installation
+
+`yarn add @metamask/transaction-pay-middleware`
+
+or
+
+`npm install @metamask/transaction-pay-middleware`
+
+## JSON-RPC Methods
+
+### wallet_pay
+
+Asks the user to confirm a MetaMask Pay transaction of the given type, and resolves once the transfer completes.
+
+**Parameters:**
+
+- `type` (string): The transaction type. Supported: `perpsDeposit`, `perpsWithdraw`.
+- `from` (string): The account to use. Must be connected to the requesting site.
+- `amount` (string, optional): The amount to prefill, as a decimal string with up to 6 decimals (for example `"10"` or `"12.5"`).
+
+Unknown fields are rejected.
+
+**Returns:**
+
+- `transactionHash` (string, optional): The hash to monitor. Omitted when the transfer completes without one.
+
+**Example:**
+
+```json
+{
+  "method": "wallet_pay",
+  "params": [
+    {
+      "type": "perpsDeposit",
+      "from": "0x1234567890123456789012345678901234567890",
+      "amount": "10"
+    }
+  ]
+}
+```
+
+**Errors:**
+
+| Code     | When                                                                                    |
+| -------- | --------------------------------------------------------------------------------------- |
+| `-32602` | The params are invalid. The message names each failing field.                           |
+| `-32601` | The type is unknown, or not enabled for the requesting site.                            |
+| `4100`   | `from` is not connected to the site.                                                    |
+| `-32004` | The user is not eligible for perps in their region (`data.reason: "perpsNotEligible"`). |
+| `4001`   | The user rejected the request.                                                          |
+
+## Usage
+
+`walletPay` is a JSON-RPC method handler. The client supplies a hook for the requesting site's connected accounts, and a messenger for the controllers it uses:
+
+```ts
+import { walletPay } from '@metamask/transaction-pay-middleware';
+
+const middleware = createScaffoldMiddleware({
+  wallet_pay: createAsyncMiddleware(async (req, res) => {
+    await walletPay(
+      req,
+      res,
+      {
+        getPermittedAccountsForOrigin: async () =>
+          getPermittedAccounts(req.origin),
+      },
+      transactionPayMiddlewareMessenger,
+    );
+  }),
+});
+```
+
+The messenger must allow:
+
+- `RemoteFeatureFlagController:getState`: `wallet_pay` is enabled per site and per type by the `confirmations_pay_rpc` flag, and `perpsWithdraw` also requires the in-wallet withdraw flag, `confirmations_pay_post_quote`.
+- `TransactionController:addTransaction` and `NetworkController:findNetworkClientIdByChainId`: the transaction is added for the requesting site. Its chain must already be configured; the dapp is expected to add it first.
+- `PerpsController:getState` and `PerpsController:refreshEligibility`: perps types check the user's eligibility.
+
+## Contributing
+
+This package is part of a monorepo. Instructions for contributing can be found in the [monorepo README](https://github.com/MetaMask/core#readme).

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const METHOD_NAMES: {
+    readonly WALLET_PAY: 'wallet_pay';
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;aACvB,UAAU,EAAE,YAAY;CAChB,CAAC"}

package/dist/constants.js

@@ -0,0 +1,4 @@
+export const METHOD_NAMES = {
+    WALLET_PAY: 'wallet_pay',
+};
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,UAAU,EAAE,YAAY;CAChB,CAAC","sourcesContent":["export const METHOD_NAMES = {\n  WALLET_PAY: 'wallet_pay',\n} as const;\n"]}

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+import type { JsonRpcError } from '@metamask/rpc-errors';
+/** Every error `wallet_pay` returns, besides ones from adding the transaction. */
+export declare const walletPayErrors: {
+    invalidParams: (details: string) => JsonRpcError<never>;
+    unsupportedType: (type: string) => JsonRpcError<never>;
+    unauthorizedAccount: () => JsonRpcError<never>;
+    networkUnavailable: (chainId: string) => JsonRpcError<never>;
+    perpsNotEligible: () => JsonRpcError<{
+        reason: string;
+    }>;
+};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAOzD,kFAAkF;AAClF,eAAO,MAAM,eAAe;IAC1B,aAAa,YAAY,MAAM,KAAG,YAAY,CAAC,KAAK,CAAC;IAKrD,eAAe,SAAS,MAAM,KAAG,YAAY,CAAC,KAAK,CAAC;IAKpD,mBAAmB,QAAM,YAAY,CAAC,KAAK,CAAC;IAK5C,kBAAkB,YAAY,MAAM,KAAG,YAAY,CAAC,KAAK,CAAC;IAM1D,gBAAgB,QAAM,YAAY,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CAKvD,CAAC"}

package/dist/errors.js

@@ -0,0 +1,24 @@
+import { providerErrors, rpcErrors } from '@metamask/rpc-errors';
+import { METHOD_NAMES } from './constants.js';
+const PREFIX = `${METHOD_NAMES.WALLET_PAY}:`;
+/** Every error `wallet_pay` returns, besides ones from adding the transaction. */
+export const walletPayErrors = {
+    invalidParams: (details) => rpcErrors.invalidParams({
+        message: `${PREFIX} invalid params.\n\n${details}`,
+    }),
+    unsupportedType: (type) => rpcErrors.methodNotFound({
+        message: `${PREFIX} type "${type}" is not available.`,
+    }),
+    unauthorizedAccount: () => providerErrors.unauthorized({
+        message: `${PREFIX} "from" is not an account connected to this site.`,
+    }),
+    networkUnavailable: (chainId) => rpcErrors.internal({
+        message: `${PREFIX} network ${chainId} is not configured.`,
+    }),
+    // Provisional code; to be confirmed with the Perps team before release.
+    perpsNotEligible: () => rpcErrors.methodNotSupported({
+        message: `${PREFIX} perps is not available in your region.`,
+        data: { reason: 'perpsNotEligible' },
+    }),
+};
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjE,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,MAAM,MAAM,GAAG,GAAG,YAAY,CAAC,UAAU,GAAG,CAAC;AAE7C,kFAAkF;AAClF,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,aAAa,EAAE,CAAC,OAAe,EAAuB,EAAE,CACtD,SAAS,CAAC,aAAa,CAAC;QACtB,OAAO,EAAE,GAAG,MAAM,uBAAuB,OAAO,EAAE;KACnD,CAAC;IAEJ,eAAe,EAAE,CAAC,IAAY,EAAuB,EAAE,CACrD,SAAS,CAAC,cAAc,CAAC;QACvB,OAAO,EAAE,GAAG,MAAM,UAAU,IAAI,qBAAqB;KACtD,CAAC;IAEJ,mBAAmB,EAAE,GAAwB,EAAE,CAC7C,cAAc,CAAC,YAAY,CAAC;QAC1B,OAAO,EAAE,GAAG,MAAM,mDAAmD;KACtE,CAAC;IAEJ,kBAAkB,EAAE,CAAC,OAAe,EAAuB,EAAE,CAC3D,SAAS,CAAC,QAAQ,CAAC;QACjB,OAAO,EAAE,GAAG,MAAM,YAAY,OAAO,qBAAqB;KAC3D,CAAC;IAEJ,wEAAwE;IACxE,gBAAgB,EAAE,GAAqC,EAAE,CACvD,SAAS,CAAC,kBAAkB,CAAC;QAC3B,OAAO,EAAE,GAAG,MAAM,yCAAyC;QAC3D,IAAI,EAAE,EAAE,MAAM,EAAE,kBAAkB,EAAE;KACrC,CAAC;CACL,CAAC","sourcesContent":["import type { JsonRpcError } from '@metamask/rpc-errors';\nimport { providerErrors, rpcErrors } from '@metamask/rpc-errors';\n\nimport { METHOD_NAMES } from './constants.js';\n\nconst PREFIX = `${METHOD_NAMES.WALLET_PAY}:`;\n\n/** Every error `wallet_pay` returns, besides ones from adding the transaction. */\nexport const walletPayErrors = {\n  invalidParams: (details: string): JsonRpcError<never> =>\n    rpcErrors.invalidParams({\n      message: `${PREFIX} invalid params.\\n\\n${details}`,\n    }),\n\n  unsupportedType: (type: string): JsonRpcError<never> =>\n    rpcErrors.methodNotFound({\n      message: `${PREFIX} type \"${type}\" is not available.`,\n    }),\n\n  unauthorizedAccount: (): JsonRpcError<never> =>\n    providerErrors.unauthorized({\n      message: `${PREFIX} \"from\" is not an account connected to this site.`,\n    }),\n\n  networkUnavailable: (chainId: string): JsonRpcError<never> =>\n    rpcErrors.internal({\n      message: `${PREFIX} network ${chainId} is not configured.`,\n    }),\n\n  // Provisional code; to be confirmed with the Perps team before release.\n  perpsNotEligible: (): JsonRpcError<{ reason: string }> =>\n    rpcErrors.methodNotSupported({\n      message: `${PREFIX} perps is not available in your region.`,\n      data: { reason: 'perpsNotEligible' },\n    }),\n};\n"]}

package/dist/flows/index.d.ts

@@ -0,0 +1,9 @@
+import type { WalletPayFlow } from '../types.js';
+/**
+ * Returns the flow for a transaction type, ignoring inherited object keys.
+ *
+ * @param transactionType - The requested transaction type.
+ * @returns The flow, or `undefined` if the type isn't supported.
+ */
+export declare function getWalletPayFlow(transactionType: string): WalletPayFlow | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/flows/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/flows/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AASjD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,eAAe,EAAE,MAAM,GACtB,aAAa,GAAG,SAAS,CAI3B"}

package/dist/flows/index.js

@@ -0,0 +1,19 @@
+import { TransactionType } from '@metamask/transaction-controller';
+import { perpsDepositFlow } from './perps/deposit.js';
+import { perpsWithdrawFlow } from './perps/withdraw.js';
+const WALLET_PAY_FLOWS = {
+    [TransactionType.perpsDeposit]: perpsDepositFlow,
+    [TransactionType.perpsWithdraw]: perpsWithdrawFlow,
+};
+/**
+ * Returns the flow for a transaction type, ignoring inherited object keys.
+ *
+ * @param transactionType - The requested transaction type.
+ * @returns The flow, or `undefined` if the type isn't supported.
+ */
+export function getWalletPayFlow(transactionType) {
+    return Object.hasOwn(WALLET_PAY_FLOWS, transactionType)
+        ? WALLET_PAY_FLOWS[transactionType]
+        : undefined;
+}
+//# sourceMappingURL=index.js.map

package/dist/flows/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/flows/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAGnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD,MAAM,gBAAgB,GAAkC;IACtD,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,gBAAgB;IAChD,CAAC,eAAe,CAAC,aAAa,CAAC,EAAE,iBAAiB;CACnD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,eAAuB;IAEvB,OAAO,MAAM,CAAC,MAAM,CAAC,gBAAgB,EAAE,eAAe,CAAC;QACrD,CAAC,CAAC,gBAAgB,CAAC,eAAe,CAAC;QACnC,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC","sourcesContent":["import { TransactionType } from '@metamask/transaction-controller';\n\nimport type { WalletPayFlow } from '../types.js';\nimport { perpsDepositFlow } from './perps/deposit.js';\nimport { perpsWithdrawFlow } from './perps/withdraw.js';\n\nconst WALLET_PAY_FLOWS: Record<string, WalletPayFlow> = {\n  [TransactionType.perpsDeposit]: perpsDepositFlow,\n  [TransactionType.perpsWithdraw]: perpsWithdrawFlow,\n};\n\n/**\n * Returns the flow for a transaction type, ignoring inherited object keys.\n *\n * @param transactionType - The requested transaction type.\n * @returns The flow, or `undefined` if the type isn't supported.\n */\nexport function getWalletPayFlow(\n  transactionType: string,\n): WalletPayFlow | undefined {\n  return Object.hasOwn(WALLET_PAY_FLOWS, transactionType)\n    ? WALLET_PAY_FLOWS[transactionType]\n    : undefined;\n}\n"]}

package/dist/flows/perps/deposit.d.ts

@@ -0,0 +1,8 @@
+import type { WalletPayFlow } from '../../types.js';
+/**
+ * `perpsDeposit`: a USDC transfer to the Hyperliquid bridge on Arbitrum,
+ * matching the in-wallet deposit. Uses the mainnet route directly, while the
+ * in-wallet flow takes it from the active perps provider.
+ */
+export declare const perpsDepositFlow: WalletPayFlow;
+//# sourceMappingURL=deposit.d.ts.map

package/dist/flows/perps/deposit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deposit.d.ts","sourceRoot":"","sources":["../../../src/flows/perps/deposit.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpD;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,aAiB9B,CAAC"}

package/dist/flows/perps/deposit.js

@@ -0,0 +1,26 @@
+import { toHex } from '@metamask/controller-utils';
+import { ARBITRUM_MAINNET_CHAIN_ID_HEX, DEPOSIT_CONFIG, HYPERLIQUID_BRIDGE_CONTRACTS, USDC_ARBITRUM_MAINNET_ADDRESS, } from '@metamask/perps-controller/constants/hyperLiquidConfig';
+import { generateERC20TransferData } from '@metamask/perps-controller/utils/transferData';
+import { TransactionType } from '@metamask/transaction-controller';
+import { assertPerpsEligible, toUsdcAmountRaw } from './shared.js';
+/**
+ * `perpsDeposit`: a USDC transfer to the Hyperliquid bridge on Arbitrum,
+ * matching the in-wallet deposit. Uses the mainnet route directly, while the
+ * in-wallet flow takes it from the active perps provider.
+ */
+export const perpsDepositFlow = {
+    assertPreconditions: assertPerpsEligible,
+    build: ({ from, amount }) => ({
+        chainId: ARBITRUM_MAINNET_CHAIN_ID_HEX,
+        transactionParams: {
+            from,
+            to: USDC_ARBITRUM_MAINNET_ADDRESS,
+            value: '0x0',
+            data: generateERC20TransferData(HYPERLIQUID_BRIDGE_CONTRACTS.mainnet.contractAddress, toUsdcAmountRaw(amount)),
+            gas: toHex(DEPOSIT_CONFIG.EstimatedGasLimit),
+        },
+        type: TransactionType.perpsDeposit,
+        skipInitialGasEstimate: true,
+    }),
+};
+//# sourceMappingURL=deposit.js.map

package/dist/flows/perps/deposit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deposit.js","sourceRoot":"","sources":["../../../src/flows/perps/deposit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACnD,OAAO,EACL,6BAA6B,EAC7B,cAAc,EACd,4BAA4B,EAC5B,6BAA6B,GAC9B,MAAM,wDAAwD,CAAC;AAChE,OAAO,EAAE,yBAAyB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAGnE,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnE;;;;GAIG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAkB;IAC7C,mBAAmB,EAAE,mBAAmB;IACxC,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;QAC5B,OAAO,EAAE,6BAA6B;QACtC,iBAAiB,EAAE;YACjB,IAAI;YACJ,EAAE,EAAE,6BAA6B;YACjC,KAAK,EAAE,KAAK;YACZ,IAAI,EAAE,yBAAyB,CAC7B,4BAA4B,CAAC,OAAO,CAAC,eAAe,EACpD,eAAe,CAAC,MAAM,CAAC,CACxB;YACD,GAAG,EAAE,KAAK,CAAC,cAAc,CAAC,iBAAiB,CAAC;SAC7C;QACD,IAAI,EAAE,eAAe,CAAC,YAAY;QAClC,sBAAsB,EAAE,IAAI;KAC7B,CAAC;CACH,CAAC","sourcesContent":["import { toHex } from '@metamask/controller-utils';\nimport {\n  ARBITRUM_MAINNET_CHAIN_ID_HEX,\n  DEPOSIT_CONFIG,\n  HYPERLIQUID_BRIDGE_CONTRACTS,\n  USDC_ARBITRUM_MAINNET_ADDRESS,\n} from '@metamask/perps-controller/constants/hyperLiquidConfig';\nimport { generateERC20TransferData } from '@metamask/perps-controller/utils/transferData';\nimport { TransactionType } from '@metamask/transaction-controller';\n\nimport type { WalletPayFlow } from '../../types.js';\nimport { assertPerpsEligible, toUsdcAmountRaw } from './shared.js';\n\n/**\n * `perpsDeposit`: a USDC transfer to the Hyperliquid bridge on Arbitrum,\n * matching the in-wallet deposit. Uses the mainnet route directly, while the\n * in-wallet flow takes it from the active perps provider.\n */\nexport const perpsDepositFlow: WalletPayFlow = {\n  assertPreconditions: assertPerpsEligible,\n  build: ({ from, amount }) => ({\n    chainId: ARBITRUM_MAINNET_CHAIN_ID_HEX,\n    transactionParams: {\n      from,\n      to: USDC_ARBITRUM_MAINNET_ADDRESS,\n      value: '0x0',\n      data: generateERC20TransferData(\n        HYPERLIQUID_BRIDGE_CONTRACTS.mainnet.contractAddress,\n        toUsdcAmountRaw(amount),\n      ),\n      gas: toHex(DEPOSIT_CONFIG.EstimatedGasLimit),\n    },\n    type: TransactionType.perpsDeposit,\n    skipInitialGasEstimate: true,\n  }),\n};\n"]}

package/dist/flows/perps/shared.d.ts

@@ -0,0 +1,16 @@
+import type { Hex } from '@metamask/utils';
+import type { TransactionPayMiddlewareMessenger } from '../../types.js';
+/**
+ * Converts a USDC amount to its raw hex value.
+ *
+ * @param amount - The decimal amount, or `undefined` for no amount.
+ * @returns The raw amount, or `0x0` when no amount is given.
+ */
+export declare function toUsdcAmountRaw(amount: string | undefined): Hex;
+/**
+ * Throws the geo-block error when the user isn't eligible for perps.
+ *
+ * @param messenger - The middleware messenger.
+ */
+export declare function assertPerpsEligible(messenger: TransactionPayMiddlewareMessenger): Promise<void>;
+//# sourceMappingURL=shared.d.ts.map

package/dist/flows/perps/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/flows/perps/shared.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAI3C,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,gBAAgB,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,GAAG,CAM/D;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CACvC,SAAS,EAAE,iCAAiC,GAC3C,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/flows/perps/shared.js

@@ -0,0 +1,33 @@
+import { USDC_DECIMALS } from '@metamask/perps-controller/constants/hyperLiquidConfig';
+import { add0x } from '@metamask/utils';
+import { BigNumber } from 'bignumber.js';
+import { walletPayErrors } from '../../errors.js';
+/**
+ * Converts a USDC amount to its raw hex value.
+ *
+ * @param amount - The decimal amount, or `undefined` for no amount.
+ * @returns The raw amount, or `0x0` when no amount is given.
+ */
+export function toUsdcAmountRaw(amount) {
+    if (amount === undefined) {
+        return '0x0';
+    }
+    return add0x(new BigNumber(amount).shiftedBy(USDC_DECIMALS).toString(16));
+}
+/**
+ * Throws the geo-block error when the user isn't eligible for perps.
+ *
+ * @param messenger - The middleware messenger.
+ */
+export async function assertPerpsEligible(messenger) {
+    if (messenger.call('PerpsController:getState').isEligible) {
+        return;
+    }
+    // `isEligible` starts as false until the first check completes, so refresh
+    // once before blocking.
+    await messenger.call('PerpsController:refreshEligibility');
+    if (!messenger.call('PerpsController:getState').isEligible) {
+        throw walletPayErrors.perpsNotEligible();
+    }
+}
+//# sourceMappingURL=shared.js.map

package/dist/flows/perps/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../../../src/flows/perps/shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wDAAwD,CAAC;AACvF,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD;;;;;GAKG;AACH,MAAM,UAAU,eAAe,CAAC,MAA0B;IACxD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,SAAS,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,SAA4C;IAE5C,IAAI,SAAS,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC,UAAU,EAAE,CAAC;QAC1D,OAAO;IACT,CAAC;IAED,2EAA2E;IAC3E,wBAAwB;IACxB,MAAM,SAAS,CAAC,IAAI,CAAC,oCAAoC,CAAC,CAAC;IAE3D,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC,UAAU,EAAE,CAAC;QAC3D,MAAM,eAAe,CAAC,gBAAgB,EAAE,CAAC;IAC3C,CAAC;AACH,CAAC","sourcesContent":["import { USDC_DECIMALS } from '@metamask/perps-controller/constants/hyperLiquidConfig';\nimport { add0x } from '@metamask/utils';\nimport type { Hex } from '@metamask/utils';\nimport { BigNumber } from 'bignumber.js';\n\nimport { walletPayErrors } from '../../errors.js';\nimport type { TransactionPayMiddlewareMessenger } from '../../types.js';\n\n/**\n * Converts a USDC amount to its raw hex value.\n *\n * @param amount - The decimal amount, or `undefined` for no amount.\n * @returns The raw amount, or `0x0` when no amount is given.\n */\nexport function toUsdcAmountRaw(amount: string | undefined): Hex {\n  if (amount === undefined) {\n    return '0x0';\n  }\n\n  return add0x(new BigNumber(amount).shiftedBy(USDC_DECIMALS).toString(16));\n}\n\n/**\n * Throws the geo-block error when the user isn't eligible for perps.\n *\n * @param messenger - The middleware messenger.\n */\nexport async function assertPerpsEligible(\n  messenger: TransactionPayMiddlewareMessenger,\n): Promise<void> {\n  if (messenger.call('PerpsController:getState').isEligible) {\n    return;\n  }\n\n  // `isEligible` starts as false until the first check completes, so refresh\n  // once before blocking.\n  await messenger.call('PerpsController:refreshEligibility');\n\n  if (!messenger.call('PerpsController:getState').isEligible) {\n    throw walletPayErrors.perpsNotEligible();\n  }\n}\n"]}

package/dist/flows/perps/withdraw.d.ts

@@ -0,0 +1,9 @@
+import type { WalletPayFlow } from '../../types.js';
+/**
+ * `perpsWithdraw`: the same placeholder USDC transfer to `from` the in-wallet
+ * withdraw uses; the confirmation and Pay turn it into the Hyperliquid
+ * withdraw. Gas isn't estimated upfront: the funds are on Hyperliquid, so the
+ * placeholder transfer would fail to estimate.
+ */
+export declare const perpsWithdrawFlow: WalletPayFlow;
+//# sourceMappingURL=withdraw.d.ts.map

package/dist/flows/perps/withdraw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdraw.d.ts","sourceRoot":"","sources":["../../../src/flows/perps/withdraw.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAIpD;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAgB/B,CAAC"}

package/dist/flows/perps/withdraw.js

@@ -0,0 +1,28 @@
+import { ARBITRUM_MAINNET_CHAIN_ID_HEX, USDC_ARBITRUM_MAINNET_ADDRESS, } from '@metamask/perps-controller/constants/hyperLiquidConfig';
+import { generateERC20TransferData } from '@metamask/perps-controller/utils/transferData';
+import { TransactionType } from '@metamask/transaction-controller';
+import { isPayFlowEnabled } from '../../utils/feature-flags.js';
+import { assertPerpsEligible, toUsdcAmountRaw } from './shared.js';
+/**
+ * `perpsWithdraw`: the same placeholder USDC transfer to `from` the in-wallet
+ * withdraw uses; the confirmation and Pay turn it into the Hyperliquid
+ * withdraw. Gas isn't estimated upfront: the funds are on Hyperliquid, so the
+ * placeholder transfer would fail to estimate.
+ */
+export const perpsWithdrawFlow = {
+    // Reuses the in-wallet withdraw flow, so it also needs that flow's flag.
+    isEnabled: (remoteFeatureFlags) => isPayFlowEnabled(remoteFeatureFlags, TransactionType.perpsWithdraw),
+    assertPreconditions: assertPerpsEligible,
+    build: ({ from, amount }) => ({
+        chainId: ARBITRUM_MAINNET_CHAIN_ID_HEX,
+        transactionParams: {
+            from,
+            to: USDC_ARBITRUM_MAINNET_ADDRESS,
+            value: '0x0',
+            data: generateERC20TransferData(from, toUsdcAmountRaw(amount)),
+        },
+        type: TransactionType.perpsWithdraw,
+        skipInitialGasEstimate: true,
+    }),
+};
+//# sourceMappingURL=withdraw.js.map

package/dist/flows/perps/withdraw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdraw.js","sourceRoot":"","sources":["../../../src/flows/perps/withdraw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,6BAA6B,EAC7B,6BAA6B,GAC9B,MAAM,wDAAwD,CAAC;AAChE,OAAO,EAAE,yBAAyB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAGnE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAkB;IAC9C,yEAAyE;IACzE,SAAS,EAAE,CAAC,kBAAkB,EAAE,EAAE,CAChC,gBAAgB,CAAC,kBAAkB,EAAE,eAAe,CAAC,aAAa,CAAC;IACrE,mBAAmB,EAAE,mBAAmB;IACxC,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;QAC5B,OAAO,EAAE,6BAA6B;QACtC,iBAAiB,EAAE;YACjB,IAAI;YACJ,EAAE,EAAE,6BAA6B;YACjC,KAAK,EAAE,KAAK;YACZ,IAAI,EAAE,yBAAyB,CAAC,IAAI,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;SAC/D;QACD,IAAI,EAAE,eAAe,CAAC,aAAa;QACnC,sBAAsB,EAAE,IAAI;KAC7B,CAAC;CACH,CAAC","sourcesContent":["import {\n  ARBITRUM_MAINNET_CHAIN_ID_HEX,\n  USDC_ARBITRUM_MAINNET_ADDRESS,\n} from '@metamask/perps-controller/constants/hyperLiquidConfig';\nimport { generateERC20TransferData } from '@metamask/perps-controller/utils/transferData';\nimport { TransactionType } from '@metamask/transaction-controller';\n\nimport type { WalletPayFlow } from '../../types.js';\nimport { isPayFlowEnabled } from '../../utils/feature-flags.js';\nimport { assertPerpsEligible, toUsdcAmountRaw } from './shared.js';\n\n/**\n * `perpsWithdraw`: the same placeholder USDC transfer to `from` the in-wallet\n * withdraw uses; the confirmation and Pay turn it into the Hyperliquid\n * withdraw. Gas isn't estimated upfront: the funds are on Hyperliquid, so the\n * placeholder transfer would fail to estimate.\n */\nexport const perpsWithdrawFlow: WalletPayFlow = {\n  // Reuses the in-wallet withdraw flow, so it also needs that flow's flag.\n  isEnabled: (remoteFeatureFlags) =>\n    isPayFlowEnabled(remoteFeatureFlags, TransactionType.perpsWithdraw),\n  assertPreconditions: assertPerpsEligible,\n  build: ({ from, amount }) => ({\n    chainId: ARBITRUM_MAINNET_CHAIN_ID_HEX,\n    transactionParams: {\n      from,\n      to: USDC_ARBITRUM_MAINNET_ADDRESS,\n      value: '0x0',\n      data: generateERC20TransferData(from, toUsdcAmountRaw(amount)),\n    },\n    type: TransactionType.perpsWithdraw,\n    skipInitialGasEstimate: true,\n  }),\n};\n"]}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { walletPay } from './methods/wallet_pay.js';
+export type { TransactionPayMiddlewareMessenger, WalletPayHooks, WalletPayJsonRpcRequest, WalletPayResult, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,YAAY,EACV,iCAAiC,EACjC,cAAc,EACd,uBAAuB,EACvB,eAAe,GAChB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { walletPay } from './methods/wallet_pay.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC","sourcesContent":["export { walletPay } from './methods/wallet_pay.js';\nexport type {\n  TransactionPayMiddlewareMessenger,\n  WalletPayHooks,\n  WalletPayJsonRpcRequest,\n  WalletPayResult,\n} from './types.js';\n"]}

package/dist/methods/wallet_pay.d.ts

@@ -0,0 +1,14 @@
+import type { PendingJsonRpcResponse } from '@metamask/utils';
+import type { TransactionPayMiddlewareMessenger, WalletPayHooks, WalletPayJsonRpcRequest } from '../types.js';
+/**
+ * The RPC method handler for `wallet_pay`: validates the request, checks the
+ * flags and the account, then adds the transaction for the requesting dapp and
+ * waits for its hash.
+ *
+ * @param req - The JSON-RPC request.
+ * @param res - The pending JSON-RPC response.
+ * @param hooks - Client hooks.
+ * @param messenger - The middleware messenger.
+ */
+export declare function walletPay(req: WalletPayJsonRpcRequest, res: PendingJsonRpcResponse, hooks: WalletPayHooks, messenger: TransactionPayMiddlewareMessenger): Promise<void>;
+//# sourceMappingURL=wallet_pay.d.ts.map

package/dist/methods/wallet_pay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet_pay.d.ts","sourceRoot":"","sources":["../../src/methods/wallet_pay.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAO,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAKnE,OAAO,KAAK,EACV,iCAAiC,EAEjC,cAAc,EACd,uBAAuB,EAIxB,MAAM,aAAa,CAAC;AAMrB;;;;;;;;;GASG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,uBAAuB,EAC5B,GAAG,EAAE,sBAAsB,EAC3B,KAAK,EAAE,cAAc,EACrB,SAAS,EAAE,iCAAiC,GAC3C,OAAO,CAAC,IAAI,CAAC,CAef"}

package/dist/methods/wallet_pay.js

@@ -0,0 +1,79 @@
+import { validate } from '@metamask/superstruct';
+import { walletPayErrors } from '../errors.js';
+import { getWalletPayFlow } from '../flows/index.js';
+import { WalletPayParamsStruct } from '../types.js';
+import { isWalletPayTypeAllowed } from '../utils/feature-flags.js';
+// Some providers resolve with this placeholder when there is no hash.
+const FALLBACK_TRANSACTION_HASH = '0x0';
+/**
+ * The RPC method handler for `wallet_pay`: validates the request, checks the
+ * flags and the account, then adds the transaction for the requesting dapp and
+ * waits for its hash.
+ *
+ * @param req - The JSON-RPC request.
+ * @param res - The pending JSON-RPC response.
+ * @param hooks - Client hooks.
+ * @param messenger - The middleware messenger.
+ */
+export async function walletPay(req, res, hooks, messenger) {
+    const request = validateRequest(req.params);
+    const flow = getAllowedFlow(messenger, req.origin, request.type);
+    await assertPermittedAccount(hooks, request.from);
+    await flow.assertPreconditions?.(messenger);
+    const hash = await addTransaction(messenger, flow.build(request), req);
+    const result = hash && hash !== FALLBACK_TRANSACTION_HASH
+        ? { transactionHash: hash }
+        : {};
+    res.result = result;
+}
+function validateRequest(params) {
+    const [error, validated] = validate(params, WalletPayParamsStruct);
+    if (error) {
+        throw walletPayErrors.invalidParams(formatValidationError(error));
+    }
+    return validated[0];
+}
+function getAllowedFlow(messenger, origin, transactionType) {
+    const flow = getWalletPayFlow(transactionType);
+    const { remoteFeatureFlags } = messenger.call('RemoteFeatureFlagController:getState');
+    if (!flow ||
+        !isWalletPayTypeAllowed(remoteFeatureFlags, origin, transactionType) ||
+        !(flow.isEnabled?.(remoteFeatureFlags) ?? true)) {
+        throw walletPayErrors.unsupportedType(transactionType);
+    }
+    return flow;
+}
+async function assertPermittedAccount(hooks, from) {
+    const permittedAccounts = await hooks.getPermittedAccountsForOrigin();
+    const isPermitted = permittedAccounts.some((account) => account.toLowerCase() === from.toLowerCase());
+    if (!isPermitted) {
+        throw walletPayErrors.unauthorizedAccount();
+    }
+}
+async function addTransaction(messenger, { chainId, transactionParams, type, skipInitialGasEstimate, }, req) {
+    const { result } = await messenger.call('TransactionController:addTransaction', transactionParams, {
+        networkClientId: getNetworkClientId(messenger, chainId),
+        origin: req.origin,
+        requestId: String(req.id),
+        method: req.method,
+        requireApproval: true,
+        type,
+        skipInitialGasEstimate,
+    });
+    return await result;
+}
+function getNetworkClientId(messenger, chainId) {
+    try {
+        return messenger.call('NetworkController:findNetworkClientIdByChainId', chainId);
+    }
+    catch {
+        throw walletPayErrors.networkUnavailable(chainId);
+    }
+}
+function formatValidationError(error) {
+    return error
+        .failures()
+        .map(({ path, message }) => `${path.join(' > ')}${path.length ? ' - ' : ''}${message}`)
+        .join('\n');
+}
+//# sourceMappingURL=wallet_pay.js.map

package/dist/methods/wallet_pay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet_pay.js","sourceRoot":"","sources":["../../src/methods/wallet_pay.ts"],"names":[],"mappings":"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","sourcesContent":["import type { StructError } from '@metamask/superstruct';\nimport { validate } from '@metamask/superstruct';\nimport type { Hex, PendingJsonRpcResponse } from '@metamask/utils';\n\nimport { walletPayErrors } from '../errors.js';\nimport { getWalletPayFlow } from '../flows/index.js';\nimport { WalletPayParamsStruct } from '../types.js';\nimport type {\n  TransactionPayMiddlewareMessenger,\n  WalletPayFlow,\n  WalletPayHooks,\n  WalletPayJsonRpcRequest,\n  WalletPayRequest,\n  WalletPayResult,\n  WalletPayTransaction,\n} from '../types.js';\nimport { isWalletPayTypeAllowed } from '../utils/feature-flags.js';\n\n// Some providers resolve with this placeholder when there is no hash.\nconst FALLBACK_TRANSACTION_HASH = '0x0';\n\n/**\n * The RPC method handler for `wallet_pay`: validates the request, checks the\n * flags and the account, then adds the transaction for the requesting dapp and\n * waits for its hash.\n *\n * @param req - The JSON-RPC request.\n * @param res - The pending JSON-RPC response.\n * @param hooks - Client hooks.\n * @param messenger - The middleware messenger.\n */\nexport async function walletPay(\n  req: WalletPayJsonRpcRequest,\n  res: PendingJsonRpcResponse,\n  hooks: WalletPayHooks,\n  messenger: TransactionPayMiddlewareMessenger,\n): Promise<void> {\n  const request = validateRequest(req.params);\n  const flow = getAllowedFlow(messenger, req.origin, request.type);\n\n  await assertPermittedAccount(hooks, request.from);\n  await flow.assertPreconditions?.(messenger);\n\n  const hash = await addTransaction(messenger, flow.build(request), req);\n\n  const result: WalletPayResult =\n    hash && hash !== FALLBACK_TRANSACTION_HASH\n      ? { transactionHash: hash as Hex }\n      : {};\n\n  res.result = result;\n}\n\nfunction validateRequest(params: unknown): WalletPayRequest {\n  const [error, validated] = validate(params, WalletPayParamsStruct);\n\n  if (error) {\n    throw walletPayErrors.invalidParams(formatValidationError(error));\n  }\n\n  return validated[0];\n}\n\nfunction getAllowedFlow(\n  messenger: TransactionPayMiddlewareMessenger,\n  origin: string,\n  transactionType: string,\n): WalletPayFlow {\n  const flow = getWalletPayFlow(transactionType);\n  const { remoteFeatureFlags } = messenger.call(\n    'RemoteFeatureFlagController:getState',\n  );\n\n  if (\n    !flow ||\n    !isWalletPayTypeAllowed(remoteFeatureFlags, origin, transactionType) ||\n    !(flow.isEnabled?.(remoteFeatureFlags) ?? true)\n  ) {\n    throw walletPayErrors.unsupportedType(transactionType);\n  }\n\n  return flow;\n}\n\nasync function assertPermittedAccount(\n  hooks: WalletPayHooks,\n  from: Hex,\n): Promise<void> {\n  const permittedAccounts = await hooks.getPermittedAccountsForOrigin();\n  const isPermitted = permittedAccounts.some(\n    (account) => account.toLowerCase() === from.toLowerCase(),\n  );\n\n  if (!isPermitted) {\n    throw walletPayErrors.unauthorizedAccount();\n  }\n}\n\nasync function addTransaction(\n  messenger: TransactionPayMiddlewareMessenger,\n  {\n    chainId,\n    transactionParams,\n    type,\n    skipInitialGasEstimate,\n  }: WalletPayTransaction,\n  req: WalletPayJsonRpcRequest,\n): Promise<string> {\n  const { result } = await messenger.call(\n    'TransactionController:addTransaction',\n    transactionParams,\n    {\n      networkClientId: getNetworkClientId(messenger, chainId),\n      origin: req.origin,\n      requestId: String(req.id),\n      method: req.method,\n      requireApproval: true,\n      type,\n      skipInitialGasEstimate,\n    },\n  );\n\n  return await result;\n}\n\nfunction getNetworkClientId(\n  messenger: TransactionPayMiddlewareMessenger,\n  chainId: Hex,\n): string {\n  try {\n    return messenger.call(\n      'NetworkController:findNetworkClientIdByChainId',\n      chainId,\n    );\n  } catch {\n    throw walletPayErrors.networkUnavailable(chainId);\n  }\n}\n\nfunction formatValidationError(error: StructError): string {\n  return error\n    .failures()\n    .map(\n      ({ path, message }) =>\n        `${path.join(' > ')}${path.length ? ' - ' : ''}${message}`,\n    )\n    .join('\\n');\n}\n"]}

package/dist/types.d.ts

@@ -0,0 +1,43 @@
+import type { Messenger } from '@metamask/messenger';
+import type { NetworkControllerFindNetworkClientIdByChainIdAction } from '@metamask/network-controller';
+import type { PerpsControllerGetStateAction, PerpsControllerRefreshEligibilityAction } from '@metamask/perps-controller';
+import type { RemoteFeatureFlagControllerGetStateAction } from '@metamask/remote-feature-flag-controller';
+import type { Infer } from '@metamask/superstruct';
+import type { TransactionControllerAddTransactionAction, TransactionParams, TransactionType } from '@metamask/transaction-controller';
+import type { Hex, Json, JsonRpcRequest } from '@metamask/utils';
+import type { RemoteFeatureFlags } from './utils/feature-flags.js';
+type AllowedActions = NetworkControllerFindNetworkClientIdByChainIdAction | PerpsControllerGetStateAction | PerpsControllerRefreshEligibilityAction | RemoteFeatureFlagControllerGetStateAction | TransactionControllerAddTransactionAction;
+export type TransactionPayMiddlewareMessenger = Messenger<'TransactionPayMiddleware', AllowedActions>;
+export declare const WalletPayParamsStruct: import("@metamask/superstruct").Struct<[{
+    type: string;
+    from: `0x${string}`;
+    amount?: string | undefined;
+}], null>;
+export type WalletPayRequest = Infer<typeof WalletPayParamsStruct>[0];
+/** Result of `wallet_pay`, returned once the transfer completes. */
+export type WalletPayResult = {
+    transactionHash?: Hex;
+};
+/** A transaction built for a `wallet_pay` request, ready to add. */
+export type WalletPayTransaction = {
+    chainId: Hex;
+    transactionParams: TransactionParams;
+    type: TransactionType;
+    skipInitialGasEstimate?: boolean;
+};
+/** How one `wallet_pay` type is enabled, checked and built. */
+export type WalletPayFlow = {
+    /** Flag checks beyond `confirmations_pay_rpc`, if the type needs any. */
+    isEnabled?: (remoteFeatureFlags: RemoteFeatureFlags) => boolean;
+    assertPreconditions?: (messenger: TransactionPayMiddlewareMessenger) => Promise<void>;
+    build: (request: WalletPayRequest) => WalletPayTransaction;
+};
+export type WalletPayJsonRpcRequest = JsonRpcRequest<Json[]> & {
+    origin: string;
+};
+export type WalletPayHooks = {
+    /** Returns the accounts the requesting origin is connected to. */
+    getPermittedAccountsForOrigin: () => Promise<string[]>;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,mDAAmD,EAAE,MAAM,8BAA8B,CAAC;AACxG,OAAO,KAAK,EACV,6BAA6B,EAC7B,uCAAuC,EACxC,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,yCAAyC,EAAE,MAAM,0CAA0C,CAAC;AAC1G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AASnD,OAAO,KAAK,EACV,yCAAyC,EACzC,iBAAiB,EACjB,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE,KAAK,cAAc,GACf,mDAAmD,GACnD,6BAA6B,GAC7B,uCAAuC,GACvC,yCAAyC,GACzC,yCAAyC,CAAC;AAE9C,MAAM,MAAM,iCAAiC,GAAG,SAAS,CACvD,0BAA0B,EAC1B,cAAc,CACf,CAAC;AAKF,eAAO,MAAM,qBAAqB;;;;SAMhC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtE,oEAAoE;AACpE,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,CAAC,EAAE,GAAG,CAAC;CACvB,CAAC;AAEF,oEAAoE;AACpE,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,GAAG,CAAC;IACb,iBAAiB,EAAE,iBAAiB,CAAC;IACrC,IAAI,EAAE,eAAe,CAAC;IACtB,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC,CAAC;AAEF,+DAA+D;AAC/D,MAAM,MAAM,aAAa,GAAG;IAC1B,yEAAyE;IACzE,SAAS,CAAC,EAAE,CAAC,kBAAkB,EAAE,kBAAkB,KAAK,OAAO,CAAC;IAChE,mBAAmB,CAAC,EAAE,CACpB,SAAS,EAAE,iCAAiC,KACzC,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,KAAK,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,oBAAoB,CAAC;CAC5D,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC,IAAI,EAAE,CAAC,GAAG;IAC7D,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,kEAAkE;IAClE,6BAA6B,EAAE,MAAM,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACxD,CAAC"}

package/dist/types.js

@@ -0,0 +1,12 @@
+import { nonempty, object, optional, pattern, string, tuple, } from '@metamask/superstruct';
+import { HexChecksumAddressStruct } from '@metamask/utils';
+/** A positive decimal string with up to 6 decimals. */
+const AmountStruct = pattern(string(), /^(?!0+(\.0+)?$)\d+(\.\d{1,6})?$/u);
+export const WalletPayParamsStruct = tuple([
+    object({
+        type: nonempty(string()),
+        from: HexChecksumAddressStruct,
+        amount: optional(AmountStruct),
+    }),
+]);
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,OAAO,EACP,MAAM,EACN,KAAK,GACN,MAAM,uBAAuB,CAAC;AAO/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAgB3D,uDAAuD;AACvD,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,kCAAkC,CAAC,CAAC;AAE3E,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,CAAC;IACzC,MAAM,CAAC;QACL,IAAI,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC;QACxB,IAAI,EAAE,wBAAwB;QAC9B,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC;KAC/B,CAAC;CACH,CAAC,CAAC","sourcesContent":["import type { Messenger } from '@metamask/messenger';\nimport type { NetworkControllerFindNetworkClientIdByChainIdAction } from '@metamask/network-controller';\nimport type {\n  PerpsControllerGetStateAction,\n  PerpsControllerRefreshEligibilityAction,\n} from '@metamask/perps-controller';\nimport type { RemoteFeatureFlagControllerGetStateAction } from '@metamask/remote-feature-flag-controller';\nimport type { Infer } from '@metamask/superstruct';\nimport {\n  nonempty,\n  object,\n  optional,\n  pattern,\n  string,\n  tuple,\n} from '@metamask/superstruct';\nimport type {\n  TransactionControllerAddTransactionAction,\n  TransactionParams,\n  TransactionType,\n} from '@metamask/transaction-controller';\nimport type { Hex, Json, JsonRpcRequest } from '@metamask/utils';\nimport { HexChecksumAddressStruct } from '@metamask/utils';\n\nimport type { RemoteFeatureFlags } from './utils/feature-flags.js';\n\ntype AllowedActions =\n  | NetworkControllerFindNetworkClientIdByChainIdAction\n  | PerpsControllerGetStateAction\n  | PerpsControllerRefreshEligibilityAction\n  | RemoteFeatureFlagControllerGetStateAction\n  | TransactionControllerAddTransactionAction;\n\nexport type TransactionPayMiddlewareMessenger = Messenger<\n  'TransactionPayMiddleware',\n  AllowedActions\n>;\n\n/** A positive decimal string with up to 6 decimals. */\nconst AmountStruct = pattern(string(), /^(?!0+(\\.0+)?$)\\d+(\\.\\d{1,6})?$/u);\n\nexport const WalletPayParamsStruct = tuple([\n  object({\n    type: nonempty(string()),\n    from: HexChecksumAddressStruct,\n    amount: optional(AmountStruct),\n  }),\n]);\n\nexport type WalletPayRequest = Infer<typeof WalletPayParamsStruct>[0];\n\n/** Result of `wallet_pay`, returned once the transfer completes. */\nexport type WalletPayResult = {\n  transactionHash?: Hex;\n};\n\n/** A transaction built for a `wallet_pay` request, ready to add. */\nexport type WalletPayTransaction = {\n  chainId: Hex;\n  transactionParams: TransactionParams;\n  type: TransactionType;\n  skipInitialGasEstimate?: boolean;\n};\n\n/** How one `wallet_pay` type is enabled, checked and built. */\nexport type WalletPayFlow = {\n  /** Flag checks beyond `confirmations_pay_rpc`, if the type needs any. */\n  isEnabled?: (remoteFeatureFlags: RemoteFeatureFlags) => boolean;\n  assertPreconditions?: (\n    messenger: TransactionPayMiddlewareMessenger,\n  ) => Promise<void>;\n  build: (request: WalletPayRequest) => WalletPayTransaction;\n};\n\nexport type WalletPayJsonRpcRequest = JsonRpcRequest<Json[]> & {\n  origin: string;\n};\n\nexport type WalletPayHooks = {\n  /** Returns the accounts the requesting origin is connected to. */\n  getPermittedAccountsForOrigin: () => Promise<string[]>;\n};\n"]}

package/dist/utils/feature-flags.d.ts

@@ -0,0 +1,36 @@
+import type { Json } from '@metamask/utils';
+/**
+ * Lists which transaction types each dapp origin may request through
+ * `wallet_pay`. A type must also be enabled at the top level (the kill
+ * switch).
+ */
+export declare const WALLET_PAY_FEATURE_FLAG = "confirmations_pay_rpc";
+/**
+ * Gates in-wallet MetaMask Pay flows per transaction type. A dapp request that
+ * reuses an in-wallet flow is gated by it too.
+ */
+export declare const PAY_POST_QUOTE_FEATURE_FLAG = "confirmations_pay_post_quote";
+export type RemoteFeatureFlags = Record<string, Json>;
+/**
+ * Whether a dapp may request a transaction type, based on
+ * `confirmations_pay_rpc`. Origins match exactly, scheme included, except
+ * `http://localhost`, which matches any port. A missing or malformed flag
+ * allows nothing.
+ *
+ * @param remoteFeatureFlags - The remote feature flags.
+ * @param origin - The requesting dapp's origin.
+ * @param transactionType - The requested transaction type.
+ * @returns Whether the request is allowed.
+ */
+export declare function isWalletPayTypeAllowed(remoteFeatureFlags: RemoteFeatureFlags, origin: string, transactionType: string): boolean;
+/**
+ * Whether the in-wallet flow for a transaction type is enabled by
+ * `confirmations_pay_post_quote`. A type-specific entry (under `overrides`, or
+ * directly) wins over `default`.
+ *
+ * @param remoteFeatureFlags - The remote feature flags.
+ * @param transactionType - The transaction type.
+ * @returns Whether the flow is enabled.
+ */
+export declare function isPayFlowEnabled(remoteFeatureFlags: RemoteFeatureFlags, transactionType: string): boolean;
+//# sourceMappingURL=feature-flags.d.ts.map

package/dist/utils/feature-flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.d.ts","sourceRoot":"","sources":["../../src/utils/feature-flags.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,0BAA0B,CAAC;AAE/D;;;GAGG;AACH,eAAO,MAAM,2BAA2B,iCAAiC,CAAC;AAoB1E,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,kBAAkB,EAAE,kBAAkB,EACtC,MAAM,EAAE,MAAM,EACd,eAAe,EAAE,MAAM,GACtB,OAAO,CAsBT;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,kBAAkB,EAAE,kBAAkB,EACtC,eAAe,EAAE,MAAM,GACtB,OAAO,CAaT"}

package/dist/utils/feature-flags.js

@@ -0,0 +1,79 @@
+import { array, boolean, is, optional, record, string, type, } from '@metamask/superstruct';
+/**
+ * Lists which transaction types each dapp origin may request through
+ * `wallet_pay`. A type must also be enabled at the top level (the kill
+ * switch).
+ */
+export const WALLET_PAY_FEATURE_FLAG = 'confirmations_pay_rpc';
+/**
+ * Gates in-wallet MetaMask Pay flows per transaction type. A dapp request that
+ * reuses an in-wallet flow is gated by it too.
+ */
+export const PAY_POST_QUOTE_FEATURE_FLAG = 'confirmations_pay_post_quote';
+// `localhost` is allowed on any port, so local development servers work
+// without listing every port in the flag.
+const LOCALHOST_ORIGIN = 'http://localhost';
+const AllowedTypesStruct = type({ allowedTypes: array(string()) });
+const WalletPayFeatureFlagStruct = type({
+    allowedTypes: array(string()),
+    dapps: record(string(), AllowedTypesStruct),
+});
+const PayFlowConfigStruct = type({ enabled: optional(boolean()) });
+const PayPostQuoteFeatureFlagStruct = type({
+    default: optional(PayFlowConfigStruct),
+    overrides: optional(record(string(), PayFlowConfigStruct)),
+});
+/**
+ * Whether a dapp may request a transaction type, based on
+ * `confirmations_pay_rpc`. Origins match exactly, scheme included, except
+ * `http://localhost`, which matches any port. A missing or malformed flag
+ * allows nothing.
+ *
+ * @param remoteFeatureFlags - The remote feature flags.
+ * @param origin - The requesting dapp's origin.
+ * @param transactionType - The requested transaction type.
+ * @returns Whether the request is allowed.
+ */
+export function isWalletPayTypeAllowed(remoteFeatureFlags, origin, transactionType) {
+    const flag = remoteFeatureFlags[WALLET_PAY_FEATURE_FLAG];
+    if (!is(flag, WalletPayFeatureFlagStruct) ||
+        !flag.allowedTypes.includes(transactionType)) {
+        return false;
+    }
+    const url = parseUrl(origin);
+    if (!url) {
+        return false;
+    }
+    const isLocalhost = url.protocol === 'http:' && url.hostname === 'localhost';
+    const dappConfig = flag.dapps[url.origin] ??
+        (isLocalhost ? flag.dapps[LOCALHOST_ORIGIN] : undefined);
+    return dappConfig?.allowedTypes.includes(transactionType) ?? false;
+}
+/**
+ * Whether the in-wallet flow for a transaction type is enabled by
+ * `confirmations_pay_post_quote`. A type-specific entry (under `overrides`, or
+ * directly) wins over `default`.
+ *
+ * @param remoteFeatureFlags - The remote feature flags.
+ * @param transactionType - The transaction type.
+ * @returns Whether the flow is enabled.
+ */
+export function isPayFlowEnabled(remoteFeatureFlags, transactionType) {
+    const flag = remoteFeatureFlags[PAY_POST_QUOTE_FEATURE_FLAG];
+    if (!is(flag, PayPostQuoteFeatureFlagStruct)) {
+        return false;
+    }
+    const directConfig = flag[transactionType];
+    const typeConfig = flag.overrides?.[transactionType] ??
+        (is(directConfig, PayFlowConfigStruct) ? directConfig : undefined);
+    return (typeConfig?.enabled ?? flag.default?.enabled) === true;
+}
+function parseUrl(origin) {
+    try {
+        return new URL(origin);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=feature-flags.js.map

package/dist/utils/feature-flags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-flags.js","sourceRoot":"","sources":["../../src/utils/feature-flags.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  array,\n  boolean,\n  is,\n  optional,\n  record,\n  string,\n  type,\n} from '@metamask/superstruct';\nimport type { Json } from '@metamask/utils';\n\n/**\n * Lists which transaction types each dapp origin may request through\n * `wallet_pay`. A type must also be enabled at the top level (the kill\n * switch).\n */\nexport const WALLET_PAY_FEATURE_FLAG = 'confirmations_pay_rpc';\n\n/**\n * Gates in-wallet MetaMask Pay flows per transaction type. A dapp request that\n * reuses an in-wallet flow is gated by it too.\n */\nexport const PAY_POST_QUOTE_FEATURE_FLAG = 'confirmations_pay_post_quote';\n\n// `localhost` is allowed on any port, so local development servers work\n// without listing every port in the flag.\nconst LOCALHOST_ORIGIN = 'http://localhost';\n\nconst AllowedTypesStruct = type({ allowedTypes: array(string()) });\n\nconst WalletPayFeatureFlagStruct = type({\n  allowedTypes: array(string()),\n  dapps: record(string(), AllowedTypesStruct),\n});\n\nconst PayFlowConfigStruct = type({ enabled: optional(boolean()) });\n\nconst PayPostQuoteFeatureFlagStruct = type({\n  default: optional(PayFlowConfigStruct),\n  overrides: optional(record(string(), PayFlowConfigStruct)),\n});\n\nexport type RemoteFeatureFlags = Record<string, Json>;\n\n/**\n * Whether a dapp may request a transaction type, based on\n * `confirmations_pay_rpc`. Origins match exactly, scheme included, except\n * `http://localhost`, which matches any port. A missing or malformed flag\n * allows nothing.\n *\n * @param remoteFeatureFlags - The remote feature flags.\n * @param origin - The requesting dapp's origin.\n * @param transactionType - The requested transaction type.\n * @returns Whether the request is allowed.\n */\nexport function isWalletPayTypeAllowed(\n  remoteFeatureFlags: RemoteFeatureFlags,\n  origin: string,\n  transactionType: string,\n): boolean {\n  const flag = remoteFeatureFlags[WALLET_PAY_FEATURE_FLAG];\n\n  if (\n    !is(flag, WalletPayFeatureFlagStruct) ||\n    !flag.allowedTypes.includes(transactionType)\n  ) {\n    return false;\n  }\n\n  const url = parseUrl(origin);\n\n  if (!url) {\n    return false;\n  }\n\n  const isLocalhost = url.protocol === 'http:' && url.hostname === 'localhost';\n  const dappConfig =\n    flag.dapps[url.origin] ??\n    (isLocalhost ? flag.dapps[LOCALHOST_ORIGIN] : undefined);\n\n  return dappConfig?.allowedTypes.includes(transactionType) ?? false;\n}\n\n/**\n * Whether the in-wallet flow for a transaction type is enabled by\n * `confirmations_pay_post_quote`. A type-specific entry (under `overrides`, or\n * directly) wins over `default`.\n *\n * @param remoteFeatureFlags - The remote feature flags.\n * @param transactionType - The transaction type.\n * @returns Whether the flow is enabled.\n */\nexport function isPayFlowEnabled(\n  remoteFeatureFlags: RemoteFeatureFlags,\n  transactionType: string,\n): boolean {\n  const flag = remoteFeatureFlags[PAY_POST_QUOTE_FEATURE_FLAG];\n\n  if (!is(flag, PayPostQuoteFeatureFlagStruct)) {\n    return false;\n  }\n\n  const directConfig = (flag as Record<string, unknown>)[transactionType];\n  const typeConfig =\n    flag.overrides?.[transactionType] ??\n    (is(directConfig, PayFlowConfigStruct) ? directConfig : undefined);\n\n  return (typeConfig?.enabled ?? flag.default?.enabled) === true;\n}\n\nfunction parseUrl(origin: string): URL | undefined {\n  try {\n    return new URL(origin);\n  } catch {\n    return undefined;\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,79 @@
 {
   "name": "@metamask-previews/transaction-pay-middleware",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-preview-55fcf3ef7",
+  "description": "Implements the wallet_pay JSON-RPC method, which lets dapps request MetaMask Pay transactions",
+  "keywords": [
+    "Ethereum",
+    "MetaMask"
+  ],
+  "homepage": "https://github.com/MetaMask/core/tree/main/packages/transaction-pay-middleware#readme",
+  "bugs": {
+    "url": "https://github.com/MetaMask/core/issues"
+  },
+  "license": "(MIT OR Apache-2.0)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MetaMask/core.git"
+  },
+  "files": [
+    "dist/"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "build:all": "tsc --build tsconfig.build.json --verbose",
+    "build:clean": "yarn build:only-clean && yarn build",
+    "build:docs": "typedoc",
+    "build:only-clean": "rimraf './dist' './tsconfig.build.tsbuildinfo'",
+    "changelog:update": "../../scripts/update-changelog.sh @metamask/transaction-pay-middleware",
+    "changelog:validate": "../../scripts/validate-changelog.sh @metamask/transaction-pay-middleware",
+    "lint:tsconfigs": "node --import ../../scripts/resolver/register.ts --experimental-transform-types ../../scripts/lint-tsconfigs/lint-tsconfigs.ts",
+    "lint:tsconfigs:fix": "node --import ../../scripts/resolver/register.ts --experimental-transform-types ../../scripts/lint-tsconfigs/lint-tsconfigs.ts --fix",
+    "messenger-action-types:check": "node --import ../../scripts/resolver/register.ts --experimental-transform-types ../../packages/messenger-cli/src/cli.ts --formatter oxfmt --check",
+    "messenger-action-types:generate": "node --import ../../scripts/resolver/register.ts --experimental-transform-types ../../packages/messenger-cli/src/cli.ts --formatter oxfmt --generate",
+    "since-latest-release": "../../scripts/since-latest-release.sh",
+    "test": "NODE_OPTIONS=--experimental-vm-modules jest --reporters=jest-silent-reporter",
+    "test:clean": "NODE_OPTIONS=--experimental-vm-modules jest --clearCache",
+    "test:verbose": "NODE_OPTIONS=--experimental-vm-modules jest --verbose",
+    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch"
+  },
+  "dependencies": {
+    "@metamask/controller-utils": "^13.0.0",
+    "@metamask/messenger": "^3.0.0",
+    "@metamask/network-controller": "^37.1.1",
+    "@metamask/perps-controller": "^21.0.0",
+    "@metamask/remote-feature-flag-controller": "^7.0.0",
+    "@metamask/rpc-errors": "^7.0.3",
+    "@metamask/superstruct": "^3.4.1",
+    "@metamask/transaction-controller": "^72.2.1",
+    "@metamask/utils": "^12.0.0",
+    "bignumber.js": "^9.1.2"
+  },
+  "devDependencies": {
+    "@metamask/auto-changelog": "^6.2.1",
+    "@types/jest": "^30.0.0",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "deepmerge": "^4.3.1",
+    "jest": "^30.5.2",
+    "rimraf": "^6.1.3",
+    "ts-jest": "^29.4.14",
+    "typedoc": "^0.28.20",
+    "typedoc-plugin-missing-exports": "^4.1.4",
+    "typescript": "npm:@typescript/typescript6@^6.0.2"
+  },
+  "engines": {
+    "node": "^22.14.0 || ^24"
+  }
 }