@b3dotfun/sdk 0.0.1-alpha.1

package/src/anyspend/types/permit.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export const zPermit = z.object({
+  ownerAddress: z.string(),
+  deadline: z.number(),
+  v: z.number(),
+  r: z.string(),
+  s: z.string()
+});
+export type Permit = z.infer<typeof zPermit>;

package/src/anyspend/types/relay.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export const zRelayStatus = z.enum(["refund", "delayed", "waiting", "failure", "pending", "success"]);
+export type RelayStatus = z.infer<typeof zRelayStatus>;
+
+export const zRelayStepStatus = z.enum(["complete", "incomplete"]);
+export type RelayStepStatus = z.infer<typeof zRelayStepStatus>;
+
+export enum TradeType {
+  EXACT_INPUT = "EXACT_INPUT",
+  EXPECTED_OUTPUT = "EXPECTED_OUTPUT",
+  EXACT_OUTPUT = "EXACT_OUTPUT"
+}

package/src/anyspend/types/req-res/createOrder.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { zCustomMetadata, zCustomPayload } from "../custom";
+import { zMintNftMetadata, zMintNftPayload } from "../nft";
+import { zOnrampMetadata } from "../onramp";
+import { OrderType, zOrder } from "../order";
+import { zSwapMetadata, zSwapPayload } from "../swap";
+import { zFundTournamentPayload, zJoinTournamentPayload, zTournamentMetadata } from "../tournament";
+
+const zBaseCreateOrderBody = z.object({
+  recipientAddress: z.string(),
+  srcChain: z.number(),
+  dstChain: z.number(),
+  srcTokenAddress: z.string(),
+  dstTokenAddress: z.string(),
+  srcAmount: z.string(),
+  onramp: zOnrampMetadata.optional(),
+  creatorAddress: z.string().optional()
+});
+
+const zCreateSwapOrderBody = zBaseCreateOrderBody.extend({
+  type: z.literal(OrderType.Swap),
+  payload: zSwapPayload,
+  metadata: zSwapMetadata
+});
+
+const zCreateMintNftOrderBody = zBaseCreateOrderBody.extend({
+  type: z.literal(OrderType.MintNFT),
+  payload: zMintNftPayload,
+  metadata: zMintNftMetadata
+});
+
+const zCreateJoinTournamentOrderBody = zBaseCreateOrderBody.extend({
+  type: z.literal(OrderType.JoinTournament),
+  payload: zJoinTournamentPayload,
+  metadata: zTournamentMetadata
+});
+
+const zCreateFundTournamentOrderBody = zBaseCreateOrderBody.extend({
+  type: z.literal(OrderType.FundTournament),
+  payload: zFundTournamentPayload,
+  metadata: zTournamentMetadata
+});
+
+const zCreateCustomOrderBody = zBaseCreateOrderBody.extend({
+  type: z.literal(OrderType.Custom),
+  payload: zCustomPayload,
+  metadata: zCustomMetadata
+});
+
+export const zCreateOrderRequest = z.object({
+  body: z.discriminatedUnion("type", [
+    zCreateSwapOrderBody,
+    zCreateMintNftOrderBody,
+    zCreateJoinTournamentOrderBody,
+    zCreateFundTournamentOrderBody,
+    zCreateCustomOrderBody
+  ])
+});
+export type CreateOrderRequest = z.infer<typeof zCreateOrderRequest.shape.body>;
+
+export const zCreateOrderResponse = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  data: zOrder,
+  statusCode: z.number()
+});

package/src/anyspend/types/req-res/getCoinbaseOnrampOptions.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+
+const zNetwork = z.object({
+  name: z.string(),
+  displayName: z.string(),
+  contractAddress: z.string(),
+  chainId: z.string()
+});
+
+const zPaymentLimit = z.object({
+  id: z.string(),
+  min: z.string(),
+  max: z.string()
+});
+
+const zPaymentCurrency = z.object({
+  id: z.string(),
+  limits: z.array(zPaymentLimit)
+});
+
+const zPurchaseCurrency = z.object({
+  id: z.string(),
+  name: z.string(),
+  symbol: z.string(),
+  networks: z.array(zNetwork),
+  iconUrl: z.string()
+});
+
+// Main response schema
+export const zGetCoinbaseOnrampOptionsResponse = z.object({
+  paymentCurrencies: z.array(zPaymentCurrency),
+  purchaseCurrencies: z.array(zPurchaseCurrency)
+});
+export type GetCoinbaseOnrampOptionsResponse = z.infer<typeof zGetCoinbaseOnrampOptionsResponse>;

package/src/anyspend/types/req-res/getOrderAndTransactions.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { zOrder } from "../order";
+import { zDepositTransaction, zExecuteTransaction, zRefundTransaction, zRelayTransaction } from "../transaction";
+
+export const zGetOrderAndTransactionsRequest = z.object({
+  params: z.object({
+    orderId: z.string()
+  })
+});
+
+export const zGetOrderAndTxsResponse = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  data: z.object({
+    order: zOrder,
+    depositTxs: z.array(zDepositTransaction).nullable(),
+    relayTx: zRelayTransaction.nullable(),
+    executeTx: zExecuteTransaction.nullable(),
+    refundTxs: z.array(zRefundTransaction).nullable()
+  }),
+  statusCode: z.number()
+});
+export type GetOrderAndTxsResponse = z.infer<typeof zGetOrderAndTxsResponse>;

package/src/anyspend/types/req-res/getOrderByCreator.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const zGetOrdersByCreatorRequest = z.object({
+  query: z.object({
+    creatorAddress: z.string().optional(),
+    limit: z.string().optional(),
+    offset: z.string().optional()
+  })
+});

package/src/anyspend/types/req-res/getOrderHistory.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+import { zOrder } from "../order";
+
+export const zGetOrderHistoryResponse = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  data: z.array(zOrder),
+  statusCode: z.number()
+});

package/src/anyspend/types/req-res/getQuote.ts

@@ -0,0 +1,60 @@
+import { QuoteDetails } from "@reservoir0x/relay-sdk";
+import { z } from "zod";
+
+import { OrderType } from "../order";
+import { TradeType } from "../relay";
+import { zCustomPayload } from "../custom";
+
+const zGetQuoteBody = z.object({
+  srcChain: z.number(),
+  dstChain: z.number(),
+  srcTokenAddress: z.string(),
+  dstTokenAddress: z.string()
+});
+
+const zGetQuoteForSwapOrderBody = zGetQuoteBody.extend({
+  type: z.literal(OrderType.Swap),
+  tradeType: z.nativeEnum(TradeType),
+  amount: z.string()
+});
+
+const zGetQuoteForMintNftOrderBody = zGetQuoteBody.extend({
+  type: z.literal(OrderType.MintNFT),
+  contractAddress: z.string(),
+  price: z.string()
+});
+
+const zGetQuoteForJoinTournamentOrderBody = zGetQuoteBody.extend({
+  type: z.literal(OrderType.JoinTournament),
+  contractAddress: z.string(),
+  price: z.string()
+});
+
+const zGetQuoteForFundTournamentOrderBody = zGetQuoteBody.extend({
+  type: z.literal(OrderType.FundTournament),
+  contractAddress: z.string(),
+  fundAmount: z.string()
+});
+
+const zGetQuoteForCustomOrderBody = zGetQuoteBody.extend({
+  type: z.literal(OrderType.Custom),
+  payload: zCustomPayload
+});
+
+export const zGetQuoteRequest = z.object({
+  body: z.discriminatedUnion("type", [
+    zGetQuoteForSwapOrderBody,
+    zGetQuoteForMintNftOrderBody,
+    zGetQuoteForJoinTournamentOrderBody,
+    zGetQuoteForFundTournamentOrderBody,
+    zGetQuoteForCustomOrderBody
+  ])
+});
+export type GetQuoteRequest = z.infer<typeof zGetQuoteRequest.shape.body>;
+
+export interface GetQuoteResponse {
+  success: boolean;
+  message: string;
+  data: QuoteDetails;
+  statusCode: number;
+}

package/src/anyspend/types/req-res/getTokenList.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+export const zGetTokenListResponse = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  data: z.array(
+    z.object({
+      chainId: z.number(),
+      address: z.string(),
+      symbol: z.string(),
+      name: z.string(),
+      decimals: z.number(),
+      metadata: z.object({
+        logoURI: z.string().optional()
+      })
+    })
+  )
+});

package/src/anyspend/types/req-res/index.ts

@@ -0,0 +1,8 @@
+export * from "./createOrder";
+export * from "./getCoinbaseOnrampOptions";
+export * from "./getOrderAndTransactions";
+export * from "./getOrderByCreator";
+export * from "./getOrderHistory";
+export * from "./getQuote";
+export * from "./getTokenList";
+export * from "./sendPermitData";

package/src/anyspend/types/req-res/sendPermitData.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { zPermit } from "../permit";
+
+export const zSendPermitDataRequest = z.object({
+  body: z.object({
+    orderId: z.string(),
+    permitData: zPermit
+  })
+});
+export type SendPermitDataRequestBody = z.infer<typeof zSendPermitDataRequest.shape.body>;

package/src/anyspend/types/swap.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+import { zToken } from "./token";
+
+export const zSwapPayload = z.object({
+  expectedDstAmount: z.string(),
+  actualDstAmount: z.string().nullable()
+});
+
+export const zSwapMetadata = z.object({
+  srcToken: zToken,
+  dstToken: zToken
+});

package/src/anyspend/types/token.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export const zToken = z.object({
+  chainId: z.number(),
+  address: z.string(),
+  symbol: z.string(),
+  name: z.string(),
+  decimals: z.number(),
+  metadata: z.object({
+    logoURI: z.string().optional()
+  })
+});
+export type Token = z.infer<typeof zToken>;

package/src/anyspend/types/tournament.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { zToken } from "./token";
+
+export const zTournament = z.object({
+  slug: z.string(),
+  name: z.string(),
+  description: z.string(),
+  imageUrl: z.string()
+});
+export type Tournament = z.infer<typeof zTournament>;
+
+export const zJoinTournamentPayload = z.object({
+  contractAddress: z.string(),
+  entryPrice: z.string()
+});
+
+export const zFundTournamentPayload = z.object({
+  contractAddress: z.string(),
+  fundAmount: z.string()
+});
+
+export const zTournamentMetadata = z.object({
+  srcToken: zToken,
+  dstToken: zToken,
+  tournament: zTournament
+});

package/src/anyspend/types/transaction.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { zRelayStatus } from "./relay";
+
+export const zDepositTransaction = z.object({
+  orderId: z.string(),
+  chain: z.number(),
+  from: z.string().nullable(),
+  txHash: z.string(),
+  amount: z.string(),
+  createdAt: z.number()
+});
+export type DepositTransaction = z.infer<typeof zDepositTransaction>;
+
+export const zRelayTransaction = z.object({
+  orderId: z.string(),
+  chain: z.number(),
+  txHash: z.string(),
+  status: zRelayStatus,
+  createdAt: z.number()
+});
+export type RelayTransaction = z.infer<typeof zRelayTransaction>;
+
+export const zExecuteTransaction = z.object({
+  orderId: z.string(),
+  chain: z.number(),
+  txHash: z.string(),
+  createdAt: z.number()
+});
+export type ExecuteTransaction = z.infer<typeof zExecuteTransaction>;
+
+export const zRefundTransaction = z.object({
+  orderId: z.string(),
+  chain: z.number(),
+  txHash: z.string(),
+  amount: z.string(),
+  status: z.enum(["success", "failure"]),
+  createdAt: z.number()
+});
+export type RefundTransaction = z.infer<typeof zRefundTransaction>;

package/src/anyspend/utils/address.ts

@@ -0,0 +1,25 @@
+import { isAddress } from "viem";
+
+export function isSolanaAddress(address: string): boolean {
+  // Solana addresses are 32-byte base58 strings (usually 32-44 characters)
+  const solanaAddressRegex = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+  return solanaAddressRegex.test(address);
+}
+
+export function isEvmOrSolanaAddress(address: string): boolean {
+  return isAddress(address) || isSolanaAddress(address);
+}
+
+export function normalizeAddress(address: string): string {
+  if (isSolanaAddress(address)) {
+    return address;
+  }
+  return address.toLowerCase(); // EVM address will normalize to lower case
+}
+
+// Equal case insensitive
+export function eqci(a: string | null | undefined, b: string | null | undefined) {
+  if (a === "" && b === "") return true;
+  if (!a || !b) return false;
+  return a.toLowerCase() === b.toLowerCase();
+}