@metamask/smart-accounts-kit 1.0.0 → 1.2.0

package/dist/{chunk-YTELOQ4I.mjs → chunk-VJXM3LWA.mjs}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-C5ZEEH2Z.mjs";
+} from "./chunk-ZA2XYCVX.mjs";
 
 // src/DelegationFramework/ERC20PeriodTransferEnforcer/index.ts
 var ERC20PeriodTransferEnforcer_exports = {};
@@ -296,4 +296,4 @@ export {
   read_exports5,
   NativeTokenStreamingEnforcer_exports
 };
-//# sourceMappingURL=chunk-YTELOQ4I.mjs.map
+//# sourceMappingURL=chunk-VJXM3LWA.mjs.map

package/dist/{chunk-WV2R7BXP.mjs → chunk-YTNCEXUX.mjs}

@@ -1,10 +1,10 @@
 import {
   encodeExecutionCalldata
-} from "./chunk-TPBFVDVM.mjs";
+} from "./chunk-4QXIOE7F.mjs";
 import {
   __export,
   toDelegationStruct
-} from "./chunk-C5ZEEH2Z.mjs";
+} from "./chunk-ZA2XYCVX.mjs";
 
 // src/DelegationFramework/utils.ts
 import { ERC1967Proxy } from "@metamask/delegation-abis";
@@ -827,4 +827,4 @@ export {
   execute6,
   encode_exports4
 };
-//# sourceMappingURL=chunk-WV2R7BXP.mjs.map
+//# sourceMappingURL=chunk-YTNCEXUX.mjs.map

package/dist/{chunk-C5ZEEH2Z.mjs → chunk-ZA2XYCVX.mjs}

@@ -999,8 +999,8 @@ var timestamp = "timestamp";
 var timestampBuilder = (environment, config) => {
   const { afterThreshold, beforeThreshold } = config;
   const terms = createTimestampTerms({
-    timestampAfterThreshold: afterThreshold,
-    timestampBeforeThreshold: beforeThreshold
+    afterThreshold,
+    beforeThreshold
   });
   const {
     caveatEnforcers: { TimestampEnforcer }
@@ -1354,6 +1354,39 @@ var resolveCaveats = ({
 };
 
 // src/caveats.ts
+import {
+  decodeAllowedCalldataTerms,
+  decodeERC20StreamingTerms,
+  decodeERC20TransferAmountTerms,
+  decodeERC20BalanceChangeTerms,
+  decodeAllowedMethodsTerms,
+  decodeAllowedTargetsTerms,
+  decodeArgsEqualityCheckTerms,
+  decodeBlockNumberTerms,
+  decodeDeployedTerms,
+  decodeERC721BalanceChangeTerms,
+  decodeERC721TransferTerms,
+  decodeERC1155BalanceChangeTerms,
+  decodeTimestampTerms,
+  decodeNonceTerms,
+  decodeValueLteTerms,
+  decodeLimitedCallsTerms,
+  decodeIdTerms,
+  decodeNativeTokenTransferAmountTerms,
+  decodeNativeBalanceChangeTerms,
+  decodeNativeTokenStreamingTerms,
+  decodeNativeTokenPaymentTerms,
+  decodeRedeemerTerms,
+  decodeSpecificActionERC20TransferBatchTerms,
+  decodeNativeTokenPeriodTransferTerms,
+  decodeERC20TokenPeriodTransferTerms,
+  decodeExactExecutionTerms,
+  decodeExactCalldataTerms,
+  decodeExactCalldataBatchTerms,
+  decodeExactExecutionBatchTerms,
+  decodeMultiTokenPeriodTerms,
+  decodeOwnershipTransferTerms
+} from "@metamask/delegation-core";
 import {
   encodeAbiParameters,
   parseAbiParameters,
@@ -1368,11 +1401,132 @@ var CAVEAT_ABI_TYPE_COMPONENTS = [
 var CAVEAT_TYPEHASH = keccak256(
   toHex2("Caveat(address enforcer,bytes terms)")
 );
-var createCaveat = (enforcer, terms, args = "0x00") => ({
-  enforcer,
-  terms,
-  args
-});
+var createCaveat = (enforcer, terms, args = "0x00") => {
+  return {
+    enforcer,
+    terms,
+    args
+  };
+};
+var decodeCaveat = ({
+  caveat: { enforcer, terms },
+  environment: { caveatEnforcers }
+}) => {
+  switch (enforcer.toLowerCase()) {
+    case caveatEnforcers.AllowedCalldataEnforcer?.toLowerCase():
+      return { type: "allowedCalldata", ...decodeAllowedCalldataTerms(terms) };
+    case caveatEnforcers.AllowedMethodsEnforcer?.toLowerCase():
+      return { type: "allowedMethods", ...decodeAllowedMethodsTerms(terms) };
+    case caveatEnforcers.AllowedTargetsEnforcer?.toLowerCase():
+      return { type: "allowedTargets", ...decodeAllowedTargetsTerms(terms) };
+    case caveatEnforcers.ArgsEqualityCheckEnforcer?.toLowerCase():
+      return {
+        type: "argsEqualityCheck",
+        ...decodeArgsEqualityCheckTerms(terms)
+      };
+    case caveatEnforcers.BlockNumberEnforcer?.toLowerCase():
+      return { type: "blockNumber", ...decodeBlockNumberTerms(terms) };
+    case caveatEnforcers.DeployedEnforcer?.toLowerCase():
+      return { type: "deployed", ...decodeDeployedTerms(terms) };
+    case caveatEnforcers.ERC20BalanceChangeEnforcer?.toLowerCase():
+      return {
+        type: "erc20BalanceChange",
+        ...decodeERC20BalanceChangeTerms(terms)
+      };
+    case caveatEnforcers.ERC20TransferAmountEnforcer?.toLowerCase():
+      return {
+        type: "erc20TransferAmount",
+        ...decodeERC20TransferAmountTerms(terms)
+      };
+    case caveatEnforcers.ERC20StreamingEnforcer?.toLowerCase():
+      return { type: "erc20Streaming", ...decodeERC20StreamingTerms(terms) };
+    case caveatEnforcers.ERC721BalanceChangeEnforcer?.toLowerCase():
+      return {
+        type: "erc721BalanceChange",
+        ...decodeERC721BalanceChangeTerms(terms)
+      };
+    case caveatEnforcers.ERC721TransferEnforcer?.toLowerCase():
+      return { type: "erc721Transfer", ...decodeERC721TransferTerms(terms) };
+    case caveatEnforcers.ERC1155BalanceChangeEnforcer?.toLowerCase():
+      return {
+        type: "erc1155BalanceChange",
+        ...decodeERC1155BalanceChangeTerms(terms)
+      };
+    case caveatEnforcers.IdEnforcer?.toLowerCase():
+      return { type: "id", ...decodeIdTerms(terms) };
+    case caveatEnforcers.LimitedCallsEnforcer?.toLowerCase():
+      return { type: "limitedCalls", ...decodeLimitedCallsTerms(terms) };
+    case caveatEnforcers.NonceEnforcer?.toLowerCase():
+      return { type: "nonce", ...decodeNonceTerms(terms) };
+    case caveatEnforcers.TimestampEnforcer?.toLowerCase():
+      return { type: "timestamp", ...decodeTimestampTerms(terms) };
+    case caveatEnforcers.ValueLteEnforcer?.toLowerCase():
+      return { type: "valueLte", ...decodeValueLteTerms(terms) };
+    case caveatEnforcers.NativeTokenTransferAmountEnforcer?.toLowerCase():
+      return {
+        type: "nativeTokenTransferAmount",
+        ...decodeNativeTokenTransferAmountTerms(terms)
+      };
+    case caveatEnforcers.NativeBalanceChangeEnforcer?.toLowerCase():
+      return {
+        type: "nativeBalanceChange",
+        ...decodeNativeBalanceChangeTerms(terms)
+      };
+    case caveatEnforcers.NativeTokenStreamingEnforcer?.toLowerCase():
+      return {
+        type: "nativeTokenStreaming",
+        ...decodeNativeTokenStreamingTerms(terms)
+      };
+    case caveatEnforcers.NativeTokenPaymentEnforcer?.toLowerCase():
+      return {
+        type: "nativeTokenPayment",
+        ...decodeNativeTokenPaymentTerms(terms)
+      };
+    case caveatEnforcers.RedeemerEnforcer?.toLowerCase():
+      return { type: "redeemer", ...decodeRedeemerTerms(terms) };
+    case caveatEnforcers.SpecificActionERC20TransferBatchEnforcer?.toLowerCase():
+      return {
+        type: "specificActionERC20TransferBatch",
+        ...decodeSpecificActionERC20TransferBatchTerms(terms)
+      };
+    case caveatEnforcers.ERC20PeriodTransferEnforcer?.toLowerCase():
+      return {
+        type: "erc20PeriodTransfer",
+        ...decodeERC20TokenPeriodTransferTerms(terms)
+      };
+    case caveatEnforcers.NativeTokenPeriodTransferEnforcer?.toLowerCase():
+      return {
+        type: "nativeTokenPeriodTransfer",
+        ...decodeNativeTokenPeriodTransferTerms(terms)
+      };
+    case caveatEnforcers.ExactCalldataBatchEnforcer?.toLowerCase():
+      return {
+        type: "exactCalldataBatch",
+        ...decodeExactCalldataBatchTerms(terms)
+      };
+    case caveatEnforcers.ExactCalldataEnforcer?.toLowerCase():
+      return { type: "exactCalldata", ...decodeExactCalldataTerms(terms) };
+    case caveatEnforcers.ExactExecutionEnforcer?.toLowerCase():
+      return { type: "exactExecution", ...decodeExactExecutionTerms(terms) };
+    case caveatEnforcers.ExactExecutionBatchEnforcer?.toLowerCase():
+      return {
+        type: "exactExecutionBatch",
+        ...decodeExactExecutionBatchTerms(terms)
+      };
+    case caveatEnforcers.MultiTokenPeriodEnforcer?.toLowerCase():
+      return {
+        type: "multiTokenPeriod",
+        ...decodeMultiTokenPeriodTerms(terms)
+      };
+    case caveatEnforcers.OwnershipTransferEnforcer?.toLowerCase():
+      return {
+        type: "ownershipTransfer",
+        ...decodeOwnershipTransferTerms(terms)
+      };
+    default:
+      throw new Error(`Unknown enforcer address: ${enforcer}`);
+  }
+};
 
 // src/delegation.ts
 import {
@@ -1388,6 +1542,317 @@ import {
 } from "@metamask/delegation-core";
 import { toHex as toHex3, getAddress, isHex as isHex5 } from "viem";
 import { signTypedData } from "viem/accounts";
+
+// src/analytics/index.ts
+import createClient from "openapi-fetch";
+
+// src/analytics/environment.ts
+var session;
+function createAnonId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `00000000-0000-4000-8000-${Math.random().toString(16).slice(2, 14).padEnd(12, "0")}`;
+}
+function inferPlatform() {
+  if (typeof globalThis === "undefined" || !("window" in globalThis)) {
+    return "nodejs";
+  }
+  const nav = globalThis.navigator;
+  const ua = typeof nav?.userAgent === "string" ? nav.userAgent : "";
+  if (/Mobile|Android|iPhone|iPod|webOS|BlackBerry|IEMobile|Opera Mini/iu.test(ua)) {
+    return "web-mobile";
+  }
+  return "web-desktop";
+}
+function inferDomain() {
+  if (typeof globalThis !== "undefined" && "window" in globalThis) {
+    const win = globalThis;
+    const hostname = win.location?.hostname;
+    if (typeof hostname === "string" && hostname.length > 0) {
+      return { domain: hostname };
+    }
+  }
+  return {};
+}
+function getInitializationContext(params) {
+  if (!session) {
+    session = {
+      sdk_version: params.sdk_version,
+      anon_id: params.anon_id ?? createAnonId(),
+      platform: inferPlatform(),
+      ...inferDomain()
+    };
+    return { ...session };
+  }
+  session = {
+    ...session,
+    sdk_version: params.sdk_version
+  };
+  return { ...session };
+}
+function getSessionBaseProperties() {
+  if (!session) {
+    throw new Error(
+      "Smart Accounts Kit analytics: call getInitializationContext({ sdk_version }) at SDK startup before recording events."
+    );
+  }
+  return { ...session };
+}
+function mergeSessionProperties(partial) {
+  if (!session) {
+    throw new Error(
+      "Smart Accounts Kit analytics: call getInitializationContext before mergeSessionProperties."
+    );
+  }
+  session = { ...session, ...partial };
+}
+
+// src/analytics/sender.ts
+var Sender = class {
+  #sendFn;
+  #batchSize;
+  #baseTimeoutMs;
+  #maxFailureCount;
+  #maxTimeoutMs;
+  #isDisabled = false;
+  #batch = [];
+  #failureCount = 0;
+  #timeoutId = null;
+  #isSending = false;
+  constructor(options) {
+    this.#batchSize = options.batchSize;
+    this.#baseTimeoutMs = options.baseTimeoutMs;
+    this.#maxFailureCount = options.maxFailureCount;
+    this.#sendFn = options.sendFn;
+    this.#maxTimeoutMs = options.maxTimeoutMs;
+  }
+  enqueue(item) {
+    if (this.#isDisabled) {
+      return;
+    }
+    this.#batch.push(item);
+    this.#schedule();
+  }
+  #schedule() {
+    if (this.#isDisabled) {
+      return;
+    }
+    if (this.#batch.length > 0 && !this.#timeoutId) {
+      const { isRetry, timeoutMs } = this.#getTimeout();
+      const timeout = setTimeout(() => {
+        this.#timeoutId = null;
+        this.#flush();
+      }, timeoutMs);
+      if (isRetry && timeout.unref) {
+        timeout.unref();
+      }
+      this.#timeoutId = timeout;
+    }
+  }
+  async #flush() {
+    if (this.#isDisabled || this.#isSending || this.#batch.length === 0) {
+      return;
+    }
+    this.#isSending = true;
+    const current = this.#batch.slice(0, this.#batchSize);
+    this.#batch = this.#batch.slice(this.#batchSize);
+    try {
+      await this.#sendFn(current);
+      this.#failureCount = 0;
+    } catch {
+      this.#failureCount += 1;
+      if (this.#failureCount >= this.#maxFailureCount) {
+        this.#isDisabled = true;
+        this.#batch = [];
+        if (this.#timeoutId !== null) {
+          clearTimeout(this.#timeoutId);
+          this.#timeoutId = null;
+        }
+      } else {
+        this.#batch = [...current, ...this.#batch];
+      }
+    } finally {
+      this.#isSending = false;
+      this.#schedule();
+    }
+  }
+  #getTimeout() {
+    const isRetry = this.#failureCount > 0;
+    const timeoutMs = Math.min(
+      this.#baseTimeoutMs * 2 ** this.#failureCount,
+      this.#maxTimeoutMs
+    );
+    return { isRetry, timeoutMs };
+  }
+};
+
+// package.json
+var version = "1.2.0";
+
+// src/analytics/index.ts
+function isCompleteBase(value) {
+  return typeof value.sdk_version === "string" && value.sdk_version.length > 0 && typeof value.anon_id === "string" && value.anon_id.length > 0 && typeof value.platform === "string" && value.platform.length > 0;
+}
+function normalise(batch) {
+  const walk = (value) => {
+    if (typeof value === "bigint") {
+      return `${value}n`;
+    }
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => walk(item));
+    }
+    const result = {};
+    for (const [key, child] of Object.entries(
+      value
+    )) {
+      result[key] = walk(child);
+    }
+    return result;
+  };
+  return walk(batch);
+}
+var METAMASK_ANALYTICS_ENDPOINT = "https://mm-sdk-analytics.api.cx.metamask.io/";
+var Analytics = class {
+  enabled = false;
+  sender;
+  constructor(baseUrl) {
+    const client = createClient({ baseUrl });
+    const sendFn = async (batch) => {
+      const normalisedBatch = normalise(batch);
+      const res = await client.POST("/v2/events", { body: normalisedBatch });
+      if (res.response.status !== 200) {
+        throw new Error(String(res.error));
+      }
+    };
+    this.sender = new Sender({
+      batchSize: 100,
+      baseTimeoutMs: 100,
+      maxFailureCount: 6,
+      maxTimeoutMs: 1e4,
+      sendFn
+    });
+  }
+  enable() {
+    this.enabled = true;
+  }
+  /**
+   * Merges a field into the session base (shared with {@link getSessionBaseProperties}).
+   *
+   * @param key - Base property name.
+   * @param value - Value for that property.
+   */
+  setGlobalProperty(key, value) {
+    mergeSessionProperties({
+      [key]: value
+    });
+  }
+  /**
+   * Sends `smart_accounts_kit_initialized` using the session base from {@link getInitializationContext}
+   * plus optional per-event overrides. Updates the stored session with the merged snapshot.
+   *
+   * @param properties - Optional overrides; omit to use the current session base only.
+   */
+  trackInitialized(properties = {}) {
+    if (!this.enabled) {
+      return;
+    }
+    const merged = {
+      ...getSessionBaseProperties(),
+      ...properties
+    };
+    if (!isCompleteBase(merged)) {
+      throw new Error(
+        "Analytics: trackInitialized produced incomplete base configuration (ensure getInitializationContext ran and sdk_version, anon_id, platform are set)"
+      );
+    }
+    mergeSessionProperties(merged);
+    const event = {
+      namespace: "metamask/smart-accounts-kit",
+      event_name: "smart_accounts_kit_initialized",
+      properties: merged
+    };
+    this.sender.enqueue(event);
+  }
+  /**
+   * Sends `smart_accounts_kit_function_called` with session base plus the function name and optional
+   * non-sensitive parameters. Does not mutate the session store (unlike {@link trackInitialized}).
+   *
+   * @param functionName - Public SDK entry name (use a stable string, e.g. `createDelegation`).
+   * @param parameters - Safe primitives only; omit secrets, keys, and raw addresses if sensitive.
+   * @param baseOverrides - Optional overrides for base fields (same as {@link trackInitialized}).
+   */
+  trackSdkFunctionCall(functionName, parameters, baseOverrides = {}) {
+    if (!this.enabled) {
+      return;
+    }
+    const mergedBase = {
+      ...getSessionBaseProperties(),
+      ...baseOverrides
+    };
+    if (!isCompleteBase(mergedBase)) {
+      throw new Error(
+        "Analytics: trackSdkFunctionCall requires session (call getInitializationContext before tracking)"
+      );
+    }
+    const props = {
+      ...mergedBase,
+      function_name: functionName,
+      ...parameters !== void 0 && Object.keys(parameters).length > 0 ? { parameters } : {}
+    };
+    const event = {
+      namespace: "metamask/smart-accounts-kit",
+      event_name: "smart_accounts_kit_function_called",
+      properties: props
+    };
+    this.sender.enqueue(event);
+  }
+};
+var analytics = new Analytics(METAMASK_ANALYTICS_ENDPOINT);
+function isAnalyticsDisabled() {
+  const dntValues = [];
+  if (typeof process !== "undefined") {
+    dntValues.push(process.env?.CI);
+    dntValues.push(process.env?.DO_NOT_TRACK);
+  }
+  if (typeof navigator !== "undefined") {
+    dntValues.push(navigator.doNotTrack);
+  }
+  if (typeof window !== "undefined") {
+    dntValues.push(window.doNotTrack);
+  }
+  return dntValues.some(
+    (dntValue) => dntValue === "1" || dntValue?.toLowerCase() === "yes" || dntValue?.toLowerCase() === "true"
+  );
+}
+var hasBootstrapped = false;
+function ensureSmartAccountsKitAnalyticsBootstrapped() {
+  if (hasBootstrapped) {
+    return;
+  }
+  hasBootstrapped = true;
+  if (isAnalyticsDisabled()) {
+    return;
+  }
+  try {
+    getInitializationContext({ sdk_version: version });
+    analytics.enable();
+    analytics.trackInitialized();
+  } catch {
+  }
+}
+function trackSmartAccountsKitFunctionCall(functionName, parameters) {
+  ensureSmartAccountsKitAnalyticsBootstrapped();
+  try {
+    analytics.trackSdkFunctionCall(functionName, parameters);
+  } catch {
+  }
+}
+
+// src/delegation.ts
 var DELEGATION_ABI_TYPE_COMPONENTS = [
   { type: "address", name: "delegate" },
   { type: "address", name: "delegator" },
@@ -1482,22 +1947,58 @@ var resolveAuthority = (parentDelegation) => {
   }
   return hashDelegation(parentDelegation);
 };
+var getCaveatNames = ({
+  caveats,
+  environment: { caveatEnforcers }
+}) => {
+  if (Array.isArray(caveats)) {
+    const knownEnforcers = Object.entries(caveatEnforcers).map(
+      ([name, address]) => ({ name, address: address.toLowerCase() })
+    );
+    return caveats.map((caveat) => {
+      const enforcerAddressLowercase = caveat.enforcer?.toLowerCase();
+      const matchingCaveat = knownEnforcers.find(
+        ({ address }) => address === enforcerAddressLowercase
+      );
+      return matchingCaveat?.name ?? "Unknown";
+    });
+  }
+  return [];
+};
 var createDelegation = (options) => {
+  const caveats = resolveCaveats(options);
+  trackSmartAccountsKitFunctionCall("createDelegation", {
+    hasParentDelegation: options.parentDelegation !== void 0,
+    scope: options.scope.type,
+    caveatNames: getCaveatNames({
+      caveats,
+      environment: options.environment
+    })
+  });
   return {
     delegate: options.to,
     delegator: options.from,
     authority: resolveAuthority(options.parentDelegation),
-    caveats: resolveCaveats(options),
+    caveats,
     salt: options.salt ?? "0x00",
     signature: "0x"
   };
 };
 var createOpenDelegation = (options) => {
+  const caveats = resolveCaveats(options);
+  trackSmartAccountsKitFunctionCall("createOpenDelegation", {
+    hasParentDelegation: options.parentDelegation !== void 0,
+    scope: options.scope.type,
+    caveatNames: getCaveatNames({
+      caveats,
+      environment: options.environment
+    })
+  });
   return {
     delegate: ANY_BENEFICIARY,
     delegator: options.from,
     authority: resolveAuthority(options.parentDelegation),
-    caveats: resolveCaveats(options),
+    caveats,
     salt: options.salt ?? "0x00",
     signature: "0x"
   };
@@ -1507,7 +2008,7 @@ var prepareSignDelegationTypedData = ({
   delegationManager,
   chainId,
   name = "DelegationManager",
-  version = "1",
+  version: version2 = "1",
   allowInsecureUnrestrictedDelegation = false
 }) => {
   const delegationStruct = toDelegationStruct({
@@ -1523,7 +2024,7 @@ var prepareSignDelegationTypedData = ({
     domain: {
       chainId,
       name,
-      version,
+      version: version2,
       verifyingContract: delegationManager
     },
     types: SIGNABLE_DELEGATION_TYPED_DATA,
@@ -1537,7 +2038,7 @@ var signDelegation = async ({
   delegationManager,
   chainId,
   name = "DelegationManager",
-  version = "1",
+  version: version2 = "1",
   allowInsecureUnrestrictedDelegation = false
 }) => {
   const typedData = prepareSignDelegationTypedData({
@@ -1545,7 +2046,7 @@ var signDelegation = async ({
     delegationManager,
     chainId,
     name,
-    version,
+    version: version2,
     allowInsecureUnrestrictedDelegation
   });
   return signTypedData({
@@ -1556,6 +2057,7 @@ var signDelegation = async ({
 
 export {
   __export,
+  trackSmartAccountsKitFunctionCall,
   Implementation,
   TransferWindow,
   ScopeType,
@@ -1566,6 +2068,7 @@ export {
   isDefined,
   toHexOrThrow,
   createCaveat,
+  decodeCaveat,
   ANY_BENEFICIARY,
   DELEGATION_TYPEHASH,
   ROOT_AUTHORITY,
@@ -1585,4 +2088,4 @@ export {
   prepareSignDelegationTypedData,
   signDelegation
 };
-//# sourceMappingURL=chunk-C5ZEEH2Z.mjs.map
+//# sourceMappingURL=chunk-ZA2XYCVX.mjs.map