@settlemint/dalp-sdk 3.1.18-main.33808370488 → 3.1.18

package/dist/auth.js

@@ -1,329 +0,0 @@
-import {
-  SDK_USER_AGENT,
-  createCookieStoreFetch,
-  makeCookieStore
-} from "./chunk-qp5ty384.js";
-import {
-  normalizeDalpBaseUrl,
-  secret,
-  unwrapSecret
-} from "./chunk-h12fatty.js";
-import {
-  createDalpSdkConfigurationError
-} from "./chunk-y0d2c7kp.js";
-
-// src/auth/live.ts
-import { apiKeyClient } from "@better-auth/api-key/client";
-import { passkeyClient } from "@better-auth/passkey/client";
-import { createAuthClient as createBetterAuthClient } from "better-auth/client";
-import {
-  adminClient,
-  customSessionClient,
-  deviceAuthorizationClient,
-  inferAdditionalFields,
-  organizationClient,
-  twoFactorClient
-} from "better-auth/client/plugins";
-
-// src/auth/client.ts
-class AuthConfigError extends Error {
-  constructor(field, requirement) {
-    super(`\`${field}\` ${requirement}`);
-    this.name = "AuthConfigError";
-  }
-}
-function optionalText(value, field) {
-  if (value === undefined) {
-    return;
-  }
-  if (typeof value !== "string") {
-    return handleNonString(field);
-  }
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    throw new AuthConfigError(field, "must not be blank");
-  }
-  return trimmed;
-}
-function handleNonString(field) {
-  throw new AuthConfigError(field, "must be a string");
-}
-function requiredUrl(value) {
-  if (typeof value !== "string") {
-    return handleNonString("url");
-  }
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new AuthConfigError("url", "must be a valid URL");
-  }
-  if (!["http:", "https:"].includes(parsed.protocol)) {
-    throw new AuthConfigError("url", "must use http or https");
-  }
-  return value;
-}
-function optionalHeaders(value) {
-  if (value === undefined) {
-    return;
-  }
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new AuthConfigError("headers", "must be an object of strings");
-  }
-  const headers = {};
-  for (const [name, header] of Object.entries(value)) {
-    if (typeof header !== "string") {
-      throw new AuthConfigError("headers", "must be an object of strings");
-    }
-    headers[name] = header;
-  }
-  return headers;
-}
-function optionalFetch(value) {
-  if (value === undefined) {
-    return;
-  }
-  if (typeof value !== "function") {
-    throw new AuthConfigError("fetch", "must be a function");
-  }
-  return value;
-}
-function optionalCookieStore(value) {
-  if (value === undefined) {
-    return;
-  }
-  const store = value;
-  if (typeof value !== "object" || value === null || typeof store.header !== "function" || typeof store.storeSetCookieHeaders !== "function") {
-    throw new AuthConfigError("cookieStore", "must expose header and storeSetCookieHeaders");
-  }
-  return store;
-}
-function decodeAuthConfig(input) {
-  const raw = input;
-  const apiKey = optionalText(raw.apiKey, "apiKey");
-  const sessionToken = optionalText(raw.sessionToken, "sessionToken");
-  const cookie = optionalText(raw.cookie, "cookie");
-  if ([apiKey, sessionToken, cookie].filter((credential) => credential !== undefined).length > 1) {
-    throw new AuthConfigError("apiKey/sessionToken/cookie", "configure only one auth credential source");
-  }
-  const url = requiredUrl(raw.url);
-  const cookieStore = optionalCookieStore(raw.cookieStore);
-  const organizationId = optionalText(raw.organizationId, "organizationId");
-  const headers = optionalHeaders(raw.headers);
-  const configuredFetch = optionalFetch(raw.fetch);
-  return {
-    url,
-    ...apiKey === undefined ? {} : { apiKey: secret(apiKey) },
-    ...sessionToken === undefined ? {} : { sessionToken: secret(sessionToken) },
-    ...cookie === undefined ? {} : { cookie: secret(cookie) },
-    ...cookieStore === undefined ? {} : { cookieStore },
-    ...organizationId === undefined ? {} : { organizationId },
-    ...headers === undefined ? {} : { headers },
-    ...configuredFetch === undefined ? {} : { fetch: configuredFetch }
-  };
-}
-async function decodeDalpAuthClientConfig(input) {
-  try {
-    return decodeAuthConfig(input);
-  } catch (error) {
-    throw createDalpSdkConfigurationError({
-      message: "DALP SDK: auth client configuration is invalid.",
-      why: "The auth client received a malformed URL, credential, header map, fetch seam, or cookie store.",
-      fix: "Pass one credential source, an HTTP(S) URL, and valid fetch and cookie-store seams.",
-      cause: error
-    });
-  }
-}
-
-// src/auth/permissions.ts
-import { createAccessControl } from "better-auth/plugins/access";
-import { adminAc, defaultStatements as adminDefaultStatements } from "better-auth/plugins/admin/access";
-import {
-  memberAc,
-  defaultStatements as organizationDefaultStatements,
-  ownerAc
-} from "better-auth/plugins/organization/access";
-var dalPermissions = {
-  organization: ["update", "delete", "list"],
-  setting: ["read", "list", "upsert", "remove", "set-global-theme"],
-  system: ["read", "list", "create"],
-  exchangeRates: ["read", "list"]
-};
-var customPermissions = {
-  ...adminDefaultStatements,
-  ...organizationDefaultStatements,
-  ...dalPermissions
-};
-var narrowAccessControl = createAccessControl(customPermissions);
-var accessControl = createAccessControl({
-  ...adminDefaultStatements,
-  ...organizationDefaultStatements,
-  ...dalPermissions
-});
-var adminRole = narrowAccessControl.newRole({
-  ...adminAc.statements,
-  ...ownerAc.statements,
-  organization: ["update", "delete", "list"],
-  setting: ["read", "list", "upsert", "remove", "set-global-theme"],
-  system: ["read", "list", "create"],
-  exchangeRates: ["read", "list"]
-});
-var ownerRole = narrowAccessControl.newRole({
-  ...ownerAc.statements,
-  user: ["list", "get", "update"],
-  setting: ["read", "list", "upsert", "remove"],
-  system: ["read", "list", "create"],
-  exchangeRates: ["read", "list"]
-});
-var memberRole = narrowAccessControl.newRole({
-  ...memberAc.statements,
-  setting: ["read", "list"],
-  system: ["read", "list"],
-  exchangeRates: ["read", "list"]
-});
-
-// src/auth/wallet-plugins.ts
-import { defineErrorCodes } from "better-auth";
-var WALLET_PINCODE_ERROR_CODES = defineErrorCodes({
-  WALLET_PINCODE_ALREADY_SET: "Wallet pincode already set",
-  WALLET_PINCODE_ALREADY_REMOVED: "Wallet pincode already removed",
-  WALLET_PINCODE_PASSWORD_REQUIRED: "Password is required",
-  WALLET_PINCODE_INVALID_PASSWORD: "Invalid password"
-});
-var WALLET_TWO_FACTOR_ERROR_CODES = defineErrorCodes({
-  WALLET_TWO_FACTOR_PASSWORD_REQUIRED: "Password is required",
-  WALLET_TWO_FACTOR_INVALID_PASSWORD: "Invalid password",
-  WALLET_TWO_FACTOR_INVALID_CODE: "Invalid two factor code"
-});
-var WALLET_SECRET_CODES_ERROR_CODES = defineErrorCodes({
-  WALLET_SECRET_CODES_PASSWORD_REQUIRED: "Password is required",
-  WALLET_SECRET_CODES_INVALID_PASSWORD: "Invalid password",
-  WALLET_SECRET_CODES_VERIFICATION_MISMATCH: "Secret codes verification mismatch"
-});
-var walletPincodeClient = () => ({
-  id: "wallet-pincode",
-  $InferServerPlugin: {
-    id: "wallet-pincode",
-    $ERROR_CODES: WALLET_PINCODE_ERROR_CODES,
-    endpoints: {}
-  },
-  $ERROR_CODES: WALLET_PINCODE_ERROR_CODES,
-  pathMethods: {
-    "/wallet/pincode/enable": "POST",
-    "/wallet/pincode/disable": "POST",
-    "/wallet/pincode/update": "POST",
-    "/wallet/pincode/reset": "POST"
-  },
-  atomListeners: [
-    {
-      matcher: (path) => path.startsWith("/wallet/pincode/"),
-      signal: "$sessionSignal"
-    }
-  ]
-});
-var walletTwoFactorClient = () => ({
-  id: "wallet-two-factor",
-  $InferServerPlugin: {
-    id: "wallet-two-factor",
-    $ERROR_CODES: WALLET_TWO_FACTOR_ERROR_CODES,
-    endpoints: {}
-  },
-  $ERROR_CODES: WALLET_TWO_FACTOR_ERROR_CODES,
-  pathMethods: {
-    "/wallet/two-factor/enable": "POST",
-    "/wallet/two-factor/disable": "POST",
-    "/wallet/two-factor/verify": "POST"
-  },
-  atomListeners: [
-    {
-      matcher: (path) => path.startsWith("/wallet/two-factor/"),
-      signal: "$sessionSignal"
-    }
-  ]
-});
-var walletSecretCodesClient = () => ({
-  id: "wallet-secret-codes",
-  $InferServerPlugin: {
-    id: "wallet-secret-codes",
-    $ERROR_CODES: WALLET_SECRET_CODES_ERROR_CODES,
-    endpoints: {}
-  },
-  $ERROR_CODES: WALLET_SECRET_CODES_ERROR_CODES,
-  pathMethods: {
-    "/wallet/secret-codes/generate": "POST",
-    "/wallet/secret-codes/confirm": "POST"
-  },
-  atomListeners: [
-    {
-      matcher: (path) => path.startsWith("/wallet/secret-codes/"),
-      signal: "$sessionSignal"
-    }
-  ]
-});
-
-// src/auth/live.ts
-var reservedHeaders = new Set(["x-api-key", "authorization", "cookie"]);
-function authHeaders(config) {
-  const headers = { "User-Agent": SDK_USER_AGENT };
-  for (const [name, value] of Object.entries(config.headers ?? {})) {
-    if (!reservedHeaders.has(name.toLowerCase())) {
-      headers[name] = value;
-    }
-  }
-  if (config.apiKey !== undefined) {
-    headers["x-api-key"] = unwrapSecret(config.apiKey);
-  }
-  if (config.sessionToken !== undefined) {
-    const token = unwrapSecret(config.sessionToken);
-    headers.authorization = token.toLowerCase().startsWith("bearer ") ? token : `Bearer ${token}`;
-  }
-  if (config.organizationId !== undefined) {
-    headers["x-organization-id"] = config.organizationId;
-  }
-  return headers;
-}
-function createConfiguredBetterAuthClient(config, cookieStore) {
-  return createBetterAuthClient({
-    baseURL: `${normalizeDalpBaseUrl(config.url)}/api/auth`,
-    fetchOptions: {
-      headers: authHeaders(config),
-      customFetchImpl: createCookieStoreFetch(cookieStore, config.fetch),
-      credentials: "include"
-    },
-    plugins: [
-      customSessionClient(),
-      inferAdditionalFields(),
-      adminClient({ ac: accessControl, roles: { admin: adminRole, owner: ownerRole, member: memberRole } }),
-      apiKeyClient(),
-      passkeyClient(),
-      walletPincodeClient(),
-      walletTwoFactorClient(),
-      walletSecretCodesClient(),
-      twoFactorClient({ onTwoFactorRedirect() {} }),
-      deviceAuthorizationClient(),
-      organizationClient({ ac: accessControl, roles: { owner: ownerRole, member: memberRole } })
-    ]
-  });
-}
-async function createDalpAuthClient(input) {
-  const config = await decodeDalpAuthClientConfig(input);
-  const cookieStore = config.cookieStore ?? makeCookieStore();
-  if (config.cookie !== undefined) {
-    cookieStore.setCookieHeader(unwrapSecret(config.cookie));
-  }
-  const credentialCount = [config.apiKey, config.sessionToken, cookieStore.isEmpty() ? undefined : true].filter(Boolean).length;
-  if (credentialCount > 1) {
-    throw createDalpSdkConfigurationError({
-      message: "DALP SDK: configure only one auth credential source.",
-      why: "The auth client received multiple credential types.",
-      fix: "Use an API key, bearer token, or cookie store, not a combination."
-    });
-  }
-  return createConfiguredBetterAuthClient(config, cookieStore);
-}
-var makeDalpAuthClient = createDalpAuthClient;
-export {
-  createDalpAuthClient,
-  decodeDalpAuthClientConfig,
-  makeDalpAuthClient
-};

package/dist/bundler.js

@@ -1,99 +0,0 @@
-import {
-  createDalpClient
-} from "./chunk-tmk1f2yb.js";
-import"./chunk-f4t1bm86.js";
-import"./chunk-def7rqy6.js";
-import"./chunk-fjnq61hj.js";
-import"./chunk-9k284df4.js";
-import"./chunk-h12fatty.js";
-import"./chunk-y0d2c7kp.js";
-
-// src/bundler.ts
-import { getAddress, hexToBigInt, isHex } from "viem";
-var responseData = (result) => {
-  const body = result !== null && typeof result === "object" ? Reflect.get(result, "data") : undefined;
-  const unwrapped = body ?? result;
-  return unwrapped !== null && typeof unwrapped === "object" ? unwrapped : {};
-};
-var requireHex = (value, field) => {
-  if (typeof value !== "string" || !isHex(value)) {
-    throw new TypeError(`DALP bundler response: ${field} must be an Ethereum hex value.`);
-  }
-  return value;
-};
-function createDalpBundlerClient(config) {
-  const client = createDalpClient({
-    baseUrl: config.url,
-    apiKey: config.apiKey,
-    context: { organizationId: config.organizationId },
-    fetch: config.fetch,
-    runtime: "server"
-  });
-  return {
-    async sendUserOperation(operation, entryPoint) {
-      const result = await client.execute("transactions/bundler/sendUserOperation", {
-        userOperation: operation,
-        entryPoint
-      });
-      return requireHex(responseData(result)["userOperationHash"], "userOperationHash");
-    },
-    async estimateUserOperationGas(operation, entryPoint) {
-      const result = await client.execute("transactions/bundler/estimateUserOperationGas", {
-        userOperation: operation,
-        entryPoint
-      });
-      const data = responseData(result);
-      return {
-        preVerificationGas: requireHex(data["preVerificationGas"], "preVerificationGas"),
-        verificationGasLimit: requireHex(data["verificationGasLimit"], "verificationGasLimit"),
-        callGasLimit: requireHex(data["callGasLimit"], "callGasLimit"),
-        ...data["paymasterVerificationGasLimit"] === undefined ? {} : {
-          paymasterVerificationGasLimit: requireHex(data["paymasterVerificationGasLimit"], "paymasterVerificationGasLimit")
-        },
-        ...data["paymasterPostOpGasLimit"] === undefined ? {} : { paymasterPostOpGasLimit: requireHex(data["paymasterPostOpGasLimit"], "paymasterPostOpGasLimit") }
-      };
-    },
-    async getUserOperationByHash(hash) {
-      const result = await client.execute("transactions/bundler/getUserOperationByHash", { userOperationHash: hash });
-      return responseData(result);
-    },
-    async getUserOperationReceipt(hash) {
-      const result = await client.execute("transactions/bundler/getUserOperationReceipt", { userOperationHash: hash });
-      return responseData(result);
-    },
-    async getSupportedEntryPoints() {
-      const result = await client.execute("transactions/bundler/getSupportedEntryPoints");
-      const entryPoints = responseData(result)["entryPoints"];
-      if (!Array.isArray(entryPoints)) {
-        throw new TypeError("DALP bundler response: entryPoints must be an array.");
-      }
-      return entryPoints.map((entryPoint) => {
-        if (typeof entryPoint !== "string") {
-          throw new TypeError("DALP bundler response: each entry point must be a string address.");
-        }
-        return getAddress(entryPoint);
-      });
-    },
-    async getChainId() {
-      const result = await client.execute("transactions/bundler/getChainId");
-      return hexToBigInt(requireHex(responseData(result)["chainId"], "chainId"));
-    },
-    async getPaymasterStubData(operation, entryPoint) {
-      const result = await client.execute("transactions/bundler/getPaymasterStubData", {
-        userOperation: operation,
-        entryPoint
-      });
-      return responseData(result);
-    },
-    async getPaymasterData(operation, entryPoint) {
-      const result = await client.execute("transactions/bundler/getPaymasterData", {
-        userOperation: operation,
-        entryPoint
-      });
-      return responseData(result);
-    }
-  };
-}
-export {
-  createDalpBundlerClient
-};