@tradeport/sui-trading-sdk 0.5.3 → 0.5.4

package/src/graphql/createChainGQLQuery.ts

@@ -0,0 +1,27 @@
+import { gql } from 'graphql-request';
+
+type ChainQuery = {
+	chain: string;
+	query: string;
+};
+
+export function createChainGQLQuery({ chain, query }: ChainQuery) {
+	const regex = /query\s+(\w+)\s*\(([\s\S]*?)\)\s*((?:@\w+(?:\([^)]*\))?\s*)*){([\s\S]*)}/;
+	const matches = regex.exec(query);
+
+	if (!matches || matches.length !== 5) {
+		throw new Error('Invalid query string format');
+	}
+
+	const [, queryName, argsString, directivesString, bodyString] = matches;
+
+	if (!argsString || !bodyString) return '';
+
+	const args = argsString.trim().length ? `(${argsString.trim()})` : '';
+	const directives = directivesString.trim();
+	const directivesPart = directives.length ? ` ${directives}` : '';
+	const body = bodyString.trim();
+	const wrappedBody = `${chain} {\n${body}\n}`;
+
+	return gql`query ${queryName}${args}${directivesPart} {\n${wrappedBody}\n}`;
+}

package/src/graphql/gqlChainRequest.ts

@@ -0,0 +1,21 @@
+import { getGraphqlClient } from '../apiClients/graphqlClient';
+import { createChainGQLQuery } from './createChainGQLQuery';
+
+type Args = {
+	chain: string;
+	query: string;
+	variables?: any;
+};
+
+export const gqlChainRequest = async ({ chain, query, variables }: Args) => {
+	if (!chain || !query) {
+		throw new Error('Missing required arguments');
+	}
+
+	const response = await getGraphqlClient().request<any>(
+		createChainGQLQuery({ chain, query }),
+		variables,
+	);
+
+	return response?.[chain];
+};

package/src/graphql/queries/fetchAccountKiosks.ts

@@ -0,0 +1,12 @@
+import { gql } from 'graphql-request';
+
+export const fetchAccountKiosks = gql`
+	query fetchAccountKiosks($accountAddress: String!) {
+		kiosks: kiosks_by_owner_address(owner_address: $accountAddress) {
+			id
+			is_origin_byte
+			owner_address
+			profits
+		}
+	}
+`;

package/src/graphql/queries/fetchActiveLockStateByNftId.ts

@@ -0,0 +1,15 @@
+import { gql } from 'graphql-request';
+
+export const fetchActiveLockStateByNftId = gql`
+	query fetchActiveLockStateByNftId($nftId: uuid!) {
+		locks(
+			where: {
+				state: { _nin: ["exercised", "canceled", "confirmed"] }
+				nft_meta_id: { _eq: $nftId }
+			}
+		) {
+			id
+			state
+		}
+	}
+`;

package/src/graphql/queries/fetchBidsById.ts

@@ -0,0 +1,36 @@
+import { gql } from 'graphql-request';
+
+export const fetchBidsById = gql`
+	query fetchBidsById($bidIds: [uuid!]) {
+		bids(where: { id: { _in: $bidIds } }) {
+			nonce
+			price
+			status
+			type
+			receiver
+			bidder
+			multi_bid_id
+			nft {
+				token_id
+				properties
+				chain_state
+				collection_id
+				owner
+				contract {
+					properties
+				}
+				listings(where: { listed: { _eq: true } }) {
+					price
+					market_name
+				}
+			}
+			market_contract {
+				name
+			}
+			collection {
+				id
+				chain_state
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchCollectionBidById.ts

@@ -0,0 +1,21 @@
+import { gql } from 'graphql-request';
+
+export const fetchCollectionBidsById = gql`
+	query fetchCollectionBidsById($bidIds: [uuid!]) {
+		bids(where: { id: { _in: $bidIds } }) {
+			nonce
+			price
+			bidder
+			status
+			type
+			collection_id
+			multi_bid_id
+			contract {
+				properties
+			}
+			market_contract {
+				name
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchCollectionBidsAtSamePrice.ts

@@ -0,0 +1,29 @@
+import { gql } from 'graphql-request';
+
+export const fetchCollectionBidsAtSamePrice = gql`
+	query fetchCollectionBidsAtSamePrice($collectionId: uuid!, $price: numeric) {
+		bids(
+			where: {
+				collection_id: { _eq: $collectionId }
+				price: { _eq: $price }
+				status: { _eq: "active" }
+				type: { _eq: "collection" }
+			}
+			order_by: { price: desc }
+		) {
+			nonce
+			price
+			bidder
+			status
+			type
+			collection_id
+			multi_bid_id
+			contract {
+				properties
+			}
+			market_contract {
+				name
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchCollectionChainState.ts

@@ -0,0 +1,17 @@
+import { gql } from 'graphql-request';
+
+export const fetchCollectionChainState = gql`
+	query fetchCollectionChainState($collectionId: uuid!) @cached(ttl: 10) {
+		collections(where: { id: { _eq: $collectionId } }) {
+			chain_state
+		}
+	}
+`;
+
+export const fetchCollectionChainStateByFtType = gql`
+	query fetchCollectionChainStateByFtType($ftType: String!) @cached(ttl: 10) {
+		collections_by_ft_type(args: { coin_type: $ftType }, limit: 1) {
+			chain_state
+		}
+	}
+`;

package/src/graphql/queries/fetchCollectionFloorListingForMarket.ts

@@ -0,0 +1,28 @@
+import { gql } from 'graphql-request';
+
+export const fetchCollectionFloorListingsForMarket = gql`
+	query fetchCollectionFloorListingsForMarket(
+		$collectionId: uuid!
+		$marketAddress: String!
+		$totalPrice: numeric
+	) {
+		listings(
+			where: {
+				collection_id: { _eq: $collectionId }
+				listed: { _eq: true }
+				market_name: { _eq: "tradeport" }
+				seller: { _neq: $marketAddress }
+				nonce: { _like: "1::0x%" }
+				price: { _lte: $totalPrice }
+			}
+			order_by: [{ price: asc_nulls_last }, { block_height: asc }, { tx_index: asc }]
+		) {
+			id
+			price
+			nft {
+				token_id
+				delegated_owner
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchCollectionFloorListings.ts

@@ -0,0 +1,15 @@
+import { gql } from 'graphql-request';
+
+export const fetchCollectionFloorListings = gql`
+	query fetchCollectionFloorListings($collectionId: uuid!) {
+		listings(
+			where: { collection_id: { _eq: $collectionId }, listed: { _eq: true }, nft: {} }
+			order_by: { price: asc_nulls_last, market_name: desc_nulls_last }
+			limit: 3
+		) {
+			id
+			price
+			market_name
+		}
+	}
+`;

package/src/graphql/queries/fetchCollectionsById.ts

@@ -0,0 +1,39 @@
+import { gql } from 'graphql-request';
+
+export const fetchCollectionsById = gql`
+	query fetchCollectionsById($collectionIds: [uuid!]) {
+		collections(where: { id: { _in: $collectionIds } }) {
+			id
+			contract {
+				properties
+			}
+		}
+	}
+`;
+
+export const fetchCollectionsByIdWithOneNft = gql`
+	query fetchCollectionsByIdWithOneNft($collectionIds: [uuid!]) {
+		collections(where: { id: { _in: $collectionIds } }) {
+			id
+			chain_state
+			contract {
+				properties
+			}
+			nfts(limit: 1) {
+				id
+				properties
+				contract {
+					properties
+				}
+			}
+		}
+	}
+`;
+
+export const fetchCollectionsBySlug = gql`
+	query fetchCollectionsBySlug($slug: String!) {
+		collections(where: { slug: { _eq: $slug } }) {
+			id
+		}
+	}
+`;

package/src/graphql/queries/fetchCommissionByListingId.ts

@@ -0,0 +1,13 @@
+import { gql } from 'graphql-request';
+
+export const fetchCommissionByNftContractId = gql`
+	query fetchCommissionByNftContractId($nftContractId: uuid!) {
+		commissions(where: { contract_id: { _eq: $nftContractId } }) {
+			is_custodial
+			key
+			market_fee
+			market_name
+			royalty
+		}
+	}
+`;

package/src/graphql/queries/fetchCryptoToUsdRate.ts

@@ -0,0 +1,13 @@
+import { gql } from 'graphql-request';
+
+export const fetchCryptoToUsdRate = gql`
+	query fetchCryptoToUsdRate($crypto: String!) {
+		crypto_rates(where: { crypto: { _eq: $crypto }, fiat: { _eq: "USD" } }) {
+			crypto
+			fiat
+			id
+			rate
+			timestamp
+		}
+	}
+`;

package/src/graphql/queries/fetchKiosksByOwner.ts

@@ -0,0 +1,14 @@
+import { gql } from 'graphql-request';
+
+export const fetchKiosksByOwner = gql`
+	query fetchKiosksByOwner($ownerAddress: String!) {
+		kiosks: kiosks_by_owner_address(owner_address: $ownerAddress) {
+			id
+			is_origin_byte
+			is_personal
+			owner_address
+			profits
+			is_shared
+		}
+	}
+`;

package/src/graphql/queries/fetchListingsById.ts

@@ -0,0 +1,29 @@
+import { gql } from 'graphql-request';
+
+export const fetchListingsById = gql`
+	query fetchListingsById($listingIds: [uuid!]) {
+		listings(where: { id: { _in: $listingIds } }) {
+			id
+			seller
+			listed
+			market_name
+			price
+			nonce
+			nft {
+				id
+				token_id
+				collection_id
+				contract_id
+				properties
+				chain_state
+				contract {
+					properties
+				}
+			}
+			collection {
+				id
+				chain_state
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchListingsByNftId.ts

@@ -0,0 +1,23 @@
+import { gql } from 'graphql-request';
+
+export const fetchListingsByNftId = gql`
+	query fetchListingsByNftId($nftIds: [uuid!]) {
+		listings(where: { nft_id: { _in: $nftIds }, listed: { _eq: true } }) {
+			listed
+			market_name
+			price
+			nonce
+			nft {
+				id
+				token_id
+				collection_id
+				contract_id
+				properties
+				chain_state
+				contract {
+					properties
+				}
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchLockById.ts

@@ -0,0 +1,23 @@
+import { gql } from 'graphql-request';
+
+export const fetchLockById = gql`
+	query fetchLockById($lockId: uuid!) {
+		locks(where: { id: { _eq: $lockId } }) {
+			id
+			type
+			state
+			collection_id
+			lock_id
+			nft_type
+			maker_price
+			maker
+			chain_state
+			collection_id
+			expire_in
+			nft {
+				id
+				token_id
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchMultibidById.ts

@@ -0,0 +1,34 @@
+import { gql } from 'graphql-request';
+
+export const fetchMultibidChainIdById = gql`
+	query fetchMultibidById($multiBidId: uuid!) {
+		multi_bids(where: { id: { _eq: $multiBidId } }) {
+			chain_id
+			cancelled_at
+		}
+	}
+`;
+
+export const fetchMultibidChainIdAndSingleBidsById = gql`
+	query fetchMultibidChainIdAndSingleBidsById($multiBidId: uuid!) {
+		multi_bids(where: { id: { _eq: $multiBidId } }) {
+			chain_id
+			cancelled_at
+			bids(where: { status: { _in: ["active", "inactive", "expired"] } }) {
+				nonce
+			}
+		}
+	}
+`;
+
+export const fetchMultibidChainIdAndExpiredSingleBidsById = gql`
+	query fetchMultibidChainIdAndExpiredSingleBidsById($multiBidId: uuid!, $expiredBidLimit: Int!) {
+		multi_bids(where: { id: { _eq: $multiBidId } }) {
+			chain_id
+			cancelled_at
+			bids(where: { status: { _eq: "expired" } }, limit: $expiredBidLimit) {
+				nonce
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchNftCollectionChainState.ts

@@ -0,0 +1,12 @@
+import { gql } from 'graphql-request';
+
+export const fetchNftCollectionChainState = gql`
+	query fetchNftCollectionChainState($nftTokenId: String!) {
+		nfts(where: { token_id: { _eq: $nftTokenId } }) {
+			collection {
+				id
+				chain_state
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchNftsById.ts

@@ -0,0 +1,75 @@
+import { gql } from 'graphql-request';
+
+export const fetchNftById = gql`
+	query fetchNftById($nftId: uuid!) {
+		nfts(where: { id: { _eq: $nftId } }) {
+			id
+			token_id
+			collection_id
+			properties
+			chain_state
+			listed
+			owner
+			contract {
+				properties
+			}
+			listings(where: { listed: { _eq: true } }) {
+				price
+				nonce
+				market_name
+			}
+			collection {
+				id
+				chain_state
+			}
+		}
+	}
+`;
+
+export const fetchNftsById = gql`
+	query fetchNftsById($nftIds: [uuid!]) {
+		nfts(where: { id: { _in: $nftIds } }) {
+			id
+			token_id
+			collection_id
+			properties
+			chain_state
+			listed
+			owner
+			contract {
+				properties
+			}
+			collection {
+				id
+				chain_state
+			}
+		}
+	}
+`;
+
+export const fetchNftsWithListingsById = gql`
+	query fetchNftsWithListingsById($nftIds: [uuid!]) {
+		nfts(where: { id: { _in: $nftIds } }) {
+			id
+			token_id
+			collection_id
+			properties
+			chain_state
+			listed
+			contract {
+				properties
+			}
+			listings {
+				listed
+				market_name
+				price
+				nonce
+				seller
+			}
+			collection {
+				id
+				chain_state
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchNftsByKioskId.ts

@@ -0,0 +1,45 @@
+import { gql } from 'graphql-request';
+
+export const fetchNftsByKioskId = gql`
+	query fetchNftsByKioskId($jsonFilter: jsonb) {
+		nfts(where: { chain_state: { _contains: $jsonFilter } }) {
+			id
+			name
+			token_id
+			properties
+			chain_state
+			collection_id
+			claimable_reason
+			owner
+			contract {
+				properties
+			}
+			collection {
+				id
+				chain_state
+			}
+		}
+	}
+`;
+
+export const fetchBulkNftsByKioskId = gql`
+	query fetchNftsByKioskId($where: nfts_bool_exp) {
+		nfts(where: $where) {
+			id
+			name
+			token_id
+			properties
+			chain_state
+			collection_id
+			claimable_reason
+			owner
+			contract {
+				properties
+			}
+			collection {
+				id
+				chain_state
+			}
+		}
+	}
+`;

package/src/graphql/queries/fetchOwnerCapByKiosk.ts

@@ -0,0 +1,10 @@
+import { gql } from 'graphql-request';
+
+export const fetchOwnerCapByKiosk = gql`
+	query fetchOwnerCapByKiosk($kioskId: String!) {
+		ownerCap: kiosk_owner_cap_by_kiosk(kiosk_id: $kioskId) {
+			id
+			kiosk_id
+		}
+	}
+`;

package/src/graphql/queries/fetchPersonalCapByKiosk.ts

@@ -0,0 +1,10 @@
+import { gql } from 'graphql-request';
+
+export const fetchPersonalCapByKiosk = gql`
+	query fetchPersonalCapByKiosk($kioskId: String!) {
+		personalCap: personal_kiosk_cap_by_kiosk(kiosk_id: $kioskId) {
+			id
+			kiosk_id
+		}
+	}
+`;

package/src/graphql/queries/fetchSharedObjectsByType.ts

@@ -0,0 +1,12 @@
+import { gql } from 'graphql-request';
+
+export const fetchSharedObjectsByType = gql`
+	query fetchSharedObjectsByType($type: String!) {
+		sharedObjects: shared_objects_by_type(type: $type) {
+			id
+			module
+			pkg
+			type
+		}
+	}
+`;

package/src/graphql/queries/fetchTransferPoliciesByType.ts

@@ -0,0 +1,12 @@
+import { gql } from 'graphql-request';
+
+export const fetchTransferPoliciesByType = gql`
+	query fetchTransferPoliciesByType($type: String!) {
+		transfer_policies_by_type(type: $type) {
+			id
+			is_origin_byte
+			rules
+			type
+		}
+	}
+`;

package/src/graphql/queries/fetchWalletKiosks.ts

@@ -0,0 +1,14 @@
+import { gql } from 'graphql-request';
+
+export const fetchWalletKiosks = gql`
+	query fetchWalletKiosks($wallet: String!) {
+		kiosks: kiosks_by_owner_address(owner_address: $wallet) {
+			id
+			is_origin_byte
+			is_personal
+			owner_address
+			profits
+			is_shared
+		}
+	}
+`;

package/src/graphql/queries/getCommissionByListingId.ts

@@ -0,0 +1,15 @@
+import { gqlChainRequest } from '../gqlChainRequest';
+import { fetchCommissionByNftContractId } from './fetchCommissionByListingId';
+
+export const getCommissionByNftContractId = async (nftContractId: string) => {
+	try {
+		const res = await gqlChainRequest({
+			chain: 'sui',
+			query: fetchCommissionByNftContractId,
+			variables: { nftContractId },
+		});
+		return res?.commissions?.[0];
+	} catch (err) {
+		throw new Error(`Failed to fetch commission for listing ${nftContractId}`);
+	}
+};

package/src/helpers/addOneDollarFee.ts

@@ -0,0 +1,17 @@
+import { type Transaction } from '@mysten/sui/transactions';
+import { TRADEPORT_BENEFICIARY_ADDRESS } from '../constants';
+import { addLeadingZerosAfter0x } from '../utils/addLeadingZerosAfter0x';
+import { getSuiToUsdRate } from './getSuiToUsdRate';
+
+export const addOneDollarFee = async (tx: Transaction) => {
+	const rate = await getSuiToUsdRate();
+
+	const companyFee = BigInt(Math.ceil(1_000_000_000 / rate));
+
+	const [microTxFee] = tx.splitCoins(tx.gas, [tx.pure.u64(Number(companyFee))]);
+
+	tx.transferObjects(
+		[tx.object(microTxFee)],
+		tx.pure.address(addLeadingZerosAfter0x(TRADEPORT_BENEFICIARY_ADDRESS)),
+	);
+};

package/src/helpers/addThirdPartyTxFee.ts

@@ -0,0 +1,17 @@
+import { type Transaction } from '@mysten/sui/transactions';
+import {
+	TRADEPORT_BENEFICIARY_ADDRESS,
+	TRADEPORT_THIRD_PARTY_FEE_DECIMAL_PERCENT,
+} from '../constants';
+import { addLeadingZerosAfter0x } from '../utils/addLeadingZerosAfter0x';
+
+export const addThirdPartyTxFee = async (tx: Transaction, price: number) => {
+	const [microTxFee] = tx.splitCoins(tx.gas, [
+		tx.pure.u64(price * TRADEPORT_THIRD_PARTY_FEE_DECIMAL_PERCENT),
+	]);
+
+	tx.transferObjects(
+		[tx.object(microTxFee)],
+		tx.pure.address(addLeadingZerosAfter0x(TRADEPORT_BENEFICIARY_ADDRESS)),
+	);
+};