@anywalletkit/protocol-swap2-jupiter 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 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/README.md

@@ -1,3 +1,95 @@
-# Temporary Holding Version
+# @anywalletkit/protocol-swap2-jupiter
 
-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.
+[Jupiter](https://developers.jup.ag/docs/swap) same-chain Solana swaps as a
+swap2 provider. It uses Swap API V2's **Router** path (`GET /swap/v2/build`):
+Metis on-chain routing, raw instructions, and no Jupiter swap fee. Quotes work
+without an API key at 0.5 requests per second. Pass `apiKey` for your plan's
+limit; the key is per organisation, so ship it on a server, not inside an app.
+
+```ts
+import {jupiterProvider} from "@anywalletkit/protocol-swap2-jupiter/provider";
+import {RouterSwap2Protocol} from "@anywalletkit/protocol-swap2-router/swap2/router";
+
+const swap2 = new RouterSwap2Protocol(solanaAccount, {
+  fromChain: "solana:mainnet",
+  providers: [jupiterProvider({rpcUrls: ["https://your-solana-rpc"]})],
+});
+const res = await swap2.swap2({fromToken: "SOL", toToken: "USDC", toChain: "solana:mainnet", fromTokenAmount: 100_000_000n, slippageBps: 50});
+```
+
+The account must expose swap2's `sendSerializedTransaction` hook
+(`@anywalletkit/wallet-solana`'s `sendSerialized` behind it): it simulates the
+transaction, proves the balance changes against the quote, signs, and
+broadcasts through its own RPC. Jupiter never lands the transaction.
+
+## What is checked before the quote is handed out
+
+`/build` returns instructions; the transaction is assembled here, and only
+after all of the following hold:
+
+- the instructions call only Jupiter v6 (`JUP6Lkb…`) and the plumbing a swap
+  needs: compute budget, System, SPL Token / Token-2022, Associated Token;
+- the taker is the only signer, and there is no tip instruction;
+- the swap instruction is `route_v2` or `shared_accounts_route_v2` (ExactIn),
+  and its own arguments — the ones the program enforces on-chain — say exactly
+  our input amount, the quoted output in the answer, our slippage, and 0 bps
+  platform fee and positive-slippage share;
+- the answer names the mints and the amount we asked for, as a v0 transaction.
+
+The minimum output (`minDestAmount`) is computed from the instruction:
+`quoted × (10 000 − slippage) / 10 000`, rounded down. A `minAmountOut` above
+it refuses the quote.
+
+## Compute budget
+
+Jupiter's compute-budget instructions are replaced by ours:
+
+- **price**: Jupiter's suggestion, capped by `maxComputeUnitPrice`
+  (default 2 000 000 µlamports/CU);
+- **limit**: 1.2× the units a simulation used when `rpcUrls` is set, otherwise
+  1 400 000. A failing simulation refuses the quote with the program's error.
+
+The quoted network fee is 5 000 lamports plus `price × limit`.
+
+## Limits
+
+- Solana → Solana only, and the recipient must be the signing wallet: Jupiter
+  pays the taker's own token account.
+- If the wallet already holds wrapped SOL, the route unwraps all of it into
+  SOL. wallet-solana's guard counts the wallet's own wSOL as its SOL, so this
+  is neutral and never counted as swap output.
+- Quotes live 30 seconds: the blockhash in a `/build` answer expires in about a
+  minute.
+- Status comes from `getSignatureStatuses` on `rpcUrls`; without them it stays
+  `pending`, and the wallet's own receipt is the source of truth.
+
+## Config
+
+```ts
+jupiterProvider({
+  enabled: true,                        // default
+  apiUrl: "https://api.jup.ag/swap/v2", // default
+  apiKey: undefined,                    // Developer Platform key → x-api-key
+  rpcUrls: [],                          // compute-unit simulation + status
+  maxComputeUnitPrice: 2_000_000n,      // µlamports per CU
+  computeUnitPricePercentile: undefined,// "medium" | "high" | "veryHigh" | bps
+  defaultSlippageBps: 50,               // when the caller names none
+});
+```
+
+## Activity
+
+`describeActivity` recognizes a Solana transaction whose first non-plumbing
+program is Jupiter v6 and where the wallet both gave and received an asset:
+"Swapped A → B", counterparty Jupiter. A route that only reaches Jupiter
+through another program, or a leg that only sends (a bridge's pre-swap), is
+left to other modules. The fixtures are real mainnet swaps.
+
+## Tests
+
+- `tests/codec.test.ts` and `tests/provider.test.ts` replay recorded `/build`
+  answers (`fixtures/build-2026-10-23.json`), including tampered ones.
+- `tests/conformance.test.ts` runs the SDK's module, activity and behaviour
+  suites.
+- `JUPITER_LIVE=1 pnpm test`: a live `/build` answer through wallet-solana's
+  guard on mainnet for a funded public wallet (simulation only, nothing signed).

package/dist/activity.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/activity.ts
+var activity_exports = {};
+__export(activity_exports, {
+  JUPITER_MODULE: () => JUPITER_MODULE,
+  describeJupiterActivity: () => describeJupiterActivity
+});
+module.exports = __toCommonJS(activity_exports);
+var import_activity = require("@anywalletkit/protocol-swap2-core/activity");
+
+// src/config.ts
+var import_swap2_assets = require("@anywalletkit/swap2-assets");
+var JUPITER_PROGRAM = "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4";
+var SYSTEM_PROGRAM = "11111111111111111111111111111111";
+var WSOL_MINT = "So11111111111111111111111111111111111111112";
+var SOLANA_CAIP2 = "solana:mainnet";
+var SOLANA_CHAINS = /* @__PURE__ */ new Set([SOLANA_CAIP2, "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"]);
+var NATIVE = /* @__PURE__ */ new Set(["", "native", "sol", SYSTEM_PROGRAM, WSOL_MINT.toLowerCase(), "0x0000000000000000000000000000000000000000"]);
+
+// src/activity.ts
+var JUPITER_MODULE = "@anywalletkit/protocol-swap2-jupiter";
+function describeJupiterActivity(tx, ctx) {
+  if (!SOLANA_CHAINS.has(tx.chain) || tx.call?.to !== JUPITER_PROGRAM) return null;
+  const item = (0, import_activity.describeSwapLike)(tx, ctx, { protocol: JUPITER_MODULE, subtitle: "Jupiter", kind: "swap", counterparty: JUPITER_PROGRAM });
+  if (item && tx.status !== "failed" && (item.assetsIn.length === 0 || item.assetsOut.length === 0)) return null;
+  return item;
+}
+//# sourceMappingURL=activity.cjs.map

package/dist/activity.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/activity.ts","../src/config.ts"],"sourcesContent":["/**\n * Activity recognition for Jupiter swaps. Solana history (wallet-solana) names the first non-plumbing program a\n * transaction runs as `call.to`: a swap sent to Jupiter v6 directly (this module's /build transactions, jup.ag) has it\n * there. A route that only passes through Jupiter inside another program (an aggregator or bridge CPI-ing into it) names\n * that program instead and is left to its module. The owner must both give and receive an asset: a leg that only sends\n * (a bridge's source leg with a Jupiter pre-swap) is not called a swap.\n */\nimport type {ActivityItem, ChainTx, DescribeActivityContext} from \"@anywalletkit/core\";\nimport {describeSwapLike} from \"@anywalletkit/protocol-swap2-core/activity\";\nimport {JUPITER_PROGRAM, SOLANA_CHAINS} from \"./config.js\";\n\nexport const JUPITER_MODULE = \"@anywalletkit/protocol-swap2-jupiter\";\n\nexport function describeJupiterActivity(tx: ChainTx, ctx: DescribeActivityContext): ActivityItem | null {\n  if (!SOLANA_CHAINS.has(tx.chain) || tx.call?.to !== JUPITER_PROGRAM) return null;\n  const item = describeSwapLike(tx, ctx, {protocol: JUPITER_MODULE, subtitle: \"Jupiter\", kind: \"swap\", counterparty: JUPITER_PROGRAM});\n  if (item && tx.status !== \"failed\" && (item.assetsIn.length === 0 || item.assetsOut.length === 0)) return null;\n  return item;\n}\n","/**\n * Jupiter (Solana) — Swap API V2, Router path (`GET /swap/v2/build`): Metis on-chain routing, raw instructions, no\n * Jupiter swap fee. The transaction is assembled here and executed by the account's serialized-transaction guard\n * (simulation + balance proof), then broadcast through the wallet's own RPC — Jupiter never lands it for us.\n * Same-chain only: Solana → Solana.\n */\nimport {ccAsset, ccAssetByToken} from \"@anywalletkit/swap2-assets\";\n\nexport const JUPITER_API_DEFAULT = \"https://api.jup.ag/swap/v2\";\n\n/** Jupiter Aggregator v6 — the only program a swap instruction may target. */\nexport const JUPITER_PROGRAM = \"JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4\";\nexport const COMPUTE_BUDGET_PROGRAM = \"ComputeBudget111111111111111111111111111111\";\nexport const SYSTEM_PROGRAM = \"11111111111111111111111111111111\";\nexport const TOKEN_PROGRAM = \"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA\";\nexport const TOKEN_2022_PROGRAM = \"TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb\";\nexport const ATA_PROGRAM = \"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL\";\n/** Wrapped SOL: Jupiter's name for native SOL (it wraps / unwraps around the swap). */\nexport const WSOL_MINT = \"So11111111111111111111111111111111111111112\";\n\n/** Programs the /build instructions may invoke; anything else refuses the quote before the wallet sees it. */\nexport const JUPITER_TX_PROGRAMS: ReadonlySet<string> = new Set([JUPITER_PROGRAM, COMPUTE_BUDGET_PROGRAM, SYSTEM_PROGRAM, TOKEN_PROGRAM, TOKEN_2022_PROGRAM, ATA_PROGRAM]);\n\n/** swap2 names Solana `solana:mainnet`; wallet history uses the genesis-hash form. */\nexport const SOLANA_CAIP2 = \"solana:mainnet\";\nexport const SOLANA_CHAINS: ReadonlySet<string> = new Set([SOLANA_CAIP2, \"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp\"]);\n\nconst BASE58 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;\nconst NATIVE = new Set([\"\", \"native\", \"sol\", SYSTEM_PROGRAM, WSOL_MINT.toLowerCase(), \"0x0000000000000000000000000000000000000000\"]);\n\n/** A swap2 token ref on Solana (catalog symbol, mint, or a native marker) → the mint Jupiter quotes; null when unknown. */\nexport function jupiterMint(token: string): string | null {\n  if (NATIVE.has(token.toLowerCase()) || /^0x0+$/.test(token)) return WSOL_MINT;\n  const bySymbol = ccAsset(SOLANA_CAIP2, token);\n  if (bySymbol) return bySymbol.contract ?? WSOL_MINT;\n  const byMint = BASE58.test(token) ? ccAssetByToken(SOLANA_CAIP2, token) : undefined;\n  if (byMint) return byMint.contract ?? WSOL_MINT;\n  return BASE58.test(token) ? token : null;\n}\n\nexport const jupiter = {\n  supportsChain: (chain: string) => chain === SOLANA_CAIP2,\n  supports: (from: string, to: string) => from === SOLANA_CAIP2 && to === SOLANA_CAIP2,\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,sBAA+B;;;ACF/B,0BAAsC;AAK/B,IAAM,kBAAkB;AAExB,IAAM,iBAAiB;AAKvB,IAAM,YAAY;AAMlB,IAAM,eAAe;AACrB,IAAM,gBAAqC,oBAAI,IAAI,CAAC,cAAc,yCAAyC,CAAC;AAGnH,IAAM,SAAS,oBAAI,IAAI,CAAC,IAAI,UAAU,OAAO,gBAAgB,UAAU,YAAY,GAAG,4CAA4C,CAAC;;;ADjB5H,IAAM,iBAAiB;AAEvB,SAAS,wBAAwB,IAAa,KAAmD;AACtG,MAAI,CAAC,cAAc,IAAI,GAAG,KAAK,KAAK,GAAG,MAAM,OAAO,gBAAiB,QAAO;AAC5E,QAAM,WAAO,kCAAiB,IAAI,KAAK,EAAC,UAAU,gBAAgB,UAAU,WAAW,MAAM,QAAQ,cAAc,gBAAe,CAAC;AACnI,MAAI,QAAQ,GAAG,WAAW,aAAa,KAAK,SAAS,WAAW,KAAK,KAAK,UAAU,WAAW,GAAI,QAAO;AAC1G,SAAO;AACT;","names":[]}

package/dist/activity.d.cts

@@ -0,0 +1,14 @@
+import { ChainTx, DescribeActivityContext, ActivityItem } from '@anywalletkit/core';
+
+/**
+ * Activity recognition for Jupiter swaps. Solana history (wallet-solana) names the first non-plumbing program a
+ * transaction runs as `call.to`: a swap sent to Jupiter v6 directly (this module's /build transactions, jup.ag) has it
+ * there. A route that only passes through Jupiter inside another program (an aggregator or bridge CPI-ing into it) names
+ * that program instead and is left to its module. The owner must both give and receive an asset: a leg that only sends
+ * (a bridge's source leg with a Jupiter pre-swap) is not called a swap.
+ */
+
+declare const JUPITER_MODULE = "@anywalletkit/protocol-swap2-jupiter";
+declare function describeJupiterActivity(tx: ChainTx, ctx: DescribeActivityContext): ActivityItem | null;
+
+export { JUPITER_MODULE, describeJupiterActivity };

package/dist/activity.d.ts

@@ -0,0 +1,14 @@
+import { ChainTx, DescribeActivityContext, ActivityItem } from '@anywalletkit/core';
+
+/**
+ * Activity recognition for Jupiter swaps. Solana history (wallet-solana) names the first non-plumbing program a
+ * transaction runs as `call.to`: a swap sent to Jupiter v6 directly (this module's /build transactions, jup.ag) has it
+ * there. A route that only passes through Jupiter inside another program (an aggregator or bridge CPI-ing into it) names
+ * that program instead and is left to its module. The owner must both give and receive an asset: a leg that only sends
+ * (a bridge's source leg with a Jupiter pre-swap) is not called a swap.
+ */
+
+declare const JUPITER_MODULE = "@anywalletkit/protocol-swap2-jupiter";
+declare function describeJupiterActivity(tx: ChainTx, ctx: DescribeActivityContext): ActivityItem | null;
+
+export { JUPITER_MODULE, describeJupiterActivity };

package/dist/activity.js

@@ -0,0 +1,10 @@
+import {
+  JUPITER_MODULE,
+  describeJupiterActivity
+} from "./chunk-H4SP5E76.js";
+import "./chunk-OVLAYYGP.js";
+export {
+  JUPITER_MODULE,
+  describeJupiterActivity
+};
+//# sourceMappingURL=activity.js.map

package/dist/activity.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-5JXNDQHW.js

@@ -0,0 +1,56 @@
+// src/codec.ts
+import { base64 } from "@scure/base";
+var ROUTE_V2 = "bb64facc31c4af14";
+var SHARED_ACCOUNTS_ROUTE_V2 = "d19853937cfed8e9";
+var hex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+var u64 = (d, o) => new DataView(d.buffer, d.byteOffset + o, 8).getBigUint64(0, true);
+var u16 = (d, o) => new DataView(d.buffer, d.byteOffset + o, 2).getUint16(0, true);
+var fromBase64 = (s) => base64.decode(s);
+var toBase64 = (b) => base64.encode(b);
+function decodeSwapArgs(data) {
+  const disc = hex(data.subarray(0, 8));
+  const at = disc === ROUTE_V2 ? 8 : disc === SHARED_ACCOUNTS_ROUTE_V2 ? 9 : -1;
+  if (at < 0) throw new Error(`unsupported Jupiter instruction ${disc}`);
+  if (data.length < at + 22 + 4) throw new Error("Jupiter swap instruction is truncated");
+  return {
+    kind: at === 8 ? "route_v2" : "shared_accounts_route_v2",
+    inAmount: u64(data, at),
+    quotedOutAmount: u64(data, at + 8),
+    slippageBps: u16(data, at + 16),
+    platformFeeBps: u16(data, at + 18),
+    positiveSlippageBps: u16(data, at + 20)
+  };
+}
+function minOutOf(quotedOut, slippageBps) {
+  return quotedOut * BigInt(1e4 - slippageBps) / 10000n;
+}
+function decodeComputeBudget(data) {
+  if (data[0] === 2 && data.length === 5) return { limit: new DataView(data.buffer, data.byteOffset + 1, 4).getUint32(0, true) };
+  if (data[0] === 3 && data.length === 9) return { price: u64(data, 1) };
+  throw new Error(`unexpected compute-budget instruction ${data[0]}`);
+}
+function setComputeUnitLimit(units) {
+  const d = new Uint8Array(5);
+  d[0] = 2;
+  new DataView(d.buffer).setUint32(1, units, true);
+  return d;
+}
+function setComputeUnitPrice(microLamports) {
+  const d = new Uint8Array(9);
+  d[0] = 3;
+  new DataView(d.buffer).setBigUint64(1, microLamports, true);
+  return d;
+}
+
+export {
+  ROUTE_V2,
+  SHARED_ACCOUNTS_ROUTE_V2,
+  fromBase64,
+  toBase64,
+  decodeSwapArgs,
+  minOutOf,
+  decodeComputeBudget,
+  setComputeUnitLimit,
+  setComputeUnitPrice
+};
+//# sourceMappingURL=chunk-5JXNDQHW.js.map

package/dist/chunk-5JXNDQHW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/codec.ts"],"sourcesContent":["/**\n * Byte-level checks of what `/build` returns. The swap instruction is Jupiter v6's Anchor `route_v2` /\n * `shared_accounts_route_v2` (ExactIn): its arguments carry the input amount, the quoted output, the slippage and the\n * platform-fee split that the program enforces on-chain — so they are read back here and must equal the request\n * before the transaction is assembled. Discriminators = sha256(\"global:<name>\")[0..8] (verified 2026-10-23 against\n * live /build answers).\n */\nimport {base64} from \"@scure/base\";\n\n/** `route_v2(in_amount u64, quoted_out_amount u64, slippage_bps u16, platform_fee_bps u16, positive_slippage_bps u16, route_plan Vec)` */\nexport const ROUTE_V2 = \"bb64facc31c4af14\";\n/** `shared_accounts_route_v2(id u8, …the same arguments…)` */\nexport const SHARED_ACCOUNTS_ROUTE_V2 = \"d19853937cfed8e9\";\n\nexport interface JupiterSwapArgs {\n  kind: \"route_v2\" | \"shared_accounts_route_v2\";\n  inAmount: bigint;\n  quotedOutAmount: bigint;\n  slippageBps: number;\n  platformFeeBps: number;\n  positiveSlippageBps: number;\n}\n\nconst hex = (b: Uint8Array) => Array.from(b, (x) => x.toString(16).padStart(2, \"0\")).join(\"\");\nconst u64 = (d: Uint8Array, o: number) => new DataView(d.buffer, d.byteOffset + o, 8).getBigUint64(0, true);\nconst u16 = (d: Uint8Array, o: number) => new DataView(d.buffer, d.byteOffset + o, 2).getUint16(0, true);\n\nexport const fromBase64 = (s: string): Uint8Array => base64.decode(s);\nexport const toBase64 = (b: Uint8Array): string => base64.encode(b);\n\n/** Decode the swap instruction's fixed arguments; throws for any other instruction (ExactOut, legacy v1 routes…). */\nexport function decodeSwapArgs(data: Uint8Array): JupiterSwapArgs {\n  const disc = hex(data.subarray(0, 8));\n  const at = disc === ROUTE_V2 ? 8 : disc === SHARED_ACCOUNTS_ROUTE_V2 ? 9 : -1;\n  if (at < 0) throw new Error(`unsupported Jupiter instruction ${disc}`);\n  if (data.length < at + 22 + 4) throw new Error(\"Jupiter swap instruction is truncated\");\n  return {\n    kind: at === 8 ? \"route_v2\" : \"shared_accounts_route_v2\",\n    inAmount: u64(data, at),\n    quotedOutAmount: u64(data, at + 8),\n    slippageBps: u16(data, at + 16),\n    platformFeeBps: u16(data, at + 18),\n    positiveSlippageBps: u16(data, at + 20),\n  };\n}\n\n/** The worst output the program accepts: quoted · (10 000 − slippage) / 10 000, rounded down (never above the on-chain check). */\nexport function minOutOf(quotedOut: bigint, slippageBps: number): bigint {\n  return (quotedOut * BigInt(10_000 - slippageBps)) / 10_000n;\n}\n\n/** ComputeBudget instructions: 2 = SetComputeUnitLimit(u32), 3 = SetComputeUnitPrice(u64 micro-lamports). */\nexport function decodeComputeBudget(data: Uint8Array): {limit?: number; price?: bigint} {\n  if (data[0] === 2 && data.length === 5) return {limit: new DataView(data.buffer, data.byteOffset + 1, 4).getUint32(0, true)};\n  if (data[0] === 3 && data.length === 9) return {price: u64(data, 1)};\n  throw new Error(`unexpected compute-budget instruction ${data[0]}`);\n}\n\nexport function setComputeUnitLimit(units: number): Uint8Array {\n  const d = new Uint8Array(5);\n  d[0] = 2;\n  new DataView(d.buffer).setUint32(1, units, true);\n  return d;\n}\n\nexport function setComputeUnitPrice(microLamports: bigint): Uint8Array {\n  const d = new Uint8Array(9);\n  d[0] = 3;\n  new DataView(d.buffer).setBigUint64(1, microLamports, true);\n  return d;\n}\n"],"mappings":";AAOA,SAAQ,cAAa;AAGd,IAAM,WAAW;AAEjB,IAAM,2BAA2B;AAWxC,IAAM,MAAM,CAAC,MAAkB,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AAC5F,IAAM,MAAM,CAAC,GAAe,MAAc,IAAI,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,CAAC,EAAE,aAAa,GAAG,IAAI;AAC1G,IAAM,MAAM,CAAC,GAAe,MAAc,IAAI,SAAS,EAAE,QAAQ,EAAE,aAAa,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI;AAEhG,IAAM,aAAa,CAAC,MAA0B,OAAO,OAAO,CAAC;AAC7D,IAAM,WAAW,CAAC,MAA0B,OAAO,OAAO,CAAC;AAG3D,SAAS,eAAe,MAAmC;AAChE,QAAM,OAAO,IAAI,KAAK,SAAS,GAAG,CAAC,CAAC;AACpC,QAAM,KAAK,SAAS,WAAW,IAAI,SAAS,2BAA2B,IAAI;AAC3E,MAAI,KAAK,EAAG,OAAM,IAAI,MAAM,mCAAmC,IAAI,EAAE;AACrE,MAAI,KAAK,SAAS,KAAK,KAAK,EAAG,OAAM,IAAI,MAAM,uCAAuC;AACtF,SAAO;AAAA,IACL,MAAM,OAAO,IAAI,aAAa;AAAA,IAC9B,UAAU,IAAI,MAAM,EAAE;AAAA,IACtB,iBAAiB,IAAI,MAAM,KAAK,CAAC;AAAA,IACjC,aAAa,IAAI,MAAM,KAAK,EAAE;AAAA,IAC9B,gBAAgB,IAAI,MAAM,KAAK,EAAE;AAAA,IACjC,qBAAqB,IAAI,MAAM,KAAK,EAAE;AAAA,EACxC;AACF;AAGO,SAAS,SAAS,WAAmB,aAA6B;AACvE,SAAQ,YAAY,OAAO,MAAS,WAAW,IAAK;AACtD;AAGO,SAAS,oBAAoB,MAAoD;AACtF,MAAI,KAAK,CAAC,MAAM,KAAK,KAAK,WAAW,EAAG,QAAO,EAAC,OAAO,IAAI,SAAS,KAAK,QAAQ,KAAK,aAAa,GAAG,CAAC,EAAE,UAAU,GAAG,IAAI,EAAC;AAC3H,MAAI,KAAK,CAAC,MAAM,KAAK,KAAK,WAAW,EAAG,QAAO,EAAC,OAAO,IAAI,MAAM,CAAC,EAAC;AACnE,QAAM,IAAI,MAAM,yCAAyC,KAAK,CAAC,CAAC,EAAE;AACpE;AAEO,SAAS,oBAAoB,OAA2B;AAC7D,QAAM,IAAI,IAAI,WAAW,CAAC;AAC1B,IAAE,CAAC,IAAI;AACP,MAAI,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,OAAO,IAAI;AAC/C,SAAO;AACT;AAEO,SAAS,oBAAoB,eAAmC;AACrE,QAAM,IAAI,IAAI,WAAW,CAAC;AAC1B,IAAE,CAAC,IAAI;AACP,MAAI,SAAS,EAAE,MAAM,EAAE,aAAa,GAAG,eAAe,IAAI;AAC1D,SAAO;AACT;","names":[]}

package/dist/chunk-5L7BPEQL.js

@@ -0,0 +1,51 @@
+import {
+  fromBase64,
+  setComputeUnitLimit,
+  setComputeUnitPrice
+} from "./chunk-5JXNDQHW.js";
+import {
+  COMPUTE_BUDGET_PROGRAM
+} from "./chunk-OVLAYYGP.js";
+
+// src/transaction.ts
+import {
+  AccountRole,
+  address,
+  appendTransactionMessageInstructions,
+  compileTransaction,
+  compressTransactionMessageUsingAddressLookupTables,
+  createTransactionMessage,
+  getBase58Decoder,
+  getBase64EncodedWireTransaction,
+  pipe,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash
+} from "@solana/kit";
+var role = (a) => a.isSigner ? a.isWritable ? AccountRole.WRITABLE_SIGNER : AccountRole.READONLY_SIGNER : a.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
+var toInstruction = (ix) => ({
+  programAddress: address(ix.programId),
+  accounts: ix.accounts.map((a) => ({ address: address(a.pubkey), role: role(a) })),
+  data: fromBase64(ix.data)
+});
+function assembleTransaction(input) {
+  const budget = [
+    { programAddress: address(COMPUTE_BUDGET_PROGRAM), data: setComputeUnitLimit(input.computeUnitLimit) },
+    { programAddress: address(COMPUTE_BUDGET_PROGRAM), data: setComputeUnitPrice(input.computeUnitPrice) }
+  ];
+  const blockhash = typeof input.blockhash === "string" ? input.blockhash : getBase58Decoder().decode(input.blockhash);
+  const tables = {};
+  for (const [table, list] of Object.entries(input.addressesByLookupTableAddress ?? {})) tables[address(table)] = list.map((a) => address(a));
+  const message = pipe(
+    createTransactionMessage({ version: 0 }),
+    (m) => setTransactionMessageFeePayer(address(input.taker), m),
+    (m) => setTransactionMessageLifetimeUsingBlockhash({ blockhash, lastValidBlockHeight: BigInt(input.lastValidBlockHeight) }, m),
+    (m) => appendTransactionMessageInstructions([...budget, ...input.instructions.map(toInstruction)], m),
+    (m) => Object.keys(tables).length ? compressTransactionMessageUsingAddressLookupTables(m, tables) : m
+  );
+  return getBase64EncodedWireTransaction(compileTransaction(message));
+}
+
+export {
+  assembleTransaction
+};
+//# sourceMappingURL=chunk-5L7BPEQL.js.map

package/dist/chunk-5L7BPEQL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/transaction.ts"],"sourcesContent":["/**\n * Assemble the v0 transaction from `/build` instructions: our compute budget (limit + capped price), Jupiter's setup,\n * swap, cleanup and other instructions, compressed with the lookup tables the response names, fee payer = the taker,\n * lifetime = the blockhash Jupiter fetched. Signatures stay empty; the account signs after its own guard.\n */\nimport {\n  AccountRole, address, appendTransactionMessageInstructions, compileTransaction, compressTransactionMessageUsingAddressLookupTables,\n  createTransactionMessage, getBase58Decoder, getBase64EncodedWireTransaction, pipe, setTransactionMessageFeePayer,\n  setTransactionMessageLifetimeUsingBlockhash, type Address, type Blockhash, type Instruction,\n} from \"@solana/kit\";\nimport {COMPUTE_BUDGET_PROGRAM} from \"./config.js\";\nimport {fromBase64, setComputeUnitLimit, setComputeUnitPrice} from \"./codec.js\";\n\nexport interface JupiterInstruction {\n  programId: string;\n  accounts: {pubkey: string; isSigner: boolean; isWritable: boolean}[];\n  data: string;\n}\n\nexport interface AssembleInput {\n  taker: string;\n  /** setup → swap → cleanup → other, in that order; compute-budget instructions are ours and come first. */\n  instructions: JupiterInstruction[];\n  computeUnitLimit: number;\n  computeUnitPrice: bigint;\n  blockhash: Uint8Array | string;\n  lastValidBlockHeight: number | bigint;\n  addressesByLookupTableAddress: Record<string, string[]> | null | undefined;\n}\n\nconst role = (a: {isSigner: boolean; isWritable: boolean}): AccountRole =>\n  a.isSigner ? (a.isWritable ? AccountRole.WRITABLE_SIGNER : AccountRole.READONLY_SIGNER) : a.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;\n\nconst toInstruction = (ix: JupiterInstruction): Instruction => ({\n  programAddress: address(ix.programId),\n  accounts: ix.accounts.map((a) => ({address: address(a.pubkey), role: role(a)})),\n  data: fromBase64(ix.data),\n});\n\n/** The unsigned transaction as base64 wire bytes (what `TxRequest.serializedTx` carries). */\nexport function assembleTransaction(input: AssembleInput): string {\n  const budget: Instruction[] = [\n    {programAddress: address(COMPUTE_BUDGET_PROGRAM), data: setComputeUnitLimit(input.computeUnitLimit)},\n    {programAddress: address(COMPUTE_BUDGET_PROGRAM), data: setComputeUnitPrice(input.computeUnitPrice)},\n  ];\n  const blockhash = (typeof input.blockhash === \"string\" ? input.blockhash : getBase58Decoder().decode(input.blockhash)) as Blockhash;\n  const tables: Record<Address, Address[]> = {};\n  for (const [table, list] of Object.entries(input.addressesByLookupTableAddress ?? {})) tables[address(table)] = list.map((a) => address(a));\n  const message = pipe(\n    createTransactionMessage({version: 0}),\n    (m) => setTransactionMessageFeePayer(address(input.taker), m),\n    (m) => setTransactionMessageLifetimeUsingBlockhash({blockhash, lastValidBlockHeight: BigInt(input.lastValidBlockHeight)}, m),\n    (m) => appendTransactionMessageInstructions([...budget, ...input.instructions.map(toInstruction)], m),\n    (m) => (Object.keys(tables).length ? compressTransactionMessageUsingAddressLookupTables(m, tables) : m),\n  );\n  return getBase64EncodedWireTransaction(compileTransaction(message));\n}\n"],"mappings":";;;;;;;;;;AAKA;AAAA,EACE;AAAA,EAAa;AAAA,EAAS;AAAA,EAAsC;AAAA,EAAoB;AAAA,EAChF;AAAA,EAA0B;AAAA,EAAkB;AAAA,EAAiC;AAAA,EAAM;AAAA,EACnF;AAAA,OACK;AAqBP,IAAM,OAAO,CAAC,MACZ,EAAE,WAAY,EAAE,aAAa,YAAY,kBAAkB,YAAY,kBAAmB,EAAE,aAAa,YAAY,WAAW,YAAY;AAE9I,IAAM,gBAAgB,CAAC,QAAyC;AAAA,EAC9D,gBAAgB,QAAQ,GAAG,SAAS;AAAA,EACpC,UAAU,GAAG,SAAS,IAAI,CAAC,OAAO,EAAC,SAAS,QAAQ,EAAE,MAAM,GAAG,MAAM,KAAK,CAAC,EAAC,EAAE;AAAA,EAC9E,MAAM,WAAW,GAAG,IAAI;AAC1B;AAGO,SAAS,oBAAoB,OAA8B;AAChE,QAAM,SAAwB;AAAA,IAC5B,EAAC,gBAAgB,QAAQ,sBAAsB,GAAG,MAAM,oBAAoB,MAAM,gBAAgB,EAAC;AAAA,IACnG,EAAC,gBAAgB,QAAQ,sBAAsB,GAAG,MAAM,oBAAoB,MAAM,gBAAgB,EAAC;AAAA,EACrG;AACA,QAAM,YAAa,OAAO,MAAM,cAAc,WAAW,MAAM,YAAY,iBAAiB,EAAE,OAAO,MAAM,SAAS;AACpH,QAAM,SAAqC,CAAC;AAC5C,aAAW,CAAC,OAAO,IAAI,KAAK,OAAO,QAAQ,MAAM,iCAAiC,CAAC,CAAC,EAAG,QAAO,QAAQ,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,MAAM,QAAQ,CAAC,CAAC;AAC1I,QAAM,UAAU;AAAA,IACd,yBAAyB,EAAC,SAAS,EAAC,CAAC;AAAA,IACrC,CAAC,MAAM,8BAA8B,QAAQ,MAAM,KAAK,GAAG,CAAC;AAAA,IAC5D,CAAC,MAAM,4CAA4C,EAAC,WAAW,sBAAsB,OAAO,MAAM,oBAAoB,EAAC,GAAG,CAAC;AAAA,IAC3H,CAAC,MAAM,qCAAqC,CAAC,GAAG,QAAQ,GAAG,MAAM,aAAa,IAAI,aAAa,CAAC,GAAG,CAAC;AAAA,IACpG,CAAC,MAAO,OAAO,KAAK,MAAM,EAAE,SAAS,mDAAmD,GAAG,MAAM,IAAI;AAAA,EACvG;AACA,SAAO,gCAAgC,mBAAmB,OAAO,CAAC;AACpE;","names":[]}

package/dist/chunk-H4SP5E76.js

@@ -0,0 +1,20 @@
+import {
+  JUPITER_PROGRAM,
+  SOLANA_CHAINS
+} from "./chunk-OVLAYYGP.js";
+
+// src/activity.ts
+import { describeSwapLike } from "@anywalletkit/protocol-swap2-core/activity";
+var JUPITER_MODULE = "@anywalletkit/protocol-swap2-jupiter";
+function describeJupiterActivity(tx, ctx) {
+  if (!SOLANA_CHAINS.has(tx.chain) || tx.call?.to !== JUPITER_PROGRAM) return null;
+  const item = describeSwapLike(tx, ctx, { protocol: JUPITER_MODULE, subtitle: "Jupiter", kind: "swap", counterparty: JUPITER_PROGRAM });
+  if (item && tx.status !== "failed" && (item.assetsIn.length === 0 || item.assetsOut.length === 0)) return null;
+  return item;
+}
+
+export {
+  JUPITER_MODULE,
+  describeJupiterActivity
+};
+//# sourceMappingURL=chunk-H4SP5E76.js.map

package/dist/chunk-H4SP5E76.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/activity.ts"],"sourcesContent":["/**\n * Activity recognition for Jupiter swaps. Solana history (wallet-solana) names the first non-plumbing program a\n * transaction runs as `call.to`: a swap sent to Jupiter v6 directly (this module's /build transactions, jup.ag) has it\n * there. A route that only passes through Jupiter inside another program (an aggregator or bridge CPI-ing into it) names\n * that program instead and is left to its module. The owner must both give and receive an asset: a leg that only sends\n * (a bridge's source leg with a Jupiter pre-swap) is not called a swap.\n */\nimport type {ActivityItem, ChainTx, DescribeActivityContext} from \"@anywalletkit/core\";\nimport {describeSwapLike} from \"@anywalletkit/protocol-swap2-core/activity\";\nimport {JUPITER_PROGRAM, SOLANA_CHAINS} from \"./config.js\";\n\nexport const JUPITER_MODULE = \"@anywalletkit/protocol-swap2-jupiter\";\n\nexport function describeJupiterActivity(tx: ChainTx, ctx: DescribeActivityContext): ActivityItem | null {\n  if (!SOLANA_CHAINS.has(tx.chain) || tx.call?.to !== JUPITER_PROGRAM) return null;\n  const item = describeSwapLike(tx, ctx, {protocol: JUPITER_MODULE, subtitle: \"Jupiter\", kind: \"swap\", counterparty: JUPITER_PROGRAM});\n  if (item && tx.status !== \"failed\" && (item.assetsIn.length === 0 || item.assetsOut.length === 0)) return null;\n  return item;\n}\n"],"mappings":";;;;;;AAQA,SAAQ,wBAAuB;AAGxB,IAAM,iBAAiB;AAEvB,SAAS,wBAAwB,IAAa,KAAmD;AACtG,MAAI,CAAC,cAAc,IAAI,GAAG,KAAK,KAAK,GAAG,MAAM,OAAO,gBAAiB,QAAO;AAC5E,QAAM,OAAO,iBAAiB,IAAI,KAAK,EAAC,UAAU,gBAAgB,UAAU,WAAW,MAAM,QAAQ,cAAc,gBAAe,CAAC;AACnI,MAAI,QAAQ,GAAG,WAAW,aAAa,KAAK,SAAS,WAAW,KAAK,KAAK,UAAU,WAAW,GAAI,QAAO;AAC1G,SAAO;AACT;","names":[]}