@settlemint/sdk-portal 2.3.2-mainb65cc53b → 2.3.2-maineefa9743

package/dist/portal.d.cts

@@ -1,25 +1,22 @@
-import { AbstractSetupSchema, FragmentOf, ResultOf, VariablesOf, initGraphQLTada, readFragment } from "gql.tada";
-import { GraphQLClient } from "graphql-request";
-import { z } from "zod/v4";
-import { Address, Hex, TransactionReceipt as TransactionReceipt$1 } from "viem";
-import * as graphql_ws0 from "graphql-ws";
+import { AbstractSetupSchema, initGraphQLTada } from 'gql.tada';
+export { FragmentOf, ResultOf, VariablesOf, readFragment } from 'gql.tada';
+import { GraphQLClient } from 'graphql-request';
+import { z } from 'zod/v4';
+import { TransactionReceipt as TransactionReceipt$1, Hex, Address } from 'viem';
+import * as graphql_ws from 'graphql-ws';
 
-//#region src/utils/websocket-client.d.ts
-/**
-* Options for the GraphQL WebSocket client
-*/
 /**
  * Options for the GraphQL WebSocket client
  */
 interface WebsocketClientOptions {
-  /**
-   * The GraphQL endpoint URL for the Portal API
-   */
-  portalGraphqlEndpoint: string;
-  /**
-   * The access token for authentication with the Portal API
-   */
-  accessToken?: string;
+    /**
+     * The GraphQL endpoint URL for the Portal API
+     */
+    portalGraphqlEndpoint: string;
+    /**
+     * The access token for authentication with the Portal API
+     */
+    accessToken?: string;
 }
 /**
  * Creates a GraphQL WebSocket client for the Portal API
@@ -34,61 +31,56 @@ interface WebsocketClientOptions {
  *   accessToken: "your-access-token",
  * });
  */
-declare function getWebsocketClient({
-  portalGraphqlEndpoint,
-  accessToken
-}: WebsocketClientOptions): graphql_ws0.Client;
+declare function getWebsocketClient({ portalGraphqlEndpoint, accessToken }: WebsocketClientOptions): graphql_ws.Client;
 
-//#endregion
-//#region src/utils/wait-for-transaction-receipt.d.ts
 /**
  * Represents an event emitted during a transaction execution
  */
 interface TransactionEvent {
-  /** The name of the event that was emitted */
-  eventName: string;
-  /** The arguments emitted by the event */
-  args: Record<string, unknown>;
-  /** Indexed event parameters used for filtering and searching */
-  topics: Hex[];
+    /** The name of the event that was emitted */
+    eventName: string;
+    /** The arguments emitted by the event */
+    args: Record<string, unknown>;
+    /** Indexed event parameters used for filtering and searching */
+    topics: Hex[];
 }
 /**
  * Represents the structure of a blockchain transaction receipt
  */
 interface TransactionReceipt extends TransactionReceipt$1<string, number, "Success" | "Reverted"> {
-  /** The raw reason for transaction reversion, if applicable */
-  revertReason: string;
-  /** Human-readable version of the revert reason */
-  revertReasonDecoded: string;
-  /** Array of events emitted during the transaction */
-  events: TransactionEvent[];
-  /** The address of the contract deployed in the transaction */
-  contractAddress: Address;
+    /** The raw reason for transaction reversion, if applicable */
+    revertReason: string;
+    /** Human-readable version of the revert reason */
+    revertReasonDecoded: string;
+    /** Array of events emitted during the transaction */
+    events: TransactionEvent[];
+    /** The address of the contract deployed in the transaction */
+    contractAddress: Address;
 }
 /**
  * Represents the structure of a blockchain transaction with its receipt
  */
 interface Transaction {
-  receipt: TransactionReceipt;
-  /** The hash of the transaction (duplicate of receipt.transactionHash) */
-  transactionHash: string;
-  /** The sender address (duplicate of receipt.from) */
-  from: string;
-  /** Timestamp when the transaction was created */
-  createdAt: string;
-  /** The contract address involved in the transaction */
-  address: string;
-  /** The name of the function called in the transaction */
-  functionName: string;
-  /** Whether the transaction is a contract deployment */
-  isContract: boolean;
+    receipt: TransactionReceipt;
+    /** The hash of the transaction (duplicate of receipt.transactionHash) */
+    transactionHash: string;
+    /** The sender address (duplicate of receipt.from) */
+    from: string;
+    /** Timestamp when the transaction was created */
+    createdAt: string;
+    /** The contract address involved in the transaction */
+    address: string;
+    /** The name of the function called in the transaction */
+    functionName: string;
+    /** Whether the transaction is a contract deployment */
+    isContract: boolean;
 }
 /**
  * Options for waiting for a transaction receipt
  */
 interface WaitForTransactionReceiptOptions extends WebsocketClientOptions {
-  /** Optional timeout in milliseconds before the operation fails */
-  timeout?: number;
+    /** Optional timeout in milliseconds before the operation fails */
+    timeout?: number;
 }
 /**
  * Waits for a blockchain transaction receipt by subscribing to transaction updates via GraphQL.
@@ -110,31 +102,22 @@ interface WaitForTransactionReceiptOptions extends WebsocketClientOptions {
  */
 declare function waitForTransactionReceipt(transactionHash: string, options: WaitForTransactionReceiptOptions): Promise<Transaction>;
 
-//#endregion
-//#region src/utils/wallet-verification-challenge.d.ts
-/**
- * Custom error class for challenge-related errors
- */
-declare class ChallengeError extends Error {
-  readonly code: string;
-  constructor(message: string, code: string);
-}
 /**
  * Options for handling a wallet verification challenge
  */
 interface HandleWalletVerificationChallengeOptions<Setup extends AbstractSetupSchema> {
-  /** The portal client instance */
-  portalClient: GraphQLClient;
-  /** The GraphQL query builder */
-  portalGraphql: initGraphQLTada<Setup>;
-  /** The ID of the verification challenge */
-  verificationId: string;
-  /** The wallet address to verify */
-  userWalletAddress: Address;
-  /** The verification code provided by the user */
-  code: string | number;
-  /** The type of verification being performed */
-  verificationType: "otp" | "secret-code" | "pincode";
+    /** The portal client instance */
+    portalClient: GraphQLClient;
+    /** The GraphQL query builder */
+    portalGraphql: initGraphQLTada<Setup>;
+    /** The ID of the verification challenge */
+    verificationId: string;
+    /** The wallet address to verify */
+    userWalletAddress: Address;
+    /** The verification code provided by the user */
+    code: string | number;
+    /** The type of verification being performed */
+    verificationType: "otp" | "secret-code" | "pincode";
 }
 /**
  * Handles a wallet verification challenge by generating an appropriate response
@@ -160,20 +143,11 @@ interface HandleWalletVerificationChallengeOptions<Setup extends AbstractSetupSc
  *   verificationType: "otp"
  * });
  */
-declare function handleWalletVerificationChallenge<const Setup extends AbstractSetupSchema>({
-  portalClient,
-  portalGraphql,
-  verificationId,
-  userWalletAddress,
-  code,
-  verificationType
-}: HandleWalletVerificationChallengeOptions<Setup>): Promise<{
-  challengeResponse: string;
-  verificationId?: string;
+declare function handleWalletVerificationChallenge<const Setup extends AbstractSetupSchema>({ portalClient, portalGraphql, verificationId, userWalletAddress, code, verificationType, }: HandleWalletVerificationChallengeOptions<Setup>): Promise<{
+    challengeResponse: string;
+    verificationId?: string;
 }>;
 
-//#endregion
-//#region src/portal.d.ts
 /**
  * Configuration options for the GraphQL client, excluding 'url' and 'exchanges'.
  */
@@ -182,16 +156,16 @@ type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];
  * Schema for validating Portal client configuration options.
  */
 declare const ClientOptionsSchema: z.ZodObject<{
-  instance: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
-  accessToken: z.ZodOptional<z.ZodString>;
-  cache: z.ZodOptional<z.ZodEnum<{
-    default: "default";
-    "force-cache": "force-cache";
-    "no-cache": "no-cache";
-    "no-store": "no-store";
-    "only-if-cached": "only-if-cached";
-    reload: "reload";
-  }>>;
+    instance: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    cache: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        "force-cache": "force-cache";
+        "no-cache": "no-cache";
+        "no-store": "no-store";
+        "only-if-cached": "only-if-cached";
+        reload: "reload";
+    }>>;
 }, z.core.$strip>;
 /**
  * Type representing the validated client options.
@@ -243,10 +217,8 @@ type ClientOptions = z.infer<typeof ClientOptionsSchema>;
  * const result = await portalClient.request(query);
  */
 declare function createPortalClient<const Setup extends AbstractSetupSchema>(options: ClientOptions, clientOptions?: RequestConfig): {
-  client: GraphQLClient;
-  graphql: initGraphQLTada<Setup>;
+    client: GraphQLClient;
+    graphql: initGraphQLTada<Setup>;
 };
 
-//#endregion
-export { ClientOptions, ClientOptionsSchema, FragmentOf, HandleWalletVerificationChallengeOptions, RequestConfig, ResultOf, Transaction, TransactionEvent, TransactionReceipt, VariablesOf, WaitForTransactionReceiptOptions, WebsocketClientOptions, createPortalClient, getWebsocketClient, handleWalletVerificationChallenge, readFragment, waitForTransactionReceipt };
-//# sourceMappingURL=portal.d.cts.map
+export { type ClientOptions, ClientOptionsSchema, type HandleWalletVerificationChallengeOptions, type RequestConfig, type Transaction, type TransactionEvent, type TransactionReceipt, type WaitForTransactionReceiptOptions, type WebsocketClientOptions, createPortalClient, getWebsocketClient, handleWalletVerificationChallenge, waitForTransactionReceipt };

package/dist/portal.d.ts

@@ -1,25 +1,22 @@
-import { AbstractSetupSchema, FragmentOf, ResultOf, VariablesOf, initGraphQLTada, readFragment } from "gql.tada";
-import { GraphQLClient } from "graphql-request";
-import { z } from "zod/v4";
-import * as graphql_ws0 from "graphql-ws";
-import { Address, Hex, TransactionReceipt as TransactionReceipt$1 } from "viem";
+import { AbstractSetupSchema, initGraphQLTada } from 'gql.tada';
+export { FragmentOf, ResultOf, VariablesOf, readFragment } from 'gql.tada';
+import { GraphQLClient } from 'graphql-request';
+import { z } from 'zod/v4';
+import { TransactionReceipt as TransactionReceipt$1, Hex, Address } from 'viem';
+import * as graphql_ws from 'graphql-ws';
 
-//#region src/utils/websocket-client.d.ts
-/**
-* Options for the GraphQL WebSocket client
-*/
 /**
  * Options for the GraphQL WebSocket client
  */
 interface WebsocketClientOptions {
-  /**
-   * The GraphQL endpoint URL for the Portal API
-   */
-  portalGraphqlEndpoint: string;
-  /**
-   * The access token for authentication with the Portal API
-   */
-  accessToken?: string;
+    /**
+     * The GraphQL endpoint URL for the Portal API
+     */
+    portalGraphqlEndpoint: string;
+    /**
+     * The access token for authentication with the Portal API
+     */
+    accessToken?: string;
 }
 /**
  * Creates a GraphQL WebSocket client for the Portal API
@@ -34,61 +31,56 @@ interface WebsocketClientOptions {
  *   accessToken: "your-access-token",
  * });
  */
-declare function getWebsocketClient({
-  portalGraphqlEndpoint,
-  accessToken
-}: WebsocketClientOptions): graphql_ws0.Client;
+declare function getWebsocketClient({ portalGraphqlEndpoint, accessToken }: WebsocketClientOptions): graphql_ws.Client;
 
-//#endregion
-//#region src/utils/wait-for-transaction-receipt.d.ts
 /**
  * Represents an event emitted during a transaction execution
  */
 interface TransactionEvent {
-  /** The name of the event that was emitted */
-  eventName: string;
-  /** The arguments emitted by the event */
-  args: Record<string, unknown>;
-  /** Indexed event parameters used for filtering and searching */
-  topics: Hex[];
+    /** The name of the event that was emitted */
+    eventName: string;
+    /** The arguments emitted by the event */
+    args: Record<string, unknown>;
+    /** Indexed event parameters used for filtering and searching */
+    topics: Hex[];
 }
 /**
  * Represents the structure of a blockchain transaction receipt
  */
 interface TransactionReceipt extends TransactionReceipt$1<string, number, "Success" | "Reverted"> {
-  /** The raw reason for transaction reversion, if applicable */
-  revertReason: string;
-  /** Human-readable version of the revert reason */
-  revertReasonDecoded: string;
-  /** Array of events emitted during the transaction */
-  events: TransactionEvent[];
-  /** The address of the contract deployed in the transaction */
-  contractAddress: Address;
+    /** The raw reason for transaction reversion, if applicable */
+    revertReason: string;
+    /** Human-readable version of the revert reason */
+    revertReasonDecoded: string;
+    /** Array of events emitted during the transaction */
+    events: TransactionEvent[];
+    /** The address of the contract deployed in the transaction */
+    contractAddress: Address;
 }
 /**
  * Represents the structure of a blockchain transaction with its receipt
  */
 interface Transaction {
-  receipt: TransactionReceipt;
-  /** The hash of the transaction (duplicate of receipt.transactionHash) */
-  transactionHash: string;
-  /** The sender address (duplicate of receipt.from) */
-  from: string;
-  /** Timestamp when the transaction was created */
-  createdAt: string;
-  /** The contract address involved in the transaction */
-  address: string;
-  /** The name of the function called in the transaction */
-  functionName: string;
-  /** Whether the transaction is a contract deployment */
-  isContract: boolean;
+    receipt: TransactionReceipt;
+    /** The hash of the transaction (duplicate of receipt.transactionHash) */
+    transactionHash: string;
+    /** The sender address (duplicate of receipt.from) */
+    from: string;
+    /** Timestamp when the transaction was created */
+    createdAt: string;
+    /** The contract address involved in the transaction */
+    address: string;
+    /** The name of the function called in the transaction */
+    functionName: string;
+    /** Whether the transaction is a contract deployment */
+    isContract: boolean;
 }
 /**
  * Options for waiting for a transaction receipt
  */
 interface WaitForTransactionReceiptOptions extends WebsocketClientOptions {
-  /** Optional timeout in milliseconds before the operation fails */
-  timeout?: number;
+    /** Optional timeout in milliseconds before the operation fails */
+    timeout?: number;
 }
 /**
  * Waits for a blockchain transaction receipt by subscribing to transaction updates via GraphQL.
@@ -110,31 +102,22 @@ interface WaitForTransactionReceiptOptions extends WebsocketClientOptions {
  */
 declare function waitForTransactionReceipt(transactionHash: string, options: WaitForTransactionReceiptOptions): Promise<Transaction>;
 
-//#endregion
-//#region src/utils/wallet-verification-challenge.d.ts
-/**
- * Custom error class for challenge-related errors
- */
-declare class ChallengeError extends Error {
-  readonly code: string;
-  constructor(message: string, code: string);
-}
 /**
  * Options for handling a wallet verification challenge
  */
 interface HandleWalletVerificationChallengeOptions<Setup extends AbstractSetupSchema> {
-  /** The portal client instance */
-  portalClient: GraphQLClient;
-  /** The GraphQL query builder */
-  portalGraphql: initGraphQLTada<Setup>;
-  /** The ID of the verification challenge */
-  verificationId: string;
-  /** The wallet address to verify */
-  userWalletAddress: Address;
-  /** The verification code provided by the user */
-  code: string | number;
-  /** The type of verification being performed */
-  verificationType: "otp" | "secret-code" | "pincode";
+    /** The portal client instance */
+    portalClient: GraphQLClient;
+    /** The GraphQL query builder */
+    portalGraphql: initGraphQLTada<Setup>;
+    /** The ID of the verification challenge */
+    verificationId: string;
+    /** The wallet address to verify */
+    userWalletAddress: Address;
+    /** The verification code provided by the user */
+    code: string | number;
+    /** The type of verification being performed */
+    verificationType: "otp" | "secret-code" | "pincode";
 }
 /**
  * Handles a wallet verification challenge by generating an appropriate response
@@ -160,20 +143,11 @@ interface HandleWalletVerificationChallengeOptions<Setup extends AbstractSetupSc
  *   verificationType: "otp"
  * });
  */
-declare function handleWalletVerificationChallenge<const Setup extends AbstractSetupSchema>({
-  portalClient,
-  portalGraphql,
-  verificationId,
-  userWalletAddress,
-  code,
-  verificationType
-}: HandleWalletVerificationChallengeOptions<Setup>): Promise<{
-  challengeResponse: string;
-  verificationId?: string;
+declare function handleWalletVerificationChallenge<const Setup extends AbstractSetupSchema>({ portalClient, portalGraphql, verificationId, userWalletAddress, code, verificationType, }: HandleWalletVerificationChallengeOptions<Setup>): Promise<{
+    challengeResponse: string;
+    verificationId?: string;
 }>;
 
-//#endregion
-//#region src/portal.d.ts
 /**
  * Configuration options for the GraphQL client, excluding 'url' and 'exchanges'.
  */
@@ -182,16 +156,16 @@ type RequestConfig = ConstructorParameters<typeof GraphQLClient>[1];
  * Schema for validating Portal client configuration options.
  */
 declare const ClientOptionsSchema: z.ZodObject<{
-  instance: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
-  accessToken: z.ZodOptional<z.ZodString>;
-  cache: z.ZodOptional<z.ZodEnum<{
-    default: "default";
-    "force-cache": "force-cache";
-    "no-cache": "no-cache";
-    "no-store": "no-store";
-    "only-if-cached": "only-if-cached";
-    reload: "reload";
-  }>>;
+    instance: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    accessToken: z.ZodOptional<z.ZodString>;
+    cache: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        "force-cache": "force-cache";
+        "no-cache": "no-cache";
+        "no-store": "no-store";
+        "only-if-cached": "only-if-cached";
+        reload: "reload";
+    }>>;
 }, z.core.$strip>;
 /**
  * Type representing the validated client options.
@@ -243,10 +217,8 @@ type ClientOptions = z.infer<typeof ClientOptionsSchema>;
  * const result = await portalClient.request(query);
  */
 declare function createPortalClient<const Setup extends AbstractSetupSchema>(options: ClientOptions, clientOptions?: RequestConfig): {
-  client: GraphQLClient;
-  graphql: initGraphQLTada<Setup>;
+    client: GraphQLClient;
+    graphql: initGraphQLTada<Setup>;
 };
 
-//#endregion
-export { ClientOptions, ClientOptionsSchema, FragmentOf, HandleWalletVerificationChallengeOptions, RequestConfig, ResultOf, Transaction, TransactionEvent, TransactionReceipt, VariablesOf, WaitForTransactionReceiptOptions, WebsocketClientOptions, createPortalClient, getWebsocketClient, handleWalletVerificationChallenge, readFragment, waitForTransactionReceipt };
-//# sourceMappingURL=portal.d.ts.map
+export { type ClientOptions, ClientOptionsSchema, type HandleWalletVerificationChallengeOptions, type RequestConfig, type Transaction, type TransactionEvent, type TransactionReceipt, type WaitForTransactionReceiptOptions, type WebsocketClientOptions, createPortalClient, getWebsocketClient, handleWalletVerificationChallenge, waitForTransactionReceipt };

package/dist/portal.mjs

@@ -0,0 +1,186 @@
+// src/portal.ts
+import { appendHeaders } from "@settlemint/sdk-utils/http";
+import { ensureServer } from "@settlemint/sdk-utils/runtime";
+import { ApplicationAccessTokenSchema, UrlOrPathSchema, validate } from "@settlemint/sdk-utils/validation";
+import { initGraphQLTada } from "gql.tada";
+import { GraphQLClient } from "graphql-request";
+import { z } from "zod/v4";
+import { readFragment } from "gql.tada";
+
+// src/utils/websocket-client.ts
+import { createClient } from "graphql-ws";
+function getWebsocketClient({ portalGraphqlEndpoint, accessToken }) {
+  if (!portalGraphqlEndpoint) {
+    throw new Error("portalGraphqlEndpoint is required");
+  }
+  const graphqlEndpoint = setWsProtocol(new URL(portalGraphqlEndpoint));
+  return createClient({
+    url: `${graphqlEndpoint.protocol}//${graphqlEndpoint.host}/${accessToken}${graphqlEndpoint.pathname}${graphqlEndpoint.search}`
+  });
+}
+function setWsProtocol(url) {
+  if (url.protocol === "ws:" || url.protocol === "wss:") {
+    return url;
+  }
+  if (url.protocol === "http:") {
+    url.protocol = "ws:";
+  } else {
+    url.protocol = "wss:";
+  }
+  return url;
+}
+
+// src/utils/wait-for-transaction-receipt.ts
+async function waitForTransactionReceipt(transactionHash, options) {
+  const wsClient = getWebsocketClient(options);
+  const subscription = wsClient.iterate({
+    query: `subscription getTransaction($transactionHash: String!) {
+        getTransaction(transactionHash: $transactionHash) {
+          receipt {
+            transactionHash
+            to
+            status
+            from
+            type
+            revertReason
+            revertReasonDecoded
+            logs
+            events
+            contractAddress
+          }
+          transactionHash
+          from
+          createdAt
+          address
+          functionName
+          isContract
+        }
+      }`,
+    variables: { transactionHash }
+  });
+  const promises = [getTransactionFromSubscription(subscription)];
+  if (options.timeout) {
+    promises.push(createTimeoutPromise(options.timeout));
+  }
+  return Promise.race(promises);
+}
+function createTimeoutPromise(timeout) {
+  return new Promise((_, reject) => {
+    setTimeout(() => reject(new Error("Transaction receipt not found")), timeout);
+  });
+}
+async function getTransactionFromSubscription(subscription) {
+  for await (const result of subscription) {
+    if (result?.data?.getTransaction?.receipt) {
+      return result.data.getTransaction;
+    }
+  }
+  throw new Error("No transaction found");
+}
+
+// src/utils/wallet-verification-challenge.ts
+import { createHash } from "crypto";
+var ChallengeError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "ChallengeError";
+    this.code = code;
+  }
+};
+function hashPincode(pincode, salt) {
+  return createHash("sha256").update(`${salt}${pincode}`).digest("hex");
+}
+function generateResponse(pincode, salt, challenge) {
+  const hashedPincode = hashPincode(pincode, salt);
+  return createHash("sha256").update(`${hashedPincode}_${challenge}`).digest("hex");
+}
+async function handleWalletVerificationChallenge({
+  portalClient,
+  portalGraphql,
+  verificationId,
+  userWalletAddress,
+  code,
+  verificationType
+}) {
+  try {
+    if (verificationType === "otp") {
+      return {
+        challengeResponse: code.toString(),
+        verificationId
+      };
+    }
+    if (verificationType === "secret-code") {
+      const formattedCode = code.toString().replace(/(.{5})(?=.)/, "$1-");
+      return {
+        challengeResponse: formattedCode,
+        verificationId
+      };
+    }
+    const verificationChallenges = await portalClient.request(
+      portalGraphql(`
+        mutation CreateWalletVerificationChallenges($userWalletAddress: String!, $verificationId: String!) {
+          createWalletVerificationChallenges(userWalletAddress: $userWalletAddress, verificationId: $verificationId) {
+            challenge
+            id
+            name
+            verificationType
+          }
+        }
+      `),
+      {
+        userWalletAddress,
+        verificationId
+      }
+    );
+    if (!verificationChallenges.createWalletVerificationChallenges?.length) {
+      throw new ChallengeError("No verification challenges received", "NO_CHALLENGES");
+    }
+    const walletVerificationChallenge = verificationChallenges.createWalletVerificationChallenges.find(
+      (challenge) => challenge.id === verificationId
+    );
+    if (!walletVerificationChallenge?.challenge?.secret || !walletVerificationChallenge?.challenge?.salt) {
+      throw new ChallengeError("Invalid challenge format", "INVALID_CHALLENGE");
+    }
+    const { secret, salt } = walletVerificationChallenge.challenge;
+    const challengeResponse = generateResponse(code.toString(), salt, secret);
+    return {
+      challengeResponse,
+      verificationId
+    };
+  } catch (error) {
+    if (error instanceof ChallengeError) {
+      throw error;
+    }
+    throw new ChallengeError("Failed to process wallet verification challenge", "CHALLENGE_PROCESSING_ERROR");
+  }
+}
+
+// src/portal.ts
+var ClientOptionsSchema = z.object({
+  instance: UrlOrPathSchema,
+  accessToken: ApplicationAccessTokenSchema.optional(),
+  cache: z.enum(["default", "force-cache", "no-cache", "no-store", "only-if-cached", "reload"]).optional()
+});
+function createPortalClient(options, clientOptions) {
+  ensureServer();
+  const validatedOptions = validate(ClientOptionsSchema, options);
+  const graphql = initGraphQLTada();
+  const fullUrl = new URL(validatedOptions.instance).toString();
+  return {
+    client: new GraphQLClient(fullUrl, {
+      ...clientOptions,
+      headers: appendHeaders(clientOptions?.headers, { "x-auth-token": validatedOptions.accessToken })
+    }),
+    graphql
+  };
+}
+export {
+  ClientOptionsSchema,
+  createPortalClient,
+  getWebsocketClient,
+  handleWalletVerificationChallenge,
+  readFragment,
+  waitForTransactionReceipt
+};
+//# sourceMappingURL=portal.mjs.map