@b3dotfun/sdk 0.0.8 → 0.0.9-alpha.0

package/dist/types/anyspend/types/transaction.d.ts

@@ -1,84 +0,0 @@
-import { z } from "zod";
-export declare const zDepositTransaction: z.ZodObject<{
-    orderId: z.ZodString;
-    chain: z.ZodNumber;
-    from: z.ZodNullable<z.ZodString>;
-    txHash: z.ZodString;
-    amount: z.ZodString;
-    createdAt: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    amount: string;
-    createdAt: number;
-    orderId: string;
-    chain: number;
-    from: string | null;
-    txHash: string;
-}, {
-    amount: string;
-    createdAt: number;
-    orderId: string;
-    chain: number;
-    from: string | null;
-    txHash: string;
-}>;
-export type DepositTransaction = z.infer<typeof zDepositTransaction>;
-export declare const zRelayTransaction: z.ZodObject<{
-    orderId: z.ZodString;
-    chain: z.ZodNumber;
-    txHash: z.ZodString;
-    status: z.ZodEnum<["refund", "delayed", "waiting", "failure", "pending", "success"]>;
-    createdAt: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    status: "failure" | "success" | "refund" | "delayed" | "waiting" | "pending";
-    createdAt: number;
-    orderId: string;
-    chain: number;
-    txHash: string;
-}, {
-    status: "failure" | "success" | "refund" | "delayed" | "waiting" | "pending";
-    createdAt: number;
-    orderId: string;
-    chain: number;
-    txHash: string;
-}>;
-export type RelayTransaction = z.infer<typeof zRelayTransaction>;
-export declare const zExecuteTransaction: z.ZodObject<{
-    orderId: z.ZodString;
-    chain: z.ZodNumber;
-    txHash: z.ZodString;
-    createdAt: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    createdAt: number;
-    orderId: string;
-    chain: number;
-    txHash: string;
-}, {
-    createdAt: number;
-    orderId: string;
-    chain: number;
-    txHash: string;
-}>;
-export type ExecuteTransaction = z.infer<typeof zExecuteTransaction>;
-export declare const zRefundTransaction: z.ZodObject<{
-    orderId: z.ZodString;
-    chain: z.ZodNumber;
-    txHash: z.ZodString;
-    amount: z.ZodString;
-    status: z.ZodEnum<["success", "failure"]>;
-    createdAt: z.ZodNumber;
-}, "strip", z.ZodTypeAny, {
-    status: "failure" | "success";
-    amount: string;
-    createdAt: number;
-    orderId: string;
-    chain: number;
-    txHash: string;
-}, {
-    status: "failure" | "success";
-    amount: string;
-    createdAt: number;
-    orderId: string;
-    chain: number;
-    txHash: string;
-}>;
-export type RefundTransaction = z.infer<typeof zRefundTransaction>;

package/src/anyspend/types/custom.ts

@@ -1,17 +0,0 @@
-import z from "zod";
-import { zToken } from "./token";
-
-export const zCustomPayload = z.object({
-  data: z.string(),
-  to: z.string(),
-  spenderAddress: z.string().optional(),
-  amount: z.string(),
-});
-export type CustomPayload = z.infer<typeof zCustomPayload>;
-
-export const zCustomMetadata = z.object({
-  srcToken: zToken,
-  dstToken: zToken,
-  action: z.string().optional(),
-});
-export type CustomMetadata = z.infer<typeof zCustomMetadata>;

package/src/anyspend/types/globalWallet.ts

@@ -1,9 +0,0 @@
-import { z } from "zod";
-
-export const zGlobalWallet = z.object({
-  chain: z.number(),
-  encryptedPrvkey: z.string(),
-  address: z.string(),
-  orderId: z.string().nullable(),
-});
-export type GlobalWallet = z.infer<typeof zGlobalWallet>;

package/src/anyspend/types/index.ts

@@ -1,14 +0,0 @@
-export * from "./req-res";
-
-export * from "./chain";
-export * from "./custom";
-export * from "./globalWallet";
-export * from "./metadata";
-export * from "./nft";
-export * from "./onramp";
-export * from "./order";
-export * from "./relay";
-export * from "./swap";
-export * from "./token";
-export * from "./tournament";
-export * from "./transaction";

package/src/anyspend/types/metadata.ts

@@ -1,41 +0,0 @@
-import { NftContract } from "./nft";
-import { OrderType } from "./order";
-
-export type BaseMetadata = {
-  type: OrderType;
-};
-
-export type NftMetadata = BaseMetadata & {
-  type: OrderType.MintNFT;
-  nftContract: NftContract;
-};
-
-export type TournamentMetadata = BaseMetadata & {
-  type: OrderType.JoinTournament | OrderType.FundTournament;
-  tournament: {
-    slug: string;
-    name: string;
-    description: string;
-    imageUrl: string;
-  };
-};
-
-export type CustomTxMetadata = BaseMetadata & {
-  type: OrderType.Custom;
-  action: string;
-};
-
-export type AnySpendMetadata = NftMetadata | TournamentMetadata | CustomTxMetadata;
-
-// Type guard functions
-export function isNftMetadata(metadata: AnySpendMetadata): metadata is NftMetadata {
-  return metadata.type === OrderType.MintNFT;
-}
-
-export function isTournamentMetadata(metadata: AnySpendMetadata): metadata is TournamentMetadata {
-  return metadata.type === OrderType.JoinTournament || metadata.type === OrderType.FundTournament;
-}
-
-export function isCustomTxMetadata(metadata: AnySpendMetadata): metadata is CustomTxMetadata {
-  return metadata.type === OrderType.Custom;
-}

package/src/anyspend/types/nft.ts

@@ -1,53 +0,0 @@
-import { z } from "zod";
-import { Token, zToken } from "./token";
-
-export enum NftType {
-  ERC721 = "erc721",
-  ERC1155 = "erc1155",
-}
-
-export const zBaseNft = z.object({
-  type: z.nativeEnum(NftType),
-  contractAddress: z.string(),
-  name: z.string(),
-  description: z.string(),
-  imageUrl: z.string(),
-});
-
-export const zNft = z.discriminatedUnion("type", [
-  zBaseNft.extend({
-    type: z.literal(NftType.ERC721),
-  }),
-  zBaseNft.extend({
-    type: z.literal(NftType.ERC1155),
-    tokenId: z.number(),
-    imageUrl: z.string(),
-  }),
-]);
-export type Nft = z.infer<typeof zNft>;
-
-export const zMintNftPayload = z.object({
-  contractAddress: z.string(),
-  tokenId: z.number().nullable(),
-  contractType: z.nativeEnum(NftType),
-  nftPrice: z.string(),
-});
-
-export const zMintNftMetadata = z.object({
-  srcToken: zToken,
-  dstToken: zToken,
-  nft: zNft,
-});
-
-export interface NftContract {
-  chainId: number;
-  contractAddress: string;
-  price: string;
-  priceFormatted: string;
-  currency: Token;
-  imageUrl: string;
-  name: string;
-  description: string;
-  tokenId: number | null;
-  type: NftType;
-}

package/src/anyspend/types/onramp.ts

@@ -1,16 +0,0 @@
-import { z } from "zod";
-
-export enum OnrampVendor {
-  Coinbase = "coinbase",
-  Stripe = "stripe",
-  StripeWeb2 = "stripe-web2",
-}
-
-export const zOnrampMetadata = z.object({
-  country: z.string(),
-  vendor: z.nativeEnum(OnrampVendor),
-  paymentMethod: z.string(),
-  ipAddress: z.string().ip("Invalid IP address").optional(),
-  redirectUrl: z.string(),
-  stripeAmountInCents: z.number().optional(),
-});

package/src/anyspend/types/order.ts

@@ -1,88 +0,0 @@
-import { z } from "zod";
-import { zOnrampMetadata } from "./onramp";
-import { zMintNftMetadata, zMintNftPayload } from "./nft";
-import { zSwapMetadata, zSwapPayload } from "./swap";
-import { zFundTournamentPayload, zJoinTournamentPayload, zTournamentMetadata } from "./tournament";
-import { zCustomMetadata, zCustomPayload } from "./custom";
-
-export enum OrderStatus {
-  // Prepare steps
-  ScanningDepositTransaction = "scanning_deposit_transaction",
-  WaitingStripePayment = "waiting_stripe_payment",
-
-  //
-  Expired = "expired",
-
-  //
-  SendingTokenFromVault = "sending_token_from_vault",
-
-  // Execute steps
-  Relay = "relay",
-  Executed = "executed",
-
-  // Refund steps
-  Refunding = "refunding",
-  Refunded = "refunded",
-
-  // Failed order
-  Failure = "failure",
-}
-
-export enum OrderType {
-  Swap = "swap",
-  MintNFT = "mint_nft",
-  JoinTournament = "join_tournament",
-  FundTournament = "fund_tournament",
-  Custom = "custom",
-}
-
-export const zBaseOrder = z.object({
-  id: z.string(),
-
-  recipientAddress: z.string(),
-  globalAddress: z.string(),
-  srcChain: z.number(),
-  dstChain: z.number(),
-  srcTokenAddress: z.string(),
-  dstTokenAddress: z.string(),
-  srcAmount: z.string(),
-  status: z.nativeEnum(OrderStatus),
-  errorDetails: z.string().nullable(),
-  createdAt: z.number(),
-  expiredAt: z.number(),
-  onrampMetadata: zOnrampMetadata.nullable(),
-  creatorAddress: z.string().nullable(),
-  partnerId: z.string().nullable(),
-
-  oneClickBuyUrl: z.string().nullable(),
-  stripePaymentIntentId: z.string().nullable(),
-});
-
-export const zOrder = z.discriminatedUnion("type", [
-  zBaseOrder.extend({
-    type: z.literal(OrderType.Swap),
-    payload: zSwapPayload,
-    metadata: zSwapMetadata,
-  }),
-  zBaseOrder.extend({
-    type: z.literal(OrderType.MintNFT),
-    payload: zMintNftPayload,
-    metadata: zMintNftMetadata,
-  }),
-  zBaseOrder.extend({
-    type: z.literal(OrderType.JoinTournament),
-    payload: zJoinTournamentPayload,
-    metadata: zTournamentMetadata,
-  }),
-  zBaseOrder.extend({
-    type: z.literal(OrderType.FundTournament),
-    payload: zFundTournamentPayload,
-    metadata: zTournamentMetadata,
-  }),
-  zBaseOrder.extend({
-    type: z.literal(OrderType.Custom),
-    payload: zCustomPayload,
-    metadata: zCustomMetadata,
-  }),
-]);
-export type Order = z.infer<typeof zOrder>;

package/src/anyspend/types/relay.ts

@@ -1,13 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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(),
-  partnerId: z.string().optional(),
-  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

@@ -1,34 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,65 +0,0 @@
-import { QuoteDetails } from "@reservoir0x/relay-sdk";
-import { z } from "zod";
-
-import { zCustomPayload } from "../custom";
-import { NftType } from "../nft";
-import { OrderType } from "../order";
-import { TradeType } from "../relay";
-import { OnrampVendor } from "../onramp";
-
-const zGetQuoteBody = z.object({
-  srcChain: z.number(),
-  dstChain: z.number(),
-  srcTokenAddress: z.string(),
-  dstTokenAddress: z.string(),
-  onrampVendor: z.nativeEnum(OnrampVendor).optional(),
-});
-
-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(),
-  tokenId: z.number().nullable(),
-  contractType: z.nativeEnum(NftType),
-  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

@@ -1,18 +0,0 @@
-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

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

package/src/anyspend/types/swap.ts

@@ -1,12 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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>;