@b3dotfun/sdk 0.0.1-alpha.1

package/dist/esm/anyspend/utils/format.js

@@ -0,0 +1,54 @@
+import { OrderStatus, OrderType } from "../../anyspend/types";
+export const getStatusDisplay = (order) => {
+    switch (order.status) {
+        case OrderStatus.ScanningDepositTransaction:
+            return {
+                text: order.onrampMetadata ? "Awaiting Payment" : "Awaiting Deposit",
+                status: "processing"
+            };
+        case OrderStatus.WaitingStripePayment:
+            return {
+                text: "Awaiting Payment",
+                status: "processing"
+            };
+        case OrderStatus.ObtainToken:
+            return { text: "Obtaining Token", status: "processing" };
+        case OrderStatus.ObtainFailed:
+            return { text: "Obtain Token Failed", status: "failure" };
+        case OrderStatus.Expired:
+            return { text: "Order Expired", status: "failure" };
+        case OrderStatus.SendingTokenFromVault:
+            return { text: "Sending Token", status: "processing" };
+        case OrderStatus.Relay:
+            return { text: "Executing Order", status: "processing" };
+        case OrderStatus.Executed: {
+            const text = order.type === OrderType.Swap
+                ? "Swap Complete"
+                : order.type === OrderType.MintNFT
+                    ? "NFT Minted"
+                    : order.type === OrderType.JoinTournament
+                        ? "Tournament Joined"
+                        : order.type === OrderType.FundTournament
+                            ? "Tournament Funded"
+                            : "Order Complete";
+            return { text, status: "success" };
+        }
+        case OrderStatus.Refunding:
+            return { text: "Order Refunding", status: "processing" };
+        case OrderStatus.Refunded:
+            return { text: "Order Refunded", status: "failure" };
+        case OrderStatus.Failure:
+            return { text: "Order Failure", status: "failure" };
+        default:
+            throw new Error("Invalid order status");
+    }
+};
+export const getErrorDisplay = (errorDetails) => {
+    switch (errorDetails) {
+        case "SLIPPAGE":
+            return "The order failed due to price movement exceeding slippage tolerance";
+        default: {
+            return "The order failed. Please try again or contact support";
+        }
+    }
+};

package/dist/esm/anyspend/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./address";
+export * from "./chain";
+export * from "./format";
+export * from "./json";
+export * from "./number";
+export * from "./string";
+export * from "./token";
+export * from "./orderPayload";

package/dist/esm/anyspend/utils/index.js

@@ -0,0 +1,8 @@
+export * from "./address";
+export * from "./chain";
+export * from "./format";
+export * from "./json";
+export * from "./number";
+export * from "./string";
+export * from "./token";
+export * from "./orderPayload";

package/dist/esm/anyspend/utils/json.d.ts

@@ -0,0 +1 @@
+export declare function stringify(value: any): string;

package/dist/esm/anyspend/utils/json.js

@@ -0,0 +1,3 @@
+export function stringify(value) {
+    return JSON.stringify(value, (_, v) => (typeof v === "bigint" ? v.toString() : v));
+}

package/dist/esm/anyspend/utils/number.d.ts

@@ -0,0 +1,13 @@
+import Big from "big.js";
+export declare function divpowToBig(n: string | number | bigint, decimals: number): Big;
+export declare function mulpowToBig(s: string, multiplier?: number): Big;
+export declare function truncateValue(value: string, decimals: number): string;
+export declare const inputRegex: RegExp;
+export declare function escapeRegExp(string: string): string;
+/**
+ * Round up a number to the nearest multiple of 0.01 USDC, which is 10^4 USDC base units
+ * @param value - The number to round up
+ * @returns The rounded number
+ * For example, roundUpUSDCBaseAmountToNearest("2663988") = "2670000"
+ */
+export declare function roundUpUSDCBaseAmountToNearest(value: string): string;

package/dist/esm/anyspend/utils/number.js

@@ -0,0 +1,79 @@
+import Big from "big.js";
+import { parseUnits } from "viem";
+// Configure Big.js to use exponential notation only for very large/small numbers
+Big.PE = 40; // Precision for exponential notation (higher = less use of exponential)
+// Convert a token amount to a human-readable decimal
+// n = "10000000000000000000", decimals = 9 => "10.0" (10 tokens with 9 decimals)
+export function divpowToBig(n, decimals) {
+    const value = new Big(n.toString());
+    const divisor = new Big(10).pow(decimals);
+    return value.div(divisor);
+}
+// Convert a human-readable decimal to a token amount
+// s = "0.000000000000001", multiplier = 18 => 1000 (0.000000000000001 ETH with 18 decimals = 1000 wei)
+export function mulpowToBig(s, multiplier = 18) {
+    if (!s || s === "") {
+        return new Big(0);
+    }
+    // Parse the string into wei/atomic units
+    const atomicUnits = parseUnits(truncateValue(s, multiplier), multiplier).toString();
+    // Return the number of atomic units
+    return new Big(atomicUnits);
+}
+export function truncateValue(value, decimals) {
+    if (!value || value === "") {
+        return "0";
+    }
+    // Special case for decimal-only input
+    if (value === ".")
+        return "0";
+    // Handle case where value starts with decimal point
+    if (value.startsWith(".")) {
+        value = "0" + value;
+    }
+    const parts = value.split(/\./);
+    if (parts.length > 1) {
+        // Remove leading zeros from whole part
+        parts[0] = parts[0].replace(/^0+(?=\d)/, "");
+        if (parts[0] === "")
+            parts[0] = "0"; // If whole part is empty, set to '0'
+        // Limit decimal part to specified number of places
+        parts[1] = parts[1].slice(0, decimals);
+        // Remove trailing zeros from decimal part
+        parts[1] = parts[1].replace(/0+$/, "");
+        // Special case for very small numbers where all digits get truncated
+        if (parts[1] === "" || parts[1].match(/^0+$/)) {
+            return parts[0];
+        }
+        // If the decimal part is empty after processing, return just the whole part
+        if (parts[1] === "") {
+            return parts[0];
+        }
+        const res = `${parts[0]}.${parts[1]}`;
+        return res;
+    }
+    // For numbers without a decimal part
+    const cleanValue = value.replace(/^0+(?=\d)/, ""); // Remove leading zeros.
+    return cleanValue || "0"; // Return '0' if the result is an empty string
+}
+export const inputRegex = RegExp(`^\\d*(?:\\\\[.])?\\d*$`); // match escaped "." characters via in a non-capturing group
+export function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+}
+/**
+ * Round up a number to the nearest multiple of 0.01 USDC, which is 10^4 USDC base units
+ * @param value - The number to round up
+ * @returns The rounded number
+ * For example, roundUpUSDCBaseAmountToNearest("2663988") = "2670000"
+ */
+export function roundUpUSDCBaseAmountToNearest(value) {
+    const divisor = new Big(10).pow(4); // Round to nearest 10,000
+    const srcAmountBig = new Big(value);
+    const remainder = srcAmountBig.mod(divisor);
+    // If remainder is already 0 (exactly divisible by 10^4), return the original amount
+    if (remainder.eq(0)) {
+        return value;
+    }
+    const res = srcAmountBig.plus(divisor.minus(remainder)).toString();
+    return res;
+}

package/dist/esm/anyspend/utils/orderPayload.d.ts

@@ -0,0 +1,127 @@
+import { Nft, OrderType, Token, Tournament } from "../../anyspend/types";
+export type OrderParams = {
+    orderType: OrderType;
+    srcToken: Token;
+    dstToken: Token;
+    expectedDstAmount?: string;
+    nft?: Nft & {
+        price: string;
+    };
+    tournament?: Tournament & {
+        contractAddress: string;
+        entryPriceOrFundAmount: string;
+    };
+    payload?: any;
+};
+export declare const buildPayload: (orderType: OrderType, params: OrderParams) => any;
+export declare const buildMetadata: (orderType: OrderType, params: OrderParams) => {
+    srcToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+    dstToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+} | {
+    nft: (({
+        name: string;
+        type: import("../../anyspend/types").NftType.ERC721;
+        contractAddress: string;
+        description: string;
+        imageUrl: string;
+    } | {
+        name: string;
+        type: import("../../anyspend/types").NftType.ERC1155;
+        contractAddress: string;
+        description: string;
+        imageUrl: string;
+        tokenId: number;
+    }) & {
+        price: string;
+    }) | undefined;
+    srcToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+    dstToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+} | {
+    tournament: ({
+        name: string;
+        description: string;
+        imageUrl: string;
+        slug: string;
+    } & {
+        contractAddress: string;
+        entryPriceOrFundAmount: string;
+    }) | undefined;
+    srcToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+    dstToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+} | {
+    action: any;
+    srcToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+    dstToken: {
+        symbol: string;
+        chainId: number;
+        address: string;
+        name: string;
+        decimals: number;
+        metadata: {
+            logoURI?: string | undefined;
+        };
+    };
+};

package/dist/esm/anyspend/utils/orderPayload.js

@@ -0,0 +1,51 @@
+import { OrderType } from "../../anyspend/types";
+import { normalizeAddress } from "../../anyspend/utils";
+export const buildPayload = (orderType, params) => {
+    const { nft, tournament, payload, expectedDstAmount } = params;
+    switch (orderType) {
+        case OrderType.Swap:
+            return {
+                expectedDstAmount,
+                actualDstAmount: null
+            };
+        case OrderType.MintNFT:
+            return {
+                contractAddress: nft ? normalizeAddress(nft.contractAddress) : "",
+                nftPrice: nft?.price || ""
+            };
+        case OrderType.JoinTournament:
+            return {
+                contractAddress: tournament?.contractAddress,
+                entryPrice: tournament?.entryPriceOrFundAmount
+            };
+        case OrderType.FundTournament:
+            return {
+                contractAddress: tournament?.contractAddress,
+                fundAmount: tournament?.entryPriceOrFundAmount
+            };
+        case OrderType.Custom:
+            return { ...payload };
+        default:
+            throw new Error(`Invalid order type: ${orderType}`);
+    }
+};
+export const buildMetadata = (orderType, params) => {
+    const { srcToken, dstToken, nft, tournament, payload } = params;
+    const baseMetadata = {
+        srcToken,
+        dstToken
+    };
+    switch (orderType) {
+        case OrderType.Swap:
+            return { ...baseMetadata };
+        case OrderType.MintNFT:
+            return { ...baseMetadata, nft };
+        case OrderType.JoinTournament:
+        case OrderType.FundTournament:
+            return { ...baseMetadata, tournament };
+        case OrderType.Custom:
+            return { ...baseMetadata, action: payload.action };
+        default:
+            throw new Error(`Invalid order type: ${orderType}`);
+    }
+};

package/dist/esm/anyspend/utils/string.d.ts

@@ -0,0 +1 @@
+export declare const capitalizeFirstLetter: (stringToCapitalize: string) => string;

package/dist/esm/anyspend/utils/string.js

@@ -0,0 +1,5 @@
+export const capitalizeFirstLetter = (stringToCapitalize) => {
+    if (!stringToCapitalize)
+        return "";
+    return stringToCapitalize.charAt(0).toUpperCase() + stringToCapitalize.slice(1);
+};

package/dist/esm/anyspend/utils/token.d.ts

@@ -0,0 +1,7 @@
+import { Token } from "../../anyspend/types";
+export declare function isNativeToken(address: string): boolean;
+export declare function getSolanaToken(): Token;
+export declare function getEthToken(chainId: number): Token;
+export declare function getPolToken(): Token;
+export declare function getBnbToken(): Token;
+export declare function getAvaxToken(): Token;

package/dist/esm/anyspend/utils/token.js

@@ -0,0 +1,65 @@
+import { avalanche, bsc, polygon } from "viem/chains";
+import { RELAY_ETH_ADDRESS, RELAY_SOL_ADDRESS, RELAY_SOLANA_MAINNET_CHAIN_ID } from "../../anyspend/constants";
+export function isNativeToken(address) {
+    return address.toLowerCase() === RELAY_ETH_ADDRESS || address.toLowerCase() === RELAY_SOL_ADDRESS;
+}
+export function getSolanaToken() {
+    return {
+        chainId: RELAY_SOLANA_MAINNET_CHAIN_ID,
+        address: RELAY_SOL_ADDRESS,
+        symbol: "SOL",
+        name: "Solana",
+        decimals: 9,
+        metadata: {
+            logoURI: "https://assets.relay.link/icons/square/792703809/light.png"
+        }
+    };
+}
+export function getEthToken(chainId) {
+    return {
+        chainId: chainId,
+        address: RELAY_ETH_ADDRESS,
+        symbol: "ETH",
+        name: "Ethereum",
+        decimals: 18,
+        metadata: {
+            logoURI: "https://assets.relay.link/icons/square/1/light.png"
+        }
+    };
+}
+export function getPolToken() {
+    return {
+        chainId: polygon.id,
+        address: RELAY_ETH_ADDRESS,
+        symbol: "POL",
+        name: "Polygon",
+        decimals: 18,
+        metadata: {
+            logoURI: "https://s2.coinmarketcap.com/static/img/coins/64x64/28321.png"
+        }
+    };
+}
+export function getBnbToken() {
+    return {
+        chainId: bsc.id,
+        address: RELAY_ETH_ADDRESS,
+        symbol: "BNB",
+        name: "BNB",
+        decimals: 18,
+        metadata: {
+            logoURI: "https://s2.coinmarketcap.com/static/img/coins/64x64/1839.png"
+        }
+    };
+}
+export function getAvaxToken() {
+    return {
+        chainId: avalanche.id,
+        address: RELAY_ETH_ADDRESS,
+        symbol: "AVAX",
+        name: "AVAX",
+        decimals: 18,
+        metadata: {
+            logoURI: "https://s2.coinmarketcap.com/static/img/coins/64x64/5805.png"
+        }
+    };
+}