@paxoslabs/amplify-sdk 0.5.3 → 1.0.0

package/dist/chunk-QMFYPHX5.mjs

@@ -1,690 +0,0 @@
-import { resolveVault, VaultNotFoundByNameError } from './chunk-Y5LBT2WT.mjs';
-import { getRateInQuoteWithAssetDecimals, getErc20Decimals, BoringVaultAbi, AccountantAbi } from './chunk-UY2WD7MF.mjs';
-import { calculateExpectedSharesMinted } from './chunk-6CU533DM.mjs';
-import { toChainId, APIError, readSupplyCapInBase, readFeeModuleFromDCD, getClient, readDepositFeeStructure, getRestV2BaseURL, DEFAULT_TIMEOUT, getRequestHeaders, isValidAddress, getCache, WithdrawQueueAbi, FeeModuleAbi } from './chunk-ODXJYXUH.mjs';
-import { parseUnits, zeroAddress, maxUint256, erc20Abi } from 'viem';
-
-async function getMinimumMint(params) {
-  try {
-    const normalizedChainId = toChainId(params.chainId);
-    const config = await resolveVault({
-      vaultName: params.vaultName,
-      assetAddress: params.depositAssetAddress,
-      chainId: normalizedChainId,
-      callerEndpoint: "getMinimumMint"
-    });
-    if (!config.vault.accountantAddress) {
-      throw new APIError(
-        `Accountant contract address not configured for vault ${config.id}`,
-        { endpoint: "getMinimumMint" }
-      );
-    }
-    if (!config.vault.boringVaultAddress) {
-      throw new APIError(
-        `BoringVault contract address not configured for vault ${config.id}`,
-        { endpoint: "getMinimumMint" }
-      );
-    }
-    const rateResults = await getRateInQuoteWithAssetDecimals({
-      assetAddress: params.depositAssetAddress,
-      accountantAddress: config.vault.accountantAddress,
-      chainId: normalizedChainId
-    });
-    const [assetDecimalsResult, exchangeRateResult] = rateResults;
-    if (assetDecimalsResult.status === "failure" || exchangeRateResult.status === "failure") {
-      throw new APIError(
-        `Failed to get exchange rate or asset decimals: ${assetDecimalsResult.error?.message || exchangeRateResult.error?.message}`,
-        { endpoint: "getMinimumMint" }
-      );
-    }
-    const assetDecimals = assetDecimalsResult.result;
-    const exchangeRate = exchangeRateResult.result;
-    const shareDecimals = await getErc20Decimals({
-      tokenAddress: config.vault.boringVaultAddress,
-      chainId: normalizedChainId
-    });
-    const depositAmountBigInt = parseUnits(params.depositAmount, assetDecimals);
-    const expectedShares = calculateExpectedSharesMinted(
-      depositAmountBigInt,
-      exchangeRate,
-      shareDecimals
-    );
-    return {
-      expectedShares,
-      exchangeRate,
-      shareDecimals,
-      assetDecimals
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to calculate minimum mint: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "getMinimumMint", cause: error }
-    );
-  }
-}
-async function getDepositCap(params) {
-  try {
-    const normalizedChainId = toChainId(params.chainId);
-    const config = await resolveVault({
-      vaultName: params.vaultName,
-      assetAddress: params.assetAddress,
-      chainId: normalizedChainId,
-      callerEndpoint: "getDepositCap"
-    });
-    if (!config.vault.communityCodeDepositorAddress || !config.vault.depositFeeModuleAddress) {
-      throw new APIError(
-        `Deposit cap not available for vault ${config.id} \u2014 requires both CommunityCodeDepositor and deposit fee module`,
-        { endpoint: "getDepositCap" }
-      );
-    }
-    const [supplyCapInBase, depositFeeModuleAddress] = await Promise.all([
-      readSupplyCapInBase(
-        config.vault.communityCodeDepositorAddress,
-        normalizedChainId
-      ),
-      readFeeModuleFromDCD(
-        config.vault.communityCodeDepositorAddress,
-        normalizedChainId
-      )
-    ]);
-    return {
-      supplyCapInBase,
-      hasDepositCap: supplyCapInBase !== 0n && supplyCapInBase !== maxUint256,
-      depositFeeModuleAddress,
-      hasFees: depositFeeModuleAddress !== zeroAddress
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to get deposit cap: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "getDepositCap", cause: error }
-    );
-  }
-}
-async function getCurrentSupply(params) {
-  try {
-    const normalizedChainId = toChainId(params.chainId);
-    const config = await resolveVault({
-      vaultName: params.vaultName,
-      assetAddress: params.assetAddress,
-      chainId: normalizedChainId,
-      callerEndpoint: "getCurrentSupply"
-    });
-    if (!config.vault.boringVaultAddress) {
-      throw new APIError(
-        `BoringVault contract address not configured for vault ${config.id}`,
-        { endpoint: "getCurrentSupply" }
-      );
-    }
-    if (!config.vault.accountantAddress) {
-      throw new APIError(
-        `Accountant contract address not configured for vault ${config.id}`,
-        { endpoint: "getCurrentSupply" }
-      );
-    }
-    const client = await getClient(normalizedChainId);
-    const results = await client.multicall({
-      contracts: [
-        {
-          abi: BoringVaultAbi,
-          address: config.vault.boringVaultAddress,
-          functionName: "totalSupply"
-        },
-        {
-          abi: AccountantAbi,
-          address: config.vault.accountantAddress,
-          functionName: "getRate"
-        },
-        {
-          abi: AccountantAbi,
-          address: config.vault.accountantAddress,
-          functionName: "decimals"
-        }
-      ]
-    });
-    const [supplyResult, rateResult, decimalsResult] = results;
-    if (supplyResult.status === "failure" || rateResult.status === "failure" || decimalsResult.status === "failure") {
-      throw new APIError("Failed to read supply data from vault contracts", {
-        endpoint: "getCurrentSupply"
-      });
-    }
-    const totalShareSupply = supplyResult.result;
-    const exchangeRate = rateResult.result;
-    const accountantDecimals = decimalsResult.result;
-    const totalValueInBase = totalShareSupply * exchangeRate / BigInt(10 ** accountantDecimals);
-    return {
-      totalShareSupply,
-      exchangeRate,
-      accountantDecimals,
-      totalValueInBase
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to get current supply: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "getCurrentSupply", cause: error }
-    );
-  }
-}
-async function calculateDepositFee(params) {
-  try {
-    const normalizedChainId = toChainId(params.chainId);
-    const config = await resolveVault({
-      vaultName: params.vaultName,
-      assetAddress: params.assetAddress,
-      chainId: normalizedChainId,
-      callerEndpoint: "calculateDepositFee"
-    });
-    const depositFeeModuleAddress = config.vault.depositFeeModuleAddress ?? zeroAddress;
-    const hasFees = depositFeeModuleAddress !== zeroAddress;
-    if (!hasFees) {
-      const assetDecimals2 = await getErc20Decimals({
-        tokenAddress: params.assetAddress,
-        chainId: normalizedChainId
-      });
-      const depositAmountBigInt2 = parseUnits(
-        params.depositAmount,
-        assetDecimals2
-      );
-      return {
-        hasFees: false,
-        depositFeeModuleAddress,
-        feePercentage: 0n,
-        oneHundredPercent: 0n,
-        flatFee: 0n,
-        variableFeeAmount: 0n,
-        totalFeeAmount: 0n,
-        depositAmountAfterFees: depositAmountBigInt2,
-        assetDecimals: assetDecimals2
-      };
-    }
-    const assetDecimals = await getErc20Decimals({
-      tokenAddress: params.assetAddress,
-      chainId: normalizedChainId
-    });
-    const { feePercentage, flatFee, oneHundredPercent } = await readDepositFeeStructure(
-      depositFeeModuleAddress,
-      params.assetAddress,
-      normalizedChainId
-    );
-    const depositAmountBigInt = parseUnits(params.depositAmount, assetDecimals);
-    const variableFeeAmount = oneHundredPercent > 0n ? depositAmountBigInt * feePercentage / oneHundredPercent : 0n;
-    const totalFeeAmount = variableFeeAmount + flatFee;
-    const depositAmountAfterFees = depositAmountBigInt > totalFeeAmount ? depositAmountBigInt - totalFeeAmount : 0n;
-    return {
-      hasFees: true,
-      depositFeeModuleAddress,
-      feePercentage,
-      oneHundredPercent,
-      flatFee,
-      variableFeeAmount,
-      totalFeeAmount,
-      depositAmountAfterFees,
-      assetDecimals
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to calculate deposit fee: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "calculateDepositFee", cause: error }
-    );
-  }
-}
-async function getShareValue(params) {
-  try {
-    if (!params.userAddress && !params.shareAmount) {
-      throw new APIError(
-        "Either userAddress or shareAmount must be provided.",
-        { endpoint: "getShareValue" }
-      );
-    }
-    const normalizedChainId = toChainId(params.chainId);
-    const config = await resolveVault({
-      vaultName: params.vaultName,
-      assetAddress: params.quoteAssetAddress,
-      chainId: normalizedChainId,
-      callerEndpoint: "getShareValue"
-    });
-    if (!config.vault.accountantAddress) {
-      throw new APIError(
-        `Accountant contract address not configured for vault ${config.id}`,
-        { endpoint: "getShareValue" }
-      );
-    }
-    if (!config.vault.boringVaultAddress) {
-      throw new APIError(
-        `BoringVault contract address not configured for vault ${config.id}`,
-        { endpoint: "getShareValue" }
-      );
-    }
-    const client = await getClient(normalizedChainId);
-    const results = await client.multicall({
-      contracts: [
-        {
-          abi: erc20Abi,
-          address: params.quoteAssetAddress,
-          functionName: "decimals"
-        },
-        {
-          abi: BoringVaultAbi,
-          address: config.vault.boringVaultAddress,
-          functionName: "decimals"
-        },
-        {
-          abi: AccountantAbi,
-          address: config.vault.accountantAddress,
-          functionName: "getRateInQuote",
-          args: [params.quoteAssetAddress]
-        }
-      ]
-    });
-    const [quoteDecimalsResult, shareDecimalsResult, rateResult] = results;
-    if (quoteDecimalsResult.status === "failure" || shareDecimalsResult.status === "failure" || rateResult.status === "failure") {
-      throw new APIError(
-        "Failed to read share value data from vault contracts",
-        { endpoint: "getShareValue" }
-      );
-    }
-    const quoteAssetDecimals = quoteDecimalsResult.result;
-    const shareDecimals = shareDecimalsResult.result;
-    const exchangeRate = rateResult.result;
-    let shareBalance;
-    if (params.shareAmount) {
-      shareBalance = parseUnits(params.shareAmount, shareDecimals);
-    } else {
-      const [balanceResult] = await client.multicall({
-        contracts: [
-          {
-            abi: erc20Abi,
-            address: config.vault.boringVaultAddress,
-            functionName: "balanceOf",
-            args: [params.userAddress]
-          }
-        ]
-      });
-      if (balanceResult.status === "failure") {
-        throw new APIError(
-          `Failed to read balanceOf for ${params.userAddress}`,
-          { endpoint: "getShareValue" }
-        );
-      }
-      shareBalance = balanceResult.result;
-    }
-    const ONE_SHARE = BigInt(10) ** BigInt(shareDecimals);
-    const value = shareBalance * exchangeRate / ONE_SHARE;
-    return {
-      shareBalance,
-      value,
-      exchangeRate,
-      shareDecimals,
-      quoteAssetDecimals
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to get share value: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "getShareValue", cause: error }
-    );
-  }
-}
-
-// src/display/vault-display.ts
-async function resolveVaultAddressForDisplay(params, callerEndpoint) {
-  if (params.vaultAddress) {
-    if (!isValidAddress(params.vaultAddress)) {
-      throw new APIError(
-        `Invalid vaultAddress: ${params.vaultAddress}. Must be a valid Ethereum address.`,
-        { endpoint: callerEndpoint }
-      );
-    }
-    return params.vaultAddress;
-  }
-  if (params.vaultName) {
-    const cache = getCache();
-    if (cache.isEmpty() || cache.isExpired()) {
-      await cache.refresh();
-    }
-    const vault = cache.getVaultByName(params.vaultName);
-    if (!vault) {
-      throw new VaultNotFoundByNameError(
-        `No vault found with name "${params.vaultName}". The vault may not exist or may not be available for your organization.`,
-        { vaultName: params.vaultName, endpoint: callerEndpoint }
-      );
-    }
-    return vault.vault.boringVaultAddress;
-  }
-  throw new APIError("Either vaultAddress or vaultName must be provided.", {
-    endpoint: callerEndpoint
-  });
-}
-async function getVaultAPY(params) {
-  try {
-    const resolvedAddress = await resolveVaultAddressForDisplay(
-      params,
-      "getVaultAPY"
-    );
-    const queryParams = new URLSearchParams({
-      filter: `vaultAddress=${resolvedAddress}`,
-      orderByTimestamp: "desc",
-      pageSize: "1"
-    });
-    const url = `${getRestV2BaseURL()}/amplify/vaultApys?${queryParams.toString()}`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
-    const response = await fetch(url, {
-      method: "GET",
-      headers: getRequestHeaders(),
-      signal: controller.signal
-    });
-    clearTimeout(timeout);
-    if (!response.ok) {
-      throw new APIError(
-        `Failed to fetch vault APY: ${response.status} ${response.statusText}`,
-        { endpoint: "getVaultAPY", statusCode: response.status }
-      );
-    }
-    const data = await response.json();
-    if (!data.vaultApys || data.vaultApys.length === 0) {
-      throw new APIError(`No APY data found for vault ${resolvedAddress}`, {
-        endpoint: "getVaultAPY"
-      });
-    }
-    const latest = data.vaultApys[0];
-    const apyNumber = Number.parseFloat(latest.apy);
-    return {
-      apy: apyNumber,
-      apyFormatted: `${apyNumber.toFixed(2)}%`,
-      vaultAddress: latest.vaultAddress,
-      timestamp: latest.timestamp
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to fetch vault APY: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "getVaultAPY", cause: error }
-    );
-  }
-}
-async function getVaultTVL(params) {
-  try {
-    const resolvedAddress = await resolveVaultAddressForDisplay(
-      params,
-      "getVaultTVL"
-    );
-    const filterParts = [`vaultAddress=${resolvedAddress}`];
-    if (params.chainId !== void 0) {
-      filterParts.push(`chainId=${params.chainId}`);
-    }
-    const queryParams = new URLSearchParams({
-      filter: filterParts.join(" AND "),
-      includeCurrent: "true",
-      orderByTimestamp: "desc",
-      pageSize: "1"
-    });
-    const url = `${getRestV2BaseURL()}/amplify/vaultTvls?${queryParams.toString()}`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
-    const response = await fetch(url, {
-      method: "GET",
-      headers: getRequestHeaders(),
-      signal: controller.signal
-    });
-    clearTimeout(timeout);
-    if (!response.ok) {
-      throw new APIError(
-        `Failed to fetch vault TVL: ${response.status} ${response.statusText}`,
-        { endpoint: "getVaultTVL", statusCode: response.status }
-      );
-    }
-    const data = await response.json();
-    if (!data.vaultTvls || data.vaultTvls.length === 0) {
-      throw new APIError(`No TVL data found for vault ${resolvedAddress}`, {
-        endpoint: "getVaultTVL"
-      });
-    }
-    const latest = data.vaultTvls[0];
-    return {
-      tvl: latest.tvl,
-      tvlAsset: latest.tvlAsset,
-      vaultAddress: latest.vaultAddress,
-      chainId: latest.chainId,
-      timestamp: latest.timestamp
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to fetch vault TVL: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "getVaultTVL", cause: error }
-    );
-  }
-}
-function buildFilterString(params) {
-  return Object.entries(params).filter(([, v]) => v !== void 0).map(([k, v]) => `${k}=${v}`).join(" AND ");
-}
-async function getWithdrawalRequests(params) {
-  try {
-    if (!isValidAddress(params.userAddress)) {
-      throw new APIError(
-        `Invalid userAddress: ${params.userAddress}. Must be a valid Ethereum address.`,
-        { endpoint: "getWithdrawalRequests" }
-      );
-    }
-    let resolvedVaultAddress = params.vaultAddress;
-    if (!resolvedVaultAddress && params.vaultName) {
-      const cache = getCache();
-      if (cache.isEmpty() || cache.isExpired()) {
-        await cache.refresh();
-      }
-      const vault = cache.getVaultByName(params.vaultName);
-      if (!vault) {
-        throw new VaultNotFoundByNameError(
-          `No vault found with name "${params.vaultName}". The vault may not exist or may not be available for your organization.`,
-          { vaultName: params.vaultName, endpoint: "getWithdrawalRequests" }
-        );
-      }
-      resolvedVaultAddress = vault.vault.boringVaultAddress;
-    }
-    const filter = buildFilterString({
-      userAddress: params.userAddress,
-      chainId: params.chainId,
-      vaultAddress: resolvedVaultAddress,
-      status: params.status
-    });
-    const queryParams = new URLSearchParams();
-    if (filter) queryParams.set("filter", filter);
-    if (params.pageSize) queryParams.set("pageSize", String(params.pageSize));
-    if (params.pageToken) queryParams.set("pageToken", params.pageToken);
-    const url = `${getRestV2BaseURL()}/amplify/withdrawalRequests?${queryParams.toString()}`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT);
-    const response = await fetch(url, {
-      method: "GET",
-      headers: getRequestHeaders(),
-      signal: controller.signal
-    });
-    clearTimeout(timeout);
-    if (!response.ok) {
-      throw new APIError(
-        `Failed to fetch withdrawal requests: ${response.status} ${response.statusText}`,
-        {
-          endpoint: "getWithdrawalRequests",
-          statusCode: response.status
-        }
-      );
-    }
-    const data = await response.json();
-    return {
-      withdrawalRequests: data.withdrawalRequests ?? [],
-      nextPageToken: data.nextPageToken ?? null
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to fetch withdrawal requests: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "getWithdrawalRequests", cause: error }
-    );
-  }
-}
-async function getWithdrawalFee(params) {
-  try {
-    const normalizedChainId = toChainId(params.chainId);
-    const config = await resolveVault({
-      vaultName: params.vaultName,
-      assetAddress: params.assetAddress,
-      chainId: normalizedChainId,
-      callerEndpoint: "getWithdrawalFee"
-    });
-    if (!config.vault.withdrawQueueAddress) {
-      throw new APIError(
-        `WithdrawQueue contract address not configured for vault ${config.id}`,
-        { endpoint: "getWithdrawalFee" }
-      );
-    }
-    if (!config.vault.boringVaultAddress) {
-      throw new APIError(
-        `BoringVault contract address not configured for vault ${config.id}`,
-        { endpoint: "getWithdrawalFee" }
-      );
-    }
-    const client = await getClient(normalizedChainId);
-    const feeModuleAddress = await client.readContract({
-      abi: WithdrawQueueAbi,
-      address: config.vault.withdrawQueueAddress,
-      functionName: "feeModule"
-    });
-    const shareDecimals = await getErc20Decimals({
-      tokenAddress: config.vault.boringVaultAddress,
-      chainId: normalizedChainId
-    });
-    const amountBigInt = parseUnits(params.amount, shareDecimals);
-    const results = await client.multicall({
-      contracts: [
-        {
-          abi: FeeModuleAbi,
-          address: feeModuleAddress,
-          functionName: "calculateOfferFees",
-          args: [
-            amountBigInt,
-            params.offerAsset,
-            params.wantAsset,
-            params.receiver
-          ]
-        },
-        {
-          abi: FeeModuleAbi,
-          address: feeModuleAddress,
-          functionName: "offerFeePercentage"
-        }
-      ]
-    });
-    const [feeAmountResult, feePercentageResult] = results;
-    if (feeAmountResult.status === "failure" || feePercentageResult.status === "failure") {
-      throw new APIError("Failed to read fee data from FeeModule contract", {
-        endpoint: "getWithdrawalFee"
-      });
-    }
-    return {
-      feeAmount: feeAmountResult.result,
-      feePercentage: feePercentageResult.result
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to get withdrawal fee: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "getWithdrawalFee", cause: error }
-    );
-  }
-}
-async function getMinimumWithdrawalOrderSize(params) {
-  try {
-    const normalizedChainId = toChainId(params.chainId);
-    const config = await resolveVault({
-      vaultName: params.vaultName,
-      assetAddress: params.assetAddress,
-      chainId: normalizedChainId,
-      callerEndpoint: "getMinimumWithdrawalOrderSize"
-    });
-    if (!config.vault.withdrawQueueAddress) {
-      throw new APIError(
-        `WithdrawQueue contract address not configured for vault ${config.id}`,
-        { endpoint: "getMinimumWithdrawalOrderSize" }
-      );
-    }
-    if (!config.vault.boringVaultAddress) {
-      throw new APIError(
-        `BoringVault contract address not configured for vault ${config.id}`,
-        { endpoint: "getMinimumWithdrawalOrderSize" }
-      );
-    }
-    const client = await getClient(normalizedChainId);
-    const [minOrderResult, shareDecimalsResult] = await client.multicall({
-      contracts: [
-        {
-          abi: WithdrawQueueAbi,
-          address: config.vault.withdrawQueueAddress,
-          functionName: "minimumOrderSize"
-        },
-        {
-          abi: [
-            {
-              inputs: [],
-              name: "decimals",
-              outputs: [
-                {
-                  internalType: "uint8",
-                  name: "",
-                  type: "uint8"
-                }
-              ],
-              stateMutability: "view",
-              type: "function"
-            }
-          ],
-          address: config.vault.boringVaultAddress,
-          functionName: "decimals"
-        }
-      ]
-    });
-    if (minOrderResult.status === "failure" || shareDecimalsResult.status === "failure") {
-      throw new APIError(
-        "Failed to read minimum order size from WithdrawQueue contract",
-        { endpoint: "getMinimumWithdrawalOrderSize" }
-      );
-    }
-    return {
-      minimumOrderSize: minOrderResult.result,
-      shareDecimals: shareDecimalsResult.result
-    };
-  } catch (error) {
-    if (error instanceof APIError) {
-      throw error;
-    }
-    throw new APIError(
-      `Failed to get minimum withdrawal order size: ${error instanceof Error ? error.message : String(error)}`,
-      { endpoint: "getMinimumWithdrawalOrderSize", cause: error }
-    );
-  }
-}
-
-export { calculateDepositFee, getCurrentSupply, getDepositCap, getMinimumMint, getMinimumWithdrawalOrderSize, getShareValue, getVaultAPY, getVaultTVL, getWithdrawalFee, getWithdrawalRequests };
-//# sourceMappingURL=chunk-QMFYPHX5.mjs.map
-//# sourceMappingURL=chunk-QMFYPHX5.mjs.map