@moveindustries/near-intents-sdk 0.0.1

package/LICENSE

@@ -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/README.md

@@ -0,0 +1,62 @@
+# near-intents-sdk
+
+A thin TypeScript SDK for moving USDT or USDC from a supported origin chain onto Movement (as USDCx or MOVE) over NEAR Intents. It wraps the official [1Click API](https://docs.near-intents.org/near-intents/integration/distribution-channels/1click-api) client and pins the destination to Movement so callers can't accidentally land elsewhere. It orchestrates the transfer — quote, deposit address, status — and never holds keys.
+
+## Authentication
+
+**A 1Click JWT is optional — the full transfer works without one.** Binding quote → deposit address → status tracking all succeed unauthenticated. Verified on mainnet: a Polygon USDC → Movement USDCx transfer completed end-to-end with no token set.
+
+Pass a JWT only to waive NEAR's protocol fee — without one, NEAR auto-injects its `appFees` and takes a small cut of the swap — and for attributed rate limits instead of anonymous IP-based ones. Obtain one at the [Partners Portal](https://partners.near-intents.org) and pass it to `configure({ jwt })`; the SDK does not mint or refresh tokens.
+
+A JWT is a secret, so in a browser don't ship it to the client. Front 1Click with a server-side proxy that injects the token and point the SDK at it with `configure({ baseUrl: "/api/oneclick" })` (omit `jwt` — the proxy holds it). Without `baseUrl` the SDK calls 1Click directly.
+
+## Usage
+
+```ts
+import { configure, quoteDeposit, prepareDepositTx, submitDeposit, getStatus, isTerminal } from "@moveindustries/near-intents-sdk";
+
+configure({ jwt: process.env.ONE_CLICK_JWT }); // jwt optional; omit configure() entirely to run token-free
+
+// 1. Quote: USDC on Ethereum -> USDCx on Movement. Destination is pinned to Movement.
+const res = await quoteDeposit({
+  originChain: "ethereum",  // "ethereum" | "polygon" | "tron"
+  originAsset: "usdc",      // "usdc" | "usdt"  (tron is usdt-only)
+  destinationAsset: "usdcx", // "usdcx" | "move"
+  amount: "1000000",        // 1.0 USDC, in the origin asset's smallest units
+  recipient: "0xYourMovementAddress",
+  refundTo: "0xYourEthereumAddress",
+  // slippageTolerance: 100, // basis points, defaults to 100 (1%); raise it for `destinationAsset: "move"`
+});
+const { depositAddress, amountOut, deadline } = res.quote;
+
+// 2. (Optional) Build the unsigned deposit transfer; your wallet signs + broadcasts it.
+const depositTx = prepareDepositTx("ethereum", "usdc", res);
+// EVM: { family: "evm", to, value, data }   Tron: { family: "tron", contractAddress, function, parameter }
+
+// 3. (Optional) After broadcasting, hand 1Click the tx hash to speed up deposit detection.
+await submitDeposit(depositAddress!, "0xYourDepositTxHash");
+
+// 4. Read execution status. Poll on your own cadence until isTerminal(status).
+const { status } = await getStatus(depositAddress!);
+// isTerminal(status) is true for "SUCCESS" | "REFUNDED" | "FAILED"
+```
+
+The SDK never signs, broadcasts, or holds keys — step 2 returns an *unsigned* transaction for your wallet.
+
+## Supported routes
+
+Backed by Movement's own solver: origins **Polygon, Ethereum, Tron** (USDC + USDT; Tron is USDT-only) → **USDCx** or **MOVE** on Movement.
+
+## Install
+
+```sh
+npm i @moveindustries/near-intents-sdk
+```
+
+Published manually by a maintainer: bump the version, update [CHANGELOG.md](CHANGELOG.md), then `npm publish` (which builds via `prepublishOnly`). See [CHANGELOG.md](CHANGELOG.md) for changes.
+
+## Tests
+
+- `npm test` — unit only, offline, no secrets.
+- `npm run test:live:noauth` — adds a live dry quote against the real API (no JWT).
+- `npm run test:live:auth` — adds an authenticated quote; requires `ONE_CLICK_JWT` in `.env` (fails if unset).

package/dist/deposit.d.ts

@@ -0,0 +1,17 @@
+import { type QuoteResponse } from "@defuse-protocol/one-click-sdk-typescript";
+import { type OriginKey, type StableKey } from "./registry.js";
+export type EvmDepositTx = {
+    family: "evm";
+    to: string;
+    value: "0x0";
+    data: string;
+};
+export type TronDepositTx = {
+    family: "tron";
+    contractAddress: string;
+    function: "transfer(address,uint256)";
+    parameter: [string, string];
+};
+export type DepositTx = EvmDepositTx | TronDepositTx;
+/** Unsigned transfer of the quote's `amountIn` to its `depositAddress`. The caller signs and broadcasts. */
+export declare function prepareDepositTx(origin: OriginKey, originAsset: StableKey, quote: QuoteResponse): DepositTx;

package/dist/deposit.js

@@ -0,0 +1,15 @@
+import { resolveOrigin, family } from "./registry.js";
+const pad32 = (hex) => hex.replace(/^0x/, "").toLowerCase().padStart(64, "0");
+/** Unsigned transfer of the quote's `amountIn` to its `depositAddress`. The caller signs and broadcasts. */
+export function prepareDepositTx(origin, originAsset, quote) {
+    const { tokenAddress } = resolveOrigin(origin, originAsset);
+    const { depositAddress, amountIn } = quote.quote;
+    if (!depositAddress)
+        throw new Error("quote has no depositAddress (dry run?)");
+    if (!tokenAddress)
+        throw new Error(`no verified L1 token address for ${origin}/${originAsset} (see tasks.md precondition)`);
+    if (family(origin) === "tron") {
+        return { family: "tron", contractAddress: tokenAddress, function: "transfer(address,uint256)", parameter: [depositAddress, amountIn] };
+    }
+    return { family: "evm", to: tokenAddress, value: "0x0", data: "0xa9059cbb" + pad32(depositAddress) + pad32(BigInt(amountIn).toString(16)) };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { configure, quoteDeposit, type QuoteDepositParams } from "./quote.js";
+export { prepareDepositTx, type DepositTx, type EvmDepositTx, type TronDepositTx } from "./deposit.js";
+export { submitDeposit } from "./submit.js";
+export { getStatus, isTerminal } from "./status.js";
+export { listTokens, type SupportedToken } from "./tokens.js";
+export { MOVEMENT, ORIGINS, type OriginKey, type StableKey, type DestKey } from "./registry.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export { configure, quoteDeposit } from "./quote.js";
+export { prepareDepositTx } from "./deposit.js";
+export { submitDeposit } from "./submit.js";
+export { getStatus, isTerminal } from "./status.js";
+export { listTokens } from "./tokens.js";
+export { MOVEMENT, ORIGINS } from "./registry.js";

package/dist/quote.d.ts

@@ -0,0 +1,18 @@
+import { type QuoteResponse } from "@defuse-protocol/one-click-sdk-typescript";
+import { type OriginKey, type StableKey, type DestKey } from "./registry.js";
+export type QuoteDepositParams = {
+    originChain: OriginKey;
+    originAsset: StableKey;
+    destinationAsset: DestKey;
+    amount: string;
+    recipient: string;
+    refundTo: string;
+    slippageTolerance?: number;
+    deadline?: string;
+    dry?: boolean;
+};
+export declare function configure(opts: {
+    jwt?: string | (() => Promise<string>);
+    baseUrl?: string;
+}): void;
+export declare function quoteDeposit(p: QuoteDepositParams): Promise<QuoteResponse>;

package/dist/quote.js

@@ -0,0 +1,32 @@
+import { OneClickService, OpenAPI, QuoteRequest } from "@defuse-protocol/one-click-sdk-typescript";
+import { resolveOrigin, resolveDest, normalizeRecipient } from "./registry.js";
+// baseUrl points the SDK at a server-side proxy that injects the JWT, so the token
+// never ships to the browser; omit it to call 1Click directly.
+export function configure(opts) {
+    OpenAPI.TOKEN = opts.jwt;
+    if (opts.baseUrl)
+        OpenAPI.BASE = opts.baseUrl;
+}
+export async function quoteDeposit(p) {
+    const origin = resolveOrigin(p.originChain, p.originAsset);
+    const dest = resolveDest(p.destinationAsset);
+    if (!/^[0-9]+$/.test(p.amount) || BigInt(p.amount) <= 0n)
+        throw new Error(`amount must be a positive integer string: ${p.amount}`);
+    const deadline = p.deadline ?? new Date(Date.now() + 600_000).toISOString();
+    if (Date.parse(deadline) <= Date.now())
+        throw new Error(`deadline is in the past: ${deadline}`);
+    return OneClickService.getQuote({
+        dry: p.dry ?? false,
+        swapType: QuoteRequest.swapType.EXACT_INPUT,
+        slippageTolerance: p.slippageTolerance ?? 100,
+        originAsset: origin.assetId,
+        destinationAsset: dest.assetId,
+        amount: p.amount,
+        depositType: QuoteRequest.depositType.ORIGIN_CHAIN,
+        recipient: normalizeRecipient(p.recipient),
+        recipientType: QuoteRequest.recipientType.DESTINATION_CHAIN,
+        refundTo: p.refundTo,
+        refundType: QuoteRequest.refundType.ORIGIN_CHAIN,
+        deadline,
+    });
+}

package/dist/registry.d.ts

@@ -0,0 +1,55 @@
+export type AssetEntry = {
+    assetId: string;
+    decimals: number;
+    tokenAddress?: string;
+};
+export type OriginKey = keyof typeof ORIGINS;
+export type StableKey = "usdc" | "usdt";
+export type DestKey = keyof typeof MOVEMENT;
+export declare const MOVEMENT: {
+    readonly usdcx: {
+        readonly assetId: "nep141:movement-6f9a70ef4605e7d9174f1abf8d8d3c15012f48f3.omft.near";
+        readonly decimals: 6;
+    };
+    readonly move: {
+        readonly assetId: "nep141:movement.omft.near";
+        readonly decimals: 8;
+    };
+};
+export declare const ORIGINS: {
+    readonly ethereum: {
+        readonly usdc: {
+            readonly assetId: "nep141:eth-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.omft.near";
+            readonly decimals: 6;
+            readonly tokenAddress: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
+        };
+        readonly usdt: {
+            readonly assetId: "nep141:eth-0xdac17f958d2ee523a2206206994597c13d831ec7.omft.near";
+            readonly decimals: 6;
+            readonly tokenAddress: "0xdac17f958d2ee523a2206206994597c13d831ec7";
+        };
+    };
+    readonly polygon: {
+        readonly usdc: {
+            readonly assetId: "nep245:v2_1.omni.hot.tg:137_qiStmoQJDQPTebaPjgx5VBxZv6L";
+            readonly decimals: 6;
+            readonly tokenAddress: "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359";
+        };
+        readonly usdt: {
+            readonly assetId: "nep245:v2_1.omni.hot.tg:137_3hpYoaLtt8MP1Z2GH1U473DMRKgr";
+            readonly decimals: 6;
+            readonly tokenAddress: "0xc2132d05d31c914a87c6611c10748aeb04b58e8f";
+        };
+    };
+    readonly tron: {
+        readonly usdt: {
+            readonly assetId: "nep141:tron-d28a265909efecdcee7c5028585214ea0b96f015.omft.near";
+            readonly decimals: 6;
+            readonly tokenAddress: "41a614f803b6fd780986a42c78ec9c7f77e6ded13c";
+        };
+    };
+};
+export declare const family: (origin: OriginKey) => "evm" | "tron";
+export declare function resolveOrigin(origin: string, originAsset: string): AssetEntry;
+export declare function resolveDest(destinationAsset: string): AssetEntry;
+export declare function normalizeRecipient(addr: string): string;

package/dist/registry.js

@@ -0,0 +1,41 @@
+export const MOVEMENT = {
+    usdcx: { assetId: "nep141:movement-6f9a70ef4605e7d9174f1abf8d8d3c15012f48f3.omft.near", decimals: 6 },
+    move: { assetId: "nep141:movement.omft.near", decimals: 8 },
+};
+// tokenAddress is the L1 token contract the deposit transfer targets. Provenance (the omft assetId hex
+// equals the L1 contract only on EVM — never derive a non-EVM contract from it):
+//   ethereum USDC 0xa0b8…eb48 / USDT 0xdac1…1ec7  — canonical Ethereum contracts (also embedded in the assetId).
+//   polygon  USDC 0x3c49…3359 (native USDC, NOT USDC.e) / USDT 0xc213…8e8f — canonical Polygon contracts.
+//   tron     USDT 41a614f803… (TR7NHqje…)          — canonical TRC-20 USDT; NOT the omft assetId hex (a bridge id).
+export const ORIGINS = {
+    ethereum: {
+        usdc: { assetId: "nep141:eth-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.omft.near", decimals: 6, tokenAddress: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" },
+        usdt: { assetId: "nep141:eth-0xdac17f958d2ee523a2206206994597c13d831ec7.omft.near", decimals: 6, tokenAddress: "0xdac17f958d2ee523a2206206994597c13d831ec7" },
+    },
+    polygon: {
+        usdc: { assetId: "nep245:v2_1.omni.hot.tg:137_qiStmoQJDQPTebaPjgx5VBxZv6L", decimals: 6, tokenAddress: "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359" },
+        usdt: { assetId: "nep245:v2_1.omni.hot.tg:137_3hpYoaLtt8MP1Z2GH1U473DMRKgr", decimals: 6, tokenAddress: "0xc2132d05d31c914a87c6611c10748aeb04b58e8f" },
+    },
+    tron: {
+        usdt: { assetId: "nep141:tron-d28a265909efecdcee7c5028585214ea0b96f015.omft.near", decimals: 6, tokenAddress: "41a614f803b6fd780986a42c78ec9c7f77e6ded13c" },
+    },
+};
+export const family = (origin) => (origin === "tron" ? "tron" : "evm");
+export function resolveOrigin(origin, originAsset) {
+    const e = ORIGINS[origin]?.[originAsset];
+    if (!e)
+        throw new Error(`unsupported origin/originAsset: ${origin}/${originAsset}`);
+    return e;
+}
+export function resolveDest(destinationAsset) {
+    const e = MOVEMENT[destinationAsset];
+    if (!e)
+        throw new Error(`unsupported destination: ${destinationAsset}`);
+    return e;
+}
+export function normalizeRecipient(addr) {
+    const hex = addr.startsWith("0x") ? addr.slice(2) : addr;
+    if (!/^[0-9a-fA-F]+$/.test(hex) || hex.length > 64)
+        throw new Error(`recipient is not valid: ${addr}`);
+    return "0x" + hex.toLowerCase().padStart(64, "0");
+}

package/dist/status.d.ts

@@ -0,0 +1,6 @@
+import { GetExecutionStatusResponse } from "@defuse-protocol/one-click-sdk-typescript";
+export declare const isTerminal: (status: GetExecutionStatusResponse.status) => boolean;
+/** Fetch the swap's current execution status once. Poll it yourself, checking `isTerminal`. */
+export declare function getStatus(depositAddress: string, opts?: {
+    depositMemo?: string;
+}): Promise<GetExecutionStatusResponse>;

package/dist/status.js

@@ -0,0 +1,11 @@
+import { OneClickService, GetExecutionStatusResponse } from "@defuse-protocol/one-click-sdk-typescript";
+const TERMINAL = new Set([
+    GetExecutionStatusResponse.status.SUCCESS,
+    GetExecutionStatusResponse.status.REFUNDED,
+    GetExecutionStatusResponse.status.FAILED,
+]);
+export const isTerminal = (status) => TERMINAL.has(status);
+/** Fetch the swap's current execution status once. Poll it yourself, checking `isTerminal`. */
+export async function getStatus(depositAddress, opts = {}) {
+    return OneClickService.getExecutionStatus(depositAddress, opts.depositMemo);
+}

package/dist/submit.d.ts

@@ -0,0 +1,9 @@
+import { type SubmitDepositTxResponse } from "@defuse-protocol/one-click-sdk-typescript";
+/**
+ * Hand 1Click the deposit tx hash so it can start processing without waiting to
+ * detect the deposit on the origin chain. Optional speed-up — status tracking works
+ * without it. Goes between broadcasting the deposit and reading status.
+ */
+export declare function submitDeposit(depositAddress: string, txHash: string, opts?: {
+    memo?: string;
+}): Promise<SubmitDepositTxResponse>;

package/dist/submit.js

@@ -0,0 +1,9 @@
+import { OneClickService } from "@defuse-protocol/one-click-sdk-typescript";
+/**
+ * Hand 1Click the deposit tx hash so it can start processing without waiting to
+ * detect the deposit on the origin chain. Optional speed-up — status tracking works
+ * without it. Goes between broadcasting the deposit and reading status.
+ */
+export async function submitDeposit(depositAddress, txHash, opts = {}) {
+    return OneClickService.submitDepositTx({ depositAddress, txHash, memo: opts.memo });
+}

package/dist/tokens.d.ts

@@ -0,0 +1,14 @@
+import { type OriginKey, type StableKey, type DestKey } from "./registry.js";
+export type SupportedToken = {
+    assetId: string;
+    symbol: string;
+    decimals: number;
+    chain: string;
+    contractAddress?: string;
+    price: number;
+    priceUpdatedAt: string;
+    originChain?: OriginKey;
+    originAsset?: StableKey;
+    destinationAsset?: DestKey;
+};
+export declare function listTokens(): Promise<SupportedToken[]>;

package/dist/tokens.js

@@ -0,0 +1,39 @@
+import { OneClickService } from "@defuse-protocol/one-click-sdk-typescript";
+import { ORIGINS, MOVEMENT } from "./registry.js";
+// assetId -> route tag, built once from the registry so listTokens can label each
+// live token with the keys quoteDeposit expects, instead of callers translating back.
+const ROUTE_BY_ASSET_ID = (() => {
+    const m = new Map();
+    const origins = ORIGINS;
+    for (const origin of Object.keys(origins)) {
+        for (const asset of Object.keys(origins[origin])) {
+            m.set(origins[origin][asset].assetId, { originChain: origin, originAsset: asset });
+        }
+    }
+    const dests = MOVEMENT;
+    for (const dest of Object.keys(dests))
+        m.set(dests[dest].assetId, { destinationAsset: dest });
+    return m;
+})();
+// listTokens — live /v0/tokens, filtered to the routes this SDK supports and each tagged with its
+// route-key, so a caller feeds the result straight into quoteDeposit without translating back.
+export async function listTokens() {
+    const tokens = await OneClickService.getTokens();
+    const out = [];
+    for (const t of tokens) {
+        const tag = ROUTE_BY_ASSET_ID.get(t.assetId);
+        if (!tag)
+            continue;
+        out.push({
+            assetId: t.assetId,
+            symbol: t.symbol,
+            decimals: t.decimals,
+            chain: t.blockchain,
+            contractAddress: t.contractAddress,
+            price: t.price,
+            priceUpdatedAt: t.priceUpdatedAt,
+            ...tag,
+        });
+    }
+    return out;
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@moveindustries/near-intents-sdk",
+  "version": "0.0.1",
+  "description": "Thin SDK: USDT/USDC -> Movement USDCx/MOVE over NEAR Intents 1Click.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MoveIndustries/near-intents-sdk.git"
+  },
+  "homepage": "https://github.com/MoveIndustries/near-intents-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/MoveIndustries/near-intents-sdk/issues"
+  },
+  "keywords": [
+    "movement",
+    "near-intents",
+    "1click",
+    "usdc",
+    "usdt",
+    "bridge"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:live:noauth": "LIVE=1 node --env-file-if-exists=.env ./node_modules/.bin/vitest run",
+    "test:live:auth": "LIVE=1 AUTH=1 node --env-file-if-exists=.env ./node_modules/.bin/vitest run",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "publish-packages": "changeset publish"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@defuse-protocol/one-click-sdk-typescript": "^0.1.24"
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.31.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  }
+}