@fastnear/intents 1.6.0

package/dist/umd/browser.global.js

@@ -0,0 +1,802 @@
+/* ⋈ 🏃🏻💨 FastNear intents - IIFE/UMD (@fastnear/intents version 1.6.0) */
+/* https://www.npmjs.com/package/@fastnear/intents/v/1.6.0 */
+"use strict";
+var nearIntents = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+  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/index.ts
+  var src_exports2 = {};
+  __export(src_exports2, {
+    FT_TRANSFER_CALL_GAS: () => FT_TRANSFER_CALL_GAS,
+    INTENTS_CONTRACT_ID: () => INTENTS_CONTRACT_ID,
+    IntentsHttpError: () => IntentsHttpError,
+    ONE_CLICK_BASE_URL: () => ONE_CLICK_BASE_URL,
+    ONE_YOCTO: () => ONE_YOCTO,
+    SOLVER_RELAY_URL: () => SOLVER_RELAY_URL,
+    SolverRelayError: () => SolverRelayError,
+    WITHDRAW_GAS: () => WITHDRAW_GAS,
+    WRAP_NEAR_CONTRACT_ID: () => WRAP_NEAR_CONTRACT_ID,
+    WRAP_NEAR_GAS: () => WRAP_NEAR_GAS,
+    buildIntentMessage: () => buildIntentMessage,
+    createOneClickClient: () => createOneClickClient,
+    createSolverRelayClient: () => createSolverRelayClient,
+    createWalletIntentSigner: () => createWalletIntentSigner,
+    defaultDeadline: () => defaultDeadline,
+    encodeIntentSignature: () => encodeIntentSignature,
+    ftDepositAction: () => ftDepositAction,
+    ftWithdrawAction: () => ftWithdrawAction,
+    mtBalance: () => mtBalance,
+    mtBatchBalances: () => mtBatchBalances,
+    normalizeIntentPublicKey: () => normalizeIntentPublicKey,
+    randomNonce: () => randomNonce,
+    toSignedIntent: () => toSignedIntent,
+    unsignedPayloadParts: () => unsignedPayloadParts,
+    wrapNearAction: () => wrapNearAction
+  });
+
+  // src/types.ts
+  var INTENTS_CONTRACT_ID = "intents.near";
+  var ONE_CLICK_BASE_URL = "https://1click.chaindefuser.com";
+  var SOLVER_RELAY_URL = "https://solver-relay-v2.chaindefuser.com/rpc";
+
+  // src/one-click.ts
+  var IntentsHttpError = class extends Error {
+    static {
+      __name(this, "IntentsHttpError");
+    }
+    status;
+    body;
+    constructor(message, status, body) {
+      super(message);
+      this.name = "IntentsHttpError";
+      this.status = status;
+      this.body = body;
+    }
+  };
+  async function parseBody(response) {
+    const text = await response.text();
+    try {
+      return text ? JSON.parse(text) : null;
+    } catch {
+      return text;
+    }
+  }
+  __name(parseBody, "parseBody");
+  function createOneClickClient(options = {}) {
+    const baseUrl = (options.baseUrl ?? ONE_CLICK_BASE_URL).replace(/\/$/, "");
+    const fetchImplementation = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImplementation !== "function") {
+      throw new Error("A fetch implementation is required");
+    }
+    const authHeaders = {};
+    if (options.apiKey) authHeaders["X-API-Key"] = options.apiKey;
+    if (options.jwt) authHeaders.Authorization = `Bearer ${options.jwt}`;
+    async function request(method, path, body) {
+      const headers = body === void 0 ? authHeaders : { ...authHeaders, "Content-Type": "application/json" };
+      const response = await fetchImplementation(`${baseUrl}${path}`, {
+        method,
+        headers,
+        ...body === void 0 ? {} : { body: JSON.stringify(body) }
+      });
+      const parsed = await parseBody(response);
+      if (!response.ok) {
+        const detail = parsed && typeof parsed === "object" && "message" in parsed ? ` \u2014 ${JSON.stringify(parsed.message)}` : "";
+        throw new IntentsHttpError(
+          `1Click ${method} ${path} failed with ${response.status}${detail}`,
+          response.status,
+          parsed
+        );
+      }
+      return parsed;
+    }
+    __name(request, "request");
+    return {
+      tokens: /* @__PURE__ */ __name(() => request("GET", "/v0/tokens"), "tokens"),
+      quote: /* @__PURE__ */ __name((quoteRequest) => request("POST", "/v0/quote", quoteRequest), "quote"),
+      status: /* @__PURE__ */ __name(({ depositAddress, depositMemo }) => {
+        const query = new URLSearchParams({ depositAddress });
+        if (depositMemo) query.set("depositMemo", depositMemo);
+        return request("GET", `/v0/status?${query}`);
+      }, "status"),
+      submitDeposit: /* @__PURE__ */ __name((submitRequest) => request("POST", "/v0/deposit/submit", submitRequest), "submitDeposit"),
+      generateIntent: /* @__PURE__ */ __name(({ standard = "nep413", signerId, depositAddress }) => request("POST", "/v0/generate-intent", {
+        type: "swap_transfer",
+        standard,
+        signerId,
+        depositAddress
+      }), "generateIntent"),
+      submitIntent: /* @__PURE__ */ __name(({ signedData }) => request("POST", "/v0/submit-intent", {
+        type: "swap_transfer",
+        signedData
+      }), "submitIntent")
+    };
+  }
+  __name(createOneClickClient, "createOneClickClient");
+
+  // ../utils/node_modules/base58-js/base58_chars.js
+  var base58_chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  var base58_chars_default = base58_chars;
+
+  // ../utils/node_modules/base58-js/create_base58_map.js
+  var create_base58_map = /* @__PURE__ */ __name(() => {
+    const base58M = Array(256).fill(-1);
+    for (let i = 0; i < base58_chars_default.length; ++i)
+      base58M[base58_chars_default.charCodeAt(i)] = i;
+    return base58M;
+  }, "create_base58_map");
+  var create_base58_map_default = create_base58_map;
+
+  // ../utils/node_modules/base58-js/binary_to_base58.js
+  var base58Map = create_base58_map_default();
+  function binary_to_base58(uint8array) {
+    const result = [];
+    for (const byte of uint8array) {
+      let carry = byte;
+      for (let j = 0; j < result.length; ++j) {
+        const x = (base58Map[result[j]] << 8) + carry;
+        result[j] = base58_chars_default.charCodeAt(x % 58);
+        carry = x / 58 | 0;
+      }
+      while (carry) {
+        result.push(base58_chars_default.charCodeAt(carry % 58));
+        carry = carry / 58 | 0;
+      }
+    }
+    for (const byte of uint8array)
+      if (byte) break;
+      else result.push("1".charCodeAt(0));
+    result.reverse();
+    return String.fromCharCode(...result);
+  }
+  __name(binary_to_base58, "binary_to_base58");
+  var binary_to_base58_default = binary_to_base58;
+
+  // ../../node_modules/js-base64/base64.mjs
+  var _hasBuffer = typeof Buffer === "function";
+  var _TD = typeof TextDecoder === "function" ? new TextDecoder() : void 0;
+  var _TE = typeof TextEncoder === "function" ? new TextEncoder() : void 0;
+  var b64ch = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+  var b64chs = Array.prototype.slice.call(b64ch);
+  var b64tab = ((a) => {
+    let tab = {};
+    a.forEach((c, i) => tab[c] = i);
+    return tab;
+  })(b64chs);
+  var b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
+  var _fromCC = String.fromCharCode.bind(String);
+  var _U8Afrom = typeof Uint8Array.from === "function" ? Uint8Array.from.bind(Uint8Array) : (it) => new Uint8Array(Array.prototype.slice.call(it, 0));
+  var _mkUriSafe = /* @__PURE__ */ __name((src) => src.replace(/=/g, "").replace(/[+\/]/g, (m0) => m0 == "+" ? "-" : "_"), "_mkUriSafe");
+  var _tidyB64 = /* @__PURE__ */ __name((s) => s.replace(/[^A-Za-z0-9\+\/]/g, ""), "_tidyB64");
+  var btoaPolyfill = /* @__PURE__ */ __name((bin) => {
+    let u32, c0, c1, c2, asc = "";
+    const pad = bin.length % 3;
+    for (let i = 0; i < bin.length; ) {
+      if ((c0 = bin.charCodeAt(i++)) > 255 || (c1 = bin.charCodeAt(i++)) > 255 || (c2 = bin.charCodeAt(i++)) > 255)
+        throw new TypeError("invalid character found");
+      u32 = c0 << 16 | c1 << 8 | c2;
+      asc += b64chs[u32 >> 18 & 63] + b64chs[u32 >> 12 & 63] + b64chs[u32 >> 6 & 63] + b64chs[u32 & 63];
+    }
+    return pad ? asc.slice(0, pad - 3) + "===".substring(pad) : asc;
+  }, "btoaPolyfill");
+  var _btoa = typeof btoa === "function" ? (bin) => btoa(bin) : _hasBuffer ? (bin) => Buffer.from(bin, "binary").toString("base64") : btoaPolyfill;
+  var _fromUint8Array = _hasBuffer ? (u8a) => Buffer.from(u8a).toString("base64") : (u8a) => {
+    const maxargs = 4096;
+    let strs = [];
+    for (let i = 0, l = u8a.length; i < l; i += maxargs) {
+      strs.push(_fromCC.apply(null, u8a.subarray(i, i + maxargs)));
+    }
+    return _btoa(strs.join(""));
+  };
+  var fromUint8Array = /* @__PURE__ */ __name((u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a), "fromUint8Array");
+  var atobPolyfill = /* @__PURE__ */ __name((asc) => {
+    asc = asc.replace(/\s+/g, "");
+    if (!b64re.test(asc))
+      throw new TypeError("malformed base64.");
+    asc += "==".slice(2 - (asc.length & 3));
+    let u24, bin = "", r1, r2;
+    for (let i = 0; i < asc.length; ) {
+      u24 = b64tab[asc.charAt(i++)] << 18 | b64tab[asc.charAt(i++)] << 12 | (r1 = b64tab[asc.charAt(i++)]) << 6 | (r2 = b64tab[asc.charAt(i++)]);
+      bin += r1 === 64 ? _fromCC(u24 >> 16 & 255) : r2 === 64 ? _fromCC(u24 >> 16 & 255, u24 >> 8 & 255) : _fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255);
+    }
+    return bin;
+  }, "atobPolyfill");
+  var _atob = typeof atob === "function" ? (asc) => atob(_tidyB64(asc)) : _hasBuffer ? (asc) => Buffer.from(asc, "base64").toString("binary") : atobPolyfill;
+  var _toUint8Array = _hasBuffer ? (a) => _U8Afrom(Buffer.from(a, "base64")) : (a) => _U8Afrom(_atob(a).split("").map((c) => c.charCodeAt(0)));
+  var toUint8Array = /* @__PURE__ */ __name((a) => _toUint8Array(_unURI(a)), "toUint8Array");
+  var _unURI = /* @__PURE__ */ __name((a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == "-" ? "+" : "/")), "_unURI");
+
+  // ../utils/src/storage.ts
+  var memoryStore = /* @__PURE__ */ new Map();
+  var memoryStorageBackend = {
+    getItem: /* @__PURE__ */ __name((key) => memoryStore.get(key) || null, "getItem"),
+    setItem: /* @__PURE__ */ __name((key, value) => memoryStore.set(key, value), "setItem"),
+    removeItem: /* @__PURE__ */ __name((key) => memoryStore.delete(key), "removeItem"),
+    clear: /* @__PURE__ */ __name(() => memoryStore.clear(), "clear")
+  };
+  var createDefaultStorage = /* @__PURE__ */ __name(() => {
+    try {
+      if (typeof globalThis !== "undefined" && "localStorage" in globalThis && globalThis.localStorage) {
+        return globalThis.localStorage;
+      }
+    } catch {
+    }
+    return memoryStorageBackend;
+  }, "createDefaultStorage");
+  var storageBackend = createDefaultStorage();
+
+  // ../utils/src/misc.ts
+  function base64ToBytes(b64Val) {
+    return toUint8Array(b64Val);
+  }
+  __name(base64ToBytes, "base64ToBytes");
+  function bytesToBase64(bytesArr) {
+    return fromUint8Array(bytesArr);
+  }
+  __name(bytesToBase64, "bytesToBase64");
+
+  // ../borsh-schema/src/index.ts
+  var nearChainSchema = new class BorshSchema {
+    static {
+      __name(this, "BorshSchema");
+    }
+    Ed25519Signature = {
+      struct: {
+        data: { array: { type: "u8", len: 64 } }
+      }
+    };
+    Secp256k1Signature = {
+      struct: {
+        data: { array: { type: "u8", len: 65 } }
+      }
+    };
+    MlDsa65Signature = {
+      struct: {
+        data: { array: { type: "u8", len: 3309 } }
+      }
+    };
+    Signature = {
+      enum: [
+        { struct: { ed25519Signature: this.Ed25519Signature } },
+        { struct: { secp256k1Signature: this.Secp256k1Signature } },
+        { struct: { mlDsa65Signature: this.MlDsa65Signature } }
+      ]
+    };
+    Ed25519Data = {
+      struct: {
+        data: { array: { type: "u8", len: 32 } }
+      }
+    };
+    Secp256k1Data = {
+      struct: {
+        data: { array: { type: "u8", len: 64 } }
+      }
+    };
+    MlDsa65Data = {
+      struct: {
+        data: { array: { type: "u8", len: 1952 } }
+      }
+    };
+    PublicKey = {
+      enum: [
+        { struct: { ed25519Key: this.Ed25519Data } },
+        { struct: { secp256k1Key: this.Secp256k1Data } },
+        { struct: { mlDsa65Key: this.MlDsa65Data } }
+      ]
+    };
+    FunctionCallPermission = {
+      struct: {
+        allowance: { option: "u128" },
+        receiverId: "string",
+        methodNames: { array: { type: "string" } }
+      }
+    };
+    FullAccessPermission = {
+      struct: {}
+    };
+    AccessKeyPermission = {
+      enum: [
+        { struct: { functionCall: this.FunctionCallPermission } },
+        { struct: { fullAccess: this.FullAccessPermission } }
+      ]
+    };
+    AccessKey = {
+      struct: {
+        nonce: "u64",
+        permission: this.AccessKeyPermission
+      }
+    };
+    CreateAccount = {
+      struct: {}
+    };
+    DeployContract = {
+      struct: {
+        code: { array: { type: "u8" } }
+      }
+    };
+    FunctionCall = {
+      struct: {
+        methodName: "string",
+        args: { array: { type: "u8" } },
+        gas: "u64",
+        deposit: "u128"
+      }
+    };
+    Transfer = {
+      struct: {
+        deposit: "u128"
+      }
+    };
+    Stake = {
+      struct: {
+        stake: "u128",
+        publicKey: this.PublicKey
+      }
+    };
+    AddKey = {
+      struct: {
+        publicKey: this.PublicKey,
+        accessKey: this.AccessKey
+      }
+    };
+    DeleteKey = {
+      struct: {
+        publicKey: this.PublicKey
+      }
+    };
+    DeleteAccount = {
+      struct: {
+        beneficiaryId: "string"
+      }
+    };
+    ClassicAction = {
+      enum: [
+        { struct: { createAccount: this.CreateAccount } },
+        { struct: { deployContract: this.DeployContract } },
+        { struct: { functionCall: this.FunctionCall } },
+        { struct: { transfer: this.Transfer } },
+        { struct: { stake: this.Stake } },
+        { struct: { addKey: this.AddKey } },
+        { struct: { deleteKey: this.DeleteKey } },
+        { struct: { deleteAccount: this.DeleteAccount } }
+      ]
+    };
+    DelegateAction = {
+      struct: {
+        senderId: "string",
+        receiverId: "string",
+        actions: { array: { type: this.ClassicAction } },
+        nonce: "u64",
+        maxBlockHeight: "u64",
+        publicKey: this.PublicKey
+      }
+    };
+    SignedDelegate = {
+      struct: {
+        delegateAction: this.DelegateAction,
+        signature: this.Signature
+      }
+    };
+    Action = {
+      enum: [
+        { struct: { createAccount: this.CreateAccount } },
+        { struct: { deployContract: this.DeployContract } },
+        { struct: { functionCall: this.FunctionCall } },
+        { struct: { transfer: this.Transfer } },
+        { struct: { stake: this.Stake } },
+        { struct: { addKey: this.AddKey } },
+        { struct: { deleteKey: this.DeleteKey } },
+        { struct: { deleteAccount: this.DeleteAccount } },
+        { struct: { signedDelegate: this.SignedDelegate } }
+      ]
+    };
+    Transaction = {
+      struct: {
+        signerId: "string",
+        publicKey: this.PublicKey,
+        nonce: "u64",
+        receiverId: "string",
+        blockHash: { array: { type: "u8", len: 32 } },
+        actions: { array: { type: this.Action } }
+      }
+    };
+    SignedTransaction = {
+      struct: {
+        transaction: this.Transaction,
+        signature: this.Signature
+      }
+    };
+  }();
+  var getBorshSchema = /* @__PURE__ */ __name(() => nearChainSchema, "getBorshSchema");
+
+  // ../utils/src/transaction.ts
+  var SCHEMA = getBorshSchema();
+
+  // src/signing.ts
+  function randomNonce() {
+    return crypto.getRandomValues(new Uint8Array(32));
+  }
+  __name(randomNonce, "randomNonce");
+  var DEFAULT_DEADLINE_MS = 5 * 60 * 1e3;
+  function defaultDeadline(ms = DEFAULT_DEADLINE_MS) {
+    return new Date(Date.now() + ms).toISOString();
+  }
+  __name(defaultDeadline, "defaultDeadline");
+  function buildIntentMessage({
+    signerId,
+    intents,
+    deadline
+  }) {
+    if (!signerId) throw new Error("signerId is required");
+    if (!Array.isArray(intents) || intents.length === 0) {
+      throw new Error("At least one intent is required");
+    }
+    return {
+      signer_id: signerId,
+      deadline: deadline ?? defaultDeadline(),
+      intents
+    };
+  }
+  __name(buildIntentMessage, "buildIntentMessage");
+  function encodeIntentSignature(signature) {
+    if (typeof signature === "string") {
+      if (signature.startsWith("ed25519:") || signature.startsWith("secp256k1:")) {
+        return signature;
+      }
+      return encodeIntentSignature(base64ToBytes(signature));
+    }
+    if (signature.length === 64) return `ed25519:${binary_to_base58_default(signature)}`;
+    if (signature.length === 65) return `secp256k1:${binary_to_base58_default(signature)}`;
+    throw new Error(
+      `Unsupported NEP-413 signature length: ${signature.length} (expected 64 or 65 bytes)`
+    );
+  }
+  __name(encodeIntentSignature, "encodeIntentSignature");
+  function normalizeIntentPublicKey(publicKey) {
+    if (!publicKey) throw new Error("A public key is required");
+    return publicKey.includes(":") ? publicKey : `ed25519:${publicKey}`;
+  }
+  __name(normalizeIntentPublicKey, "normalizeIntentPublicKey");
+  function toSignedIntent({
+    message,
+    nonce,
+    recipient = INTENTS_CONTRACT_ID,
+    publicKey,
+    signature,
+    callbackUrl
+  }) {
+    if (nonce.length !== 32) {
+      throw new Error(`NEP-413 nonce must be exactly 32 bytes, got ${nonce.length}`);
+    }
+    return {
+      standard: "nep413",
+      payload: {
+        message: typeof message === "string" ? message : JSON.stringify(message),
+        nonce: bytesToBase64(nonce),
+        recipient,
+        ...callbackUrl ? { callbackUrl } : {}
+      },
+      public_key: normalizeIntentPublicKey(publicKey),
+      signature: encodeIntentSignature(signature)
+    };
+  }
+  __name(toSignedIntent, "toSignedIntent");
+  function unsignedPayloadParts(input) {
+    const payload = "payload" in input && typeof input.payload === "object" ? input.payload : input;
+    if ("standard" in input && typeof input.standard === "string" && input.standard !== "nep413") {
+      throw new Error(
+        `This signer only signs nep413 payloads; got standard "${input.standard}"`
+      );
+    }
+    if (typeof payload?.message !== "string" || typeof payload?.recipient !== "string") {
+      throw new Error("Unsigned payload must carry message and recipient strings");
+    }
+    const nonce = typeof payload.nonce === "string" ? base64ToBytes(payload.nonce) : payload.nonce;
+    if (!(nonce instanceof Uint8Array) || nonce.length !== 32) {
+      throw new Error("Unsigned payload nonce must decode to exactly 32 bytes");
+    }
+    return {
+      message: payload.message,
+      nonce,
+      recipient: payload.recipient,
+      ...payload.callbackUrl ? { callbackUrl: payload.callbackUrl } : {}
+    };
+  }
+  __name(unsignedPayloadParts, "unsignedPayloadParts");
+  function assertExpectedRecipient(recipient, options) {
+    const expected = options?.expectedRecipient ?? INTENTS_CONTRACT_ID;
+    if (recipient !== expected) {
+      throw new Error(
+        `Refusing to sign a payload for recipient "${recipient}" \u2014 expected "${expected}". Pass { expectedRecipient } only when intentionally targeting a different verifier.`
+      );
+    }
+  }
+  __name(assertExpectedRecipient, "assertExpectedRecipient");
+  function signerIdFromMessage(message) {
+    try {
+      const parsed = JSON.parse(message);
+      return typeof parsed?.signer_id === "string" ? parsed.signer_id : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  __name(signerIdFromMessage, "signerIdFromMessage");
+  function createWalletIntentSigner({
+    wallet,
+    network = "mainnet"
+  }) {
+    if (!wallet || typeof wallet.signMessage !== "function") {
+      throw new Error(
+        "A FastNEAR wallet module with signMessage is required (connect @fastnear/wallet first)"
+      );
+    }
+    async function signParts({
+      message,
+      nonce,
+      recipient,
+      callbackUrl,
+      expectedSigner
+    }) {
+      if (callbackUrl) {
+        throw new Error(
+          "Wallet intent signing cannot bind callbackUrl payloads; use the local signer or drop callbackUrl"
+        );
+      }
+      const signed = await wallet.signMessage({
+        message,
+        recipient,
+        nonce,
+        network
+      });
+      if (expectedSigner && signed.accountId && signed.accountId !== expectedSigner) {
+        throw new Error(
+          `Wallet signed as ${signed.accountId} but the intent names ${expectedSigner}; reconnect the intended account`
+        );
+      }
+      return toSignedIntent({
+        message,
+        nonce,
+        recipient,
+        publicKey: signed.publicKey,
+        signature: signed.signature,
+        callbackUrl
+      });
+    }
+    __name(signParts, "signParts");
+    return {
+      async signIntents(params) {
+        const signerId = params.signerId ?? (typeof wallet.accountId === "function" ? wallet.accountId({ network }) : null);
+        if (!signerId) {
+          throw new Error(`No wallet account connected on ${network}`);
+        }
+        const message = buildIntentMessage({
+          signerId,
+          intents: params.intents,
+          deadline: params.deadline
+        });
+        return signParts({
+          message: JSON.stringify(message),
+          nonce: params.nonce ?? randomNonce(),
+          recipient: params.verifyingContract ?? INTENTS_CONTRACT_ID,
+          expectedSigner: signerId
+        });
+      },
+      async signPayload(payload, options) {
+        const parts = unsignedPayloadParts(payload);
+        assertExpectedRecipient(parts.recipient, options);
+        return signParts({
+          ...parts,
+          expectedSigner: signerIdFromMessage(parts.message)
+        });
+      }
+    };
+  }
+  __name(createWalletIntentSigner, "createWalletIntentSigner");
+
+  // src/verifier.ts
+  var FT_TRANSFER_CALL_GAS = "100000000000000";
+  var WITHDRAW_GAS = "100000000000000";
+  var WRAP_NEAR_GAS = "30000000000000";
+  var ONE_YOCTO = "1";
+  var WRAP_NEAR_CONTRACT_ID = "wrap.near";
+  function ftDepositAction({
+    amount,
+    creditTo,
+    msg,
+    verifierId = INTENTS_CONTRACT_ID,
+    gas = FT_TRANSFER_CALL_GAS
+  }) {
+    if (creditTo !== void 0 && msg !== void 0) {
+      throw new Error("Pass either creditTo or msg, not both");
+    }
+    return {
+      type: "FunctionCall",
+      methodName: "ft_transfer_call",
+      args: {
+        receiver_id: verifierId,
+        amount,
+        msg: msg ?? creditTo ?? ""
+      },
+      gas,
+      deposit: ONE_YOCTO
+    };
+  }
+  __name(ftDepositAction, "ftDepositAction");
+  function wrapNearAction({
+    amountYocto,
+    gas = WRAP_NEAR_GAS
+  }) {
+    return {
+      type: "FunctionCall",
+      methodName: "near_deposit",
+      args: {},
+      gas,
+      deposit: amountYocto
+    };
+  }
+  __name(wrapNearAction, "wrapNearAction");
+  function ftWithdrawAction({
+    token,
+    receiverId,
+    amount,
+    memo,
+    msg,
+    storageDeposit,
+    gas = WITHDRAW_GAS
+  }) {
+    if (token.includes(":")) {
+      throw new Error(
+        `ft_withdraw takes the plain token contract id, not a prefixed multi-token id: ${token}`
+      );
+    }
+    return {
+      type: "FunctionCall",
+      methodName: "ft_withdraw",
+      args: {
+        token,
+        receiver_id: receiverId,
+        amount,
+        ...memo !== void 0 ? { memo } : {},
+        ...msg !== void 0 ? { msg } : {},
+        ...storageDeposit !== void 0 ? { storage_deposit: storageDeposit } : {}
+      },
+      gas,
+      deposit: ONE_YOCTO
+    };
+  }
+  __name(ftWithdrawAction, "ftWithdrawAction");
+  async function mtBalance({
+    accountId,
+    tokenId,
+    view,
+    verifierId = INTENTS_CONTRACT_ID
+  }) {
+    const result = await view({
+      contractId: verifierId,
+      methodName: "mt_balance_of",
+      args: { account_id: accountId, token_id: tokenId }
+    });
+    return String(result ?? "0");
+  }
+  __name(mtBalance, "mtBalance");
+  async function mtBatchBalances({
+    accountId,
+    tokenIds,
+    view,
+    verifierId = INTENTS_CONTRACT_ID
+  }) {
+    const result = await view({
+      contractId: verifierId,
+      methodName: "mt_batch_balance_of",
+      args: { account_id: accountId, token_ids: tokenIds }
+    });
+    if (!Array.isArray(result) || result.length !== tokenIds.length) {
+      throw new Error(
+        `mt_batch_balance_of returned ${Array.isArray(result) ? result.length : typeof result} results for ${tokenIds.length} token ids`
+      );
+    }
+    return Object.fromEntries(
+      tokenIds.map((tokenId, index) => [tokenId, String(result[index] ?? "0")])
+    );
+  }
+  __name(mtBatchBalances, "mtBatchBalances");
+
+  // src/relay.ts
+  var SolverRelayError = class extends Error {
+    static {
+      __name(this, "SolverRelayError");
+    }
+    rpcError;
+    constructor(message, rpcError) {
+      super(message);
+      this.name = "SolverRelayError";
+      this.rpcError = rpcError;
+    }
+  };
+  function createSolverRelayClient(options = {}) {
+    const url = options.url ?? SOLVER_RELAY_URL;
+    const fetchImplementation = options.fetch ?? globalThis.fetch;
+    if (typeof fetchImplementation !== "function") {
+      throw new Error("A fetch implementation is required");
+    }
+    const headers = { "Content-Type": "application/json" };
+    if (options.apiKey) headers["X-API-Key"] = options.apiKey;
+    let nextId = 0;
+    async function call(method, params) {
+      const id = ++nextId;
+      const response = await fetchImplementation(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ id, jsonrpc: "2.0", method, params: [params] })
+      });
+      const text = await response.text();
+      let parsed = null;
+      try {
+        parsed = text ? JSON.parse(text) : null;
+      } catch {
+        parsed = text;
+      }
+      if (!response.ok) {
+        throw new IntentsHttpError(
+          `Solver relay ${method} failed with ${response.status}`,
+          response.status,
+          parsed
+        );
+      }
+      const body = parsed;
+      if (body && typeof body === "object" && body.error != null) {
+        throw new SolverRelayError(
+          `Solver relay ${method} returned an error: ${JSON.stringify(body.error)}`,
+          body.error
+        );
+      }
+      if (!body || typeof body !== "object" || !("result" in body)) {
+        throw new SolverRelayError(
+          `Solver relay ${method} returned a malformed JSON-RPC envelope`,
+          parsed
+        );
+      }
+      return body.result;
+    }
+    __name(call, "call");
+    return {
+      quote: /* @__PURE__ */ __name((params) => call("quote", params), "quote"),
+      publishIntent: /* @__PURE__ */ __name(({ signedData, quoteHashes }) => call("publish_intent", {
+        signed_data: signedData,
+        quote_hashes: quoteHashes
+      }), "publishIntent"),
+      publishIntents: /* @__PURE__ */ __name(({ signedDatas, quoteHashes, requote }) => call("publish_intents", {
+        signed_datas: signedDatas,
+        quote_hashes: quoteHashes,
+        ...requote === void 0 ? {} : { requote }
+      }), "publishIntents"),
+      getStatus: /* @__PURE__ */ __name(({ intentHash }) => call("get_status", { intent_hash: intentHash }), "getStatus")
+    };
+  }
+  __name(createSolverRelayClient, "createSolverRelayClient");
+  return __toCommonJS(src_exports2);
+})();
+
+Object.defineProperty(globalThis, 'nearIntents', {
+  value: nearIntents,
+  enumerable: true,
+  configurable: false,
+});
+
+//# sourceMappingURL=browser.global.js.map