@mojito-inc/core-service
Advanced tools
👨💻 React components for the Mojito Platform, Reference App and third-party projects, including Mojito's core service
Version: 1.0.0
You can install this project with one of these commands: npm i @mojito-inc/core-service
yarn add @mojito-inc/core-service
You can install the package with one of these commands:
npm i graphql
yarn add graphql
Once the package is installed, you can import the library using import;
Two way of integration Core API provider uri or apollo client, if pass both param priority is client only.
baseURL = https://api.mojito.xyz/query
baseURL = https://api-dev.mojito.xyz/query
import { CoreServiceProvider } from "@mojito-inc/core-service";
<CoreServiceProvider uri={ baseURL } token={ 'Bearer <Token>' }>
{ children }
</CoreServiceProvider>
| Param | type | Description |
|---|---|---|
| uri | string | skip this param, if client param passed |
| client | Apollo Client | skip this param, if uri param passed |
| token | string | Optional |
After setup with CoreServiceProvider, API can be access via hooks
following the api are
It will provide a message that should be used for in signing process
import { useClaims, Response, GetSignatureData } from "@mojito-inc/core-service";
const { getSignatureMessage } = useClaims();
const response: Response<GetSignatureData> = await getSignatureMessage({
orgId: <ORG_ID>,
networkID: <NETWORK_ID>,
walletAddress: <WALLET_ADDRESS>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| networkID | UUID1 | ✅ | |
| walletAddress | string | ✅ |
{
"data: {
"getSignatureMessage": "This message is used for signature validation for organization caa and wallet address 0x6588ec22a85d611c8c3cd254d0c063d0be78a6c1 at 2023-02-22T04:39:23Z"
}
}
The request receiver retrieves the Signature security token
import { useClaims, Response, LoginWithSignatureData } from "@mojito-inc/core-service";
const { loginWithSignature } = useClaims();
const response: Response<LoginWithSignatureData> = await loginWithSignature({
challenge: <GET_SIGNATURE_MESSAGE>,
signature: <CROSS_MINT_SIGNATURE>,
signer: <SIGNER_ADDRESS>,
chainId: <CHAIN_ID>,
orgId: <ORG_ID>,
name: <NAME>,
email: <EMAIL>
});
| Param | type | Required | Description |
|---|---|---|---|
| challenge | String | ✅ | |
| signature | String | ✅ | |
| signer | String | ✅ | |
| chainId | Int | ✅ | Int can represent values between -(2^31) and 2^31 - 1 |
| orgId | UUID1 | ✅ | |
| name | String | ||
| String |
{
"data": {
"loginWithSignature": {
"token": "344fbc51-b6d4-4428-9783-b09dd9df95fb"
}
}
}
Redeem a claimable code
import { useClaims, Response, RedeemClaimableCodeData } from "@mojito-inc/core-service";
const { redeemClaimableCode } = useClaims();
const response: Response<RedeemClaimableCodeData> = await redeemClaimableCode({
code: discountCode,
destAddr: address,
});
| Param | type | Required | Description |
|---|---|---|---|
| code | string | ✅ | |
| destAddr | string | ✅ |
{
"data": {
"redeemClaimableCode": {
"success": true
}
}
}
Redeem Earnable Item.
import { useClaims, RedeemEarnableItemData, Response } from '@mojito-inc/core-service';
const { redeemEarnableItem } = useClaims();
const response: Response<RedeemEarnableItemData> = await redeemEarnableItem({
claimableItemId: claimableItemId,
destAddr: destAddr,
gating: gating
});
| Param | type | Required | Description |
|---|---|---|---|
| claimableItemId | string | ✅ | |
| destAddr | string | ||
| gating | object | gating |
| Param | type | Required | Description |
|---|---|---|---|
| ruleId | string | ✅ | |
| contractAddress | string | ✅ | |
| tokenId | string | ✅ | |
| ownerWallet | string | ✅ |
Get the Invoice detail of the Given invoice id.
import { useClaims, Response, GetClaimInvoiceDetailData } from '@mojito-inc/core-service';
const { getInvoiceDetails } = useClaims();
const response: Response<GetClaimInvoiceDetailData> = await getInvoiceDetails({
invoiceID: invoiceID
});
| Param | type | Required | Description |
|---|---|---|---|
| invoiceID | string | ✅ |
Redeem a claimable code
import { useClaims, Response, RedeemEarnableCodeData } from "@mojito-inc/core-service";
const { redeemEarnableCode } = useClaims();
const response: Response<RedeemEarnableCodeData> = await redeemEarnableCode({
code: discountCode,
destAddr: address,
});
| Param | type | Required | Description |
|---|---|---|---|
| code | string | ✅ | |
| destAddr | string |
{
"data": {
"redeemEarnableCode": {
"redeemInitiated": true,
"invoiceID": "278806fb-d82c-4d9c-bda0-ace148452c00"
}
}
}
will receives 1 unit crypto equivalent USD price
import { useConversion, Response, USDConversionData } from '@mojito-inc/core-service';
const { getUSDConversion } = useConversion();
const response: Response<USDConversionData> = await getUSDConversion({ cryptoCurrencyCode: <cryptoCurrencyCode> });
| Param | type | Required | Description |
|---|---|---|---|
| cryptoCurrencyCode | enum | ✅ | CryptoCurrencyCode |
| Enum Variable | value |
|---|---|
| ETH | ETH |
| MATIC | MATIC |
| WETH | WETH |
| WMATIC | WMATIC |
{
"data": {
"getUSDPrice": {
"amount": "1799.34",
"currency": "USD",
"base": "ETH",
}
}
}
will receives list of supported currency by id
import { useConversion, Response, GetSupportedCurrenciesData } from '@mojito-inc/core-service';
const { getSupportedCurrency, GetSupportedCurrenciesData } = useConversion();
const response: Response<GetSupportedCurrenciesData> = await getSupportedCurrency({ nftTokenId: '514fedfe-165b-451b-b2f6-63667e66c096', orgId: 'f2f5c627-5421-4c40-9913-edfd09dd98b3' });
| Param | type | Required | Description |
|---|---|---|---|
| nftTokenId | UUID | ✅ | |
| orgId | UUID | ✅ |
{
"data": {
"getSupportedCurrencies": [
{
"id": "8b2343d6-8a8b-11ed-9e0a-42010a940031",
"name": "ETH",
"networkId": "c41db347-0ee3-4212-943a-ca213b8e0ea8",
"symbol": "ETH",
"contractAddress": "0x0000000000000000000000000000000000000000",
"secondaryMarketplaceContractAddress": "0xB658b650F0B2Dacd90aF58Ad78b3a6F8eb9BdF21",
"network": {
"id": "c41db347-0ee3-4212-943a-ca213b8e0ea8",
"name": "Goerli Testnet",
"chainID": 5,
"wethAddress": "0xB4FBF271143F4FBf7B91A5ded31805e42b2208d6",
"paymentCurrency": "WETH"
}
},
]
}
}
Auction Details and Auction History
import { useAuction } from '@mojito-inc/core-service';
const { auctionDetails } = useAuction();
const response: Response<AuctionData> = await auctionDetails({ id: <ID> });
| Param | type | Required | Description |
|---|---|---|---|
| id | UUID | ✅ |
{
"data": {
"collectionItemById": {
"id": "8ed1783c-c4c4-47f1-9384-5ff64f2ebc97",
"name": "POCA During Sale 2",
"artist": null,
"status": "Active",
"description": null,
"details": {
"id": "68d2fee2-db56-48f4-9e10-e703e9054ae6",
"startingBid": 0.0001,
"startDate": "2023-03-22T05:00:00Z",
"endDate": "2023-03-22T11:00:00Z",
"currentBid": {
"userId": "afca6cad-782c-4338-b71d-9193b14b736d",
"currentBid": 0.0002,
"isMine": false,
"walletAddress": "0x669dbFF9c68CAC7b52C4B789f5Ebc3b5293D0a73",
"marketplaceUser": {
"id": "afca6cad-782c-4338-b71d-9193b14b736d",
"username": null,
"avatar": null,
},
},
"myBid": null,
"bids": [
{
"id": "9b407667-fc96-4022-a892-8c5d2fea4e52",
"amount": 0.0002,
"createdAt": "2023-03-22T09:32:15Z",
"maximumBid": null,
"marketplaceAuctionLotId": "68d2fee2-db56-48f4-9e10-e703e9054ae6",
"walletAddress": "0x669dbFF9c68CAC7b52C4B789f5Ebc3b5293D0a73",
"txHash": "0xa6d9d6474e759134bd85d9111376366a3e8360f93eafc723646967c63d675422",
"marketplaceUser": {
"id": "afca6cad-782c-4338-b71d-9193b14b736d",
"username": null,
"avatar": null,
},
}
],
},
}
}
}
Receive tax and contract address
import { useAuction, OnChainBidResponse } from '@mojito-inc/core-service';
const { verifyOnChainBid } = useAuction();
const response: Response<OnChainBidResponse> = await verifyOnChainBid({
lotID=<lotID>,
orgID=<orgID>,
walletAddress=<walletAddress>,
amount: <amount>, });
| Param | type | Required | Description |
|---|---|---|---|
| lotID | UUID | ✅ | |
| orgID | UUID | ✅ | |
| walletAddress | string | ✅ | |
| amount | Int | ✅ |
{
"data": {
"verifyOnchainBid": {
"amount": 0.0003,
"tax": 0.000055575933397801415,
"onChainAuctionContractAddress": "0xeed7f3e16a6018d65dffd63bc30ac252c034edc1",
"commissionFee": 0.000005999999999999999,
"platformFee": 0.000005999999999999999,
"__typename": "OnChainBidResponse"
}
}
}
Auction submit
import { confirmOnChainBid, BidsItemData } from '@mojito-inc/core-service';
const { confirmOnChainBid } = useAuction();
const response: Promise<Response<BidsItemData>> = await confirmOnChainBid({
lotID=<lotID>
orgID=<orgID>
walletAddress=<walletAddress>
amount=<amount>
tax=<tax>
txhash=<txhash>
commissionFee=<commissionFee>
platformFee<platformFee<> });
{
"data": {
"confirmOnchainBid": {
"amount": 0.0005,
"tax": 0.00007216969871926542,
"__typename": "MarketplaceAuctionBid"
}
}
}
Create Auction Bid
import { createMarketplaceAuctionBid, CreateMarketplaceAuctionBidData } from '@mojito-inc/core-service';
const { createMarketplaceAuctionBid } = useAuction();
const response: Promise<Response<CreateMarketplaceAuctionBidData> = await createMarketplaceAuctionBid({
marketplaceAuctionLotId=<marketplaceAuctionLotId>
amount=<amount> });
{
"data": {
"createMarketplaceAuctionBid": {
"id": "95962a20-2194-493e-ba2d-7abc5cea93bf",
"marketplaceAuctionLotId": "95962a20-2194-493e-ba2d-7abc5cea93bf",
"amount": 0.0005,
}
}
}
User API can be access via hooks
following the api are
It will provide a active user data
import { useUser, GetUserData } from "@mojito-inc/core-service";
const { currentUser } = useUser();
const response: Response<GetUserData> = await currentUser({
orgId: <ORG_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ |
{
"data: {
"me": {
"id": "d1a59f7e-8626-46f9-b0ca-b70477910c8c",
"userOrgs": [
{
"id": "30ec5163-90bc-4b6a-a0a1-8696cc19c327",
"role": "Admin",
"organizationId": "d086ea16-d40d-454c-84a4-64b5e940670a",
"organization": {
"purchaseLimitWithoutKYC": 0
},
"kycStatus": "Clear",
"w8Form": true,
"isBlacklisted": false,
"bidAllowed": true,
"avatar": null,
"username": "020704f2-cb16-4c26-bed0-4ac0dbdf67bb",
"settings": null,
"reason": ""
}
]
}
}
}
It can able to update the user details
import { useUser, updateUserOrgSettingsData } from "@mojito-inc/core-service";
const { updateUserOrgSettings } = useUser();
const response: Response<updateUserOrgSettingsData> = await updateUserOrgSettings({
userOrgId: <USER_ORG_ID>,
username: <USER_NAME>,
avatar: <AVATAR>,
settingsJson: <SETTING_JSON>,
profilePic: <PROFILE_PIC>
});
| Param | type | Required | Description |
|---|---|---|---|
| userOrgId | UUID1 | ✅ | |
| username | String | ✅ | |
| avatar | String | ✅ | |
| settingsJson | String | ||
| profilePic | String |
{
"data: {
"updateUserOrgSettings": {
"id": "d1a59f7e-8626-46f9-b0ca-b70477910c8c",
"username": "test",
"avatar": "U0BpDFXLEKmMNPly",
}
}
}
KYC API can be access via hooks
following the api are
It can able to create form to complete KYC
import { useKYC } from "@mojito-inc/core-service";
const { createApplicant } = useKYC();
const response: Response<CreateApplicantData> = await createApplicant({
orgID: <ORG_ID>,
input: {
firstName: <FIRST_NAME>,
lastName: <LAST_NAME>,
dob: <DATE_OF_BIRTH>,
address: {
country: <COUNTRY>,
state: <STATE>,
town: <TOWN>,
postcode: <POSTAL_CODE>
}
},
});
| Param | type | Required | Description |
|---|---|---|---|
| orgID | UUID1 | ✅ | |
| input | ApplicantRequest | ✅ |
{
"data: {
"createApplicant": {
"id": "7578afa6-cb7e-45cc-82ef-5c5821ebec42",
"firstName": "test",
"lastName": "test",
"email": "",
"dob": "1998-12-22",
"href": "/v3.2/applicants/7578afa6-cb7e-45cc-82ef-5c5821ebec42",
"idNumbers": null,
"address": {
"flatNumber": null,
"buildingNumber": "12",
"buildingName": null,
"street": "test road",
"subStreet": null,
"town": "new york",
"postcode": "12345",
"country": "US",
"line1": null,
"line2": null,
"line3": null,
"state": "new york"
}
}
}
}
It can able to check the details
import { useKYC } from "@mojito-inc/core-service";
const { createCheck } = useKYC();
const response: Response<CreateCheckData> = await createCheck({
applicantID: <APPLICANT_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| applicantID | UUID1 | ✅ |
{
"data: {
"createCheck": {
"id": "c2854107-93b6-4200-a1f7-ad28beaa9d1d",
"success": true
}
}
}
It can able to get user kyc details
import { useKYC } from "@mojito-inc/core-service";
const { getApplicant } = useKYC();
const response: Response<GetApplicantData> = await getApplicant({
organizationID: <ORGANIZATION_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| organizationID | UUID1 | ✅ |
{
"data: {
"getApplicant": {
"id": "262f085c-474b-44be-8568-e1b58a16c97f",
"firstName": "test",
"lastName": "test",
"email": "",
"dob": "1998-12-22",
"href": "/v3.2/applicants/7578afa6-cb7e-45cc-82ef-5c5821ebec42",
"idNumbers": null,
"address": {
"flatNumber": null,
"buildingNumber": "12",
"buildingName": null,
"street": "test road",
"subStreet": null,
"town": "new york",
"postcode": "12345",
"country": "US",
"line1": null,
"line2": null,
"line3": null,
"state": "new york"
}
}
}
}
It can able to get sdk token
import { useKYC } from "@mojito-inc/core-service";
const { getSDKToken } = useKYC();
const response: Response<GetSDKTokenData> = await getSDKToken({
applicantID: <APPLICANT_ID>,
referrer: <REFERRER>,
});
| Param | type | Required | Description |
|---|---|---|---|
| applicantID | UUID1 | ✅ | |
| referrer | String | ✅ |
{
"data: {
"getSDKToken": {
"token": "eyJhbGciOiJFUzUxMiJ9.eyJleHAiOjE2ODExMTgzNjEsInBheWxvYWQiOnsiYXBwIjoiNzU3OGFmYTYtY2I3ZS00NWNjLTgyZWYtNWM1ODIxZWJlYzQyIiwiY2xpZW50X3V1aWQiOiIyMmQyYzQ1NC0zNzMxLTQ4N2UtYmUzYS05N2I4NmQ4NWYzOWMiLCJpc19zYW5kYm94Ijp0cnVlLCJpc19zZWxmX3NlcnZpY2VfdHJpYWwiOmZhbHNlLCJpc190cmlhbCI6ZmFsc2UsInJlZiI6Imh0iHBzOi8vd2hpc2tleWV4Y2hhbmdlLWRldi5uZXRsaWZ5LmFwcC8iLCJzYXJkaW5lX3Nlc3Npb24iOiI1NzkxMGUyMC0yMTljLTQxZTItOTUzOS1lYjJhYjFmZDdiZTQifSwidXVpZCI6InBsYXRmb3JtX3N0YXRpY19hcGlfdG9rZW5fdXVpZCIsInVybHMiOnsiZGV0ZWN0X2RvY3VtZz50X3VybCI6Imh0dHBzOi8vc2RrLnVzLm9uZmlkby5jb20iLCJzeW5jX3VybCI6Imh0dHBzOi8vc3luYy5vbmZpZG8uY29tIiwiaG9zdGVkX3Nka191cmwiOiJodHRwczovL2lkLm9uZmlkby5jb20iLCJhdXRoX3VybCI6Imh0dHBzOi8vYXBpLnVzLm9uZmlkby5jb20iLCJvbmZpZG9fYXBpX3VybCI6Imh0dHBzOi8vYXBpLnVzLm9uZmlkby5jb20iLCJ0ZWxlcGhvbnlfdXJsIjoiaHR0cHM6Ly9hcGkudXMub25maWRvLmNvbSJ9fQ.MIGIAkIAtiM1UkIpaTKIGeTn6sYfX3GR4fTWPq_AeU1RxwQDQu5S7K3NM1z5hzh01sTo3KK_elpMh27XC0mhR9MkLt3kkroCQgG9gAW4w0vO1k1dXJKzbq3WDpklTqXtjT3plDbe5_bM8QujgjlbaW7nkASg68BYqa7P5UHOI5p-_QBayflaU3wXa"
}
}
}
It can able to update the user kyc details
import { useKYC } from "@mojito-inc/core-service";
const { updateApplicant } = useKYC();
const response: Response<UpdateApplicantData> = await updateApplicant({
orgID: <ORG_ID>,
input: {
firstName: <FIRST_NAME>,
lastName: <LAST_NAME>,
dob: <DATE_OF_BIRTH>,
address: {
country: <COUNTRY>,
state: <STATE>,
town: <TOWN>,
postcode: <POSTAL_CODE>
}
},
});
| Param | type | Required | Description |
|---|---|---|---|
| orgID | UUID1 | ✅ | |
| input | ApplicantRequest | ✅ |
{
"data: {
"updateApplicant": {
"id": "7578afa6-cb7e-45cc-82ef-5c5821ebec42",
"firstName": "test",
"lastName": "test",
"email": "",
"dob": "1998-12-22",
"href": "/v3.2/applicants/7578afa6-cb7e-45cc-82ef-5c5821ebec42",
"idNumbers": null,
"address": {
"flatNumber": null,
"buildingNumber": "12",
"buildingName": null,
"street": "test road",
"subStreet": null,
"town": "new york",
"postcode": "12345",
"country": "US",
"line1": null,
"line2": null,
"line3": null,
"state": "new york"
}
}
}
}
Connect wallet API can be access via hooks
following the api are
It can able to connect wallet
import { useConnectWallet, ConnectExternalWalletData } from "@mojito-inc/core-service";
const { connectExternalWallet } = useConnectWallet();
const response: Response<ConnectExternalWalletData> = await connectExternalWallet({
signature: <SIGNATURE>,
message: <MESSAGE>,
address: <ADDRESS>,
orgID: <ORG_ID>,
networkID: <NETWORK_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgID | UUID1 | ✅ | |
| networkID | UUID1 | ✅ | |
| message | String | ✅ | |
| signature | String | ✅ | |
| address | String | ✅ |
{
"data": {
"connectExternalWallet": true
}
}
It can able to get wallet data
import { useConnectWallet, GetActiveWalletsContentData } from "@mojito-inc/core-service";
const { getActiveWalletsContent } = useConnectWallet();
const response: Response<GetActiveWalletsContentData> = await getActiveWalletsContent({
orgID: <ORG_ID>,
networkId: <NETWORK_ID>,
walletAddress: <WALLET_ADDRESS>,
filters: <FILTERS>,
refreshCache: <REFRESH_CACHE>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgID | UUID1 | ✅ | |
| networkId | UUID1 | ✅ | |
| walletAddress | String | ✅ | |
| filters | ActiveWalletFilterInput | ||
| refreshCache | Boolean |
{
"data": {
"getActiveWalletsContent": {
"tokens": [
{
"contractAddress": "0xd0e2fd21764f643fa32b06a4c7d7924f43138d90",
"id": "6",
"network": "Goerli Testnet",
"tokenType": "ERC1155",
"title": "BasedHead #6",
"tokenURI": "https://drops.api.topdogstudios.io/basedAf/token/6",
"nftTokenId": "5bc739a6-f5d3-4417-b4af-91687e0af525",
"mintedAt": "2023-01-25T14:18:02Z",
"status": "SALE_PENDING",
"metadata": {
"name": "BasedHead #6",
"description": "This PFP will be affiliated to the Fraz corporation.\n\nFraz is believed to have begun in the mid-1800s as the JP Fraz and Sons Tinctures and Cure-all Company. However, the lack of any supporting evidence that TrashLand existed before the 1980s suggests that this may not be factually correct. Fraz makes a variety of different food items, all alcoholic beverages, which are distilled from edible shore drift sourced on the island. In 2022, Fraz was announced as the official drink of the Metaverse.\n\n[Download V0 BasedHead](https://ipfs.io/ipfs/QmWiDG1zG7vncPYXMEVSkRYcn2gsujAACSyUsbXvD33ezC)",
"image": "https://ipfs.io/ipfs/QmQJBFoLqcgxDogd5pLgbMKn6u4RPiu1djUfecuZxMhdzk",
"animationURL": "",
"openSeaImageURL": ""
},
"contractName": "test",
"artistName": "Test",
},
]
}
}
}
It can able to get the supported networks list
import { useConnectWallet, GetSupportedNetworksData } from "@mojito-inc/core-service";
const { getSupportedNetworks } = useConnectWallet();
const response: Response<GetSupportedNetworksData> = await getSupportedNetworks({
orgId: <ORG_ID>,
includeTestnets: <INCLUDE_TESTNETS>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| includeTestnets | Boolean |
{
"data": {
"getSupportedNetworks": [
{
"id": "f7babe75-2dfc-434a-9e3b-a28e101c4863",
"name": "Ethereum Mainnet",
"chainID": 1,
"isTestnet": false
},
{
"id": "c41db347-0ee3-4212-943a-ca213b8e0ea8",
"name": "Goerli Testnet",
"chainID": 5,
"isTestnet": true
},
]
}
}
List item API can be access via hooks
following the api are
It can able to create list item for sale
import { useListItem, CreateSignatureToListNFTForSaleData } from "@mojito-inc/core-service";
const { createSignatureToListNFTForSale } = useListItem();
const response: Response<CreateSignatureToListNFTForSaleData> = await createSignatureToListNFTForSale({
orgId: <ORG_ID>,
nftTokenId: <NFT_TOKEN_ID>,
tokenType: <TOKEN_TYPE>,
quantity: <QUANTITY>,
nftOwnerAddress: <NFT_OWNER_ADDRESS>,
fixedPrice: <FIXED_PRICE>,
paymentToken: <PAYMENT_TOKEN>,
currencyId: <CURRENCY_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| nftTokenId | UUID1 | ✅ | |
| tokenType | TokenType | ✅ | |
| quantity | Int | ✅ | |
| nftOwnerAddress | String | ✅ | |
| fixedPrice | Float | ✅ | |
| paymentToken | String | ✅ | |
| currencyId | UUID1 | ✅ |
{
"data": {
"createSignatureToListNFTForSale": {
"messageToSign": "0xc061ed6367ab12e87d93ac081487f069e4c8ba3b6bc100fec2a1afffd937f632",
"order": {
"id":"32dc6e44-79f3-4d2f-8068-94639e543a6e"
"nftTokenId":"6bd80dcd-9cc8-4078-a7e2-02c5164d7ab4"
"tokenContract":"0xd0e2fd21764f643fa32b06a4c7d7924f43138d90"
"tokenId":"15"
"tokenType":"ERC1155"
"quantity":1
"nftOwnerAddress":"0xC7e893488A039A341d935959E52f86085976F865"
"fixedPrice":0.04
"paymentToken":"0x0000000000000000000000000000000000000000"
"orderType":"LISTING"
}
}
}
}
It can able to remove listing an item
import { useListItem, RemoveListingData } from "@mojito-inc/core-service";
const { createSignatureToListNFTForSale } = useListItem();
const response: Response<RemoveListingData> = await removeListing({
orgID: <ORG_ID>,
nftTokenId: <NFT_TOKEN_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgID | UUID1 | ✅ | |
| nftTokenId | UUID1 | ✅ |
{
"data": {
"removeListing": "Listing removed."
}
}
It can able to submit approval for listing an item
import { useListItem, SubmitProofOfApprovalData } from "@mojito-inc/core-service";
const { submitProofOfApproval } = useListItem();
const response: Response<SubmitProofOfApprovalData> = await submitProofOfApproval({
orgID: <ORG_ID>,
nftTokenId: <NFT_TOKEN_ID>,
signature: <SIGNATURE>,
quantity: <QUANTITY>,
fixedPrice: <FIXED_PRICE>,
paymentToken: <PAYMENT_TOKEN>,
currencyId: <CURRENCY_ID>,
creatorFee: <CREATOR_FEE>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgID | UUID1 | ✅ | |
| nftTokenId | UUID1 | ✅ | |
| signature | String | ✅ | |
| quantity | Int | ||
| fixedPrice | Float | ||
| paymentToken | String | ||
| currencyId | UUID1 | ||
| creatorFee | TokenType |
{
"data": {
"submitProofOfApproval":"Signature updated."
}
}
Tax and fee API can be access via hooks
following the api are
It can able to get tax and fee data
import { useFee, EstimateTaxAndRoyaltyFeeData } from "@mojito-inc/core-service";
const { estimateTaxAndRoyaltyFee } = useFee();
const response: Response<EstimateTaxAndRoyaltyFeeData> = await estimateTaxAndRoyaltyFee({
orgId: <ORG_ID>,
estimateType: <ESTIMATE_TYPE>,
nftTokenId: <NFT_TOKEN_ID>,
orderId: <ORDER_ID>,
price: <PRICE>,
country: <COUNTRY>,
postalCode: <POSTAL_CODE>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| estimateType | TaxEstimateType | ✅ | |
| nftTokenId | UUID1 | ||
| orderId | UUID1 | ||
| price | Float | ||
| country | String | ||
| postalCode | String |
{
"data": {
"estimateTaxAndRoyaltyFee": {
"taxPercentage": 0,
"royaltyFee": 0,
"platformFee": 2.5,
"taxResponse": {
"cryptoTaxPrice": 0,
"cryptoTotalPrice": 1,
"USDUnitprice": 1920.88,
"taxPercentage": 0
}
}
}
}
It can able to get tax and fee data
import { useFee, GetTaxQuoteData } from "@mojito-inc/core-service";
const { getTaxQuote } = useFee();
const response: Response<GetTaxQuoteData> = await getTaxQuote({
orgID: <ORG_ID>,
taxablePrice: <TAXABLE_PRICE>,
street1: <STREET>,
city: <CITY>,
state: <STATE>,
postalCode: <POSTAL_CODE>,
country: <COUNTRY>,
currencyCode: <CURRENCY_CODE>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgID | UUID1 | ✅ | |
| taxablePrice | Float | ✅ | |
| street1 | String | ✅ | |
| city | String | ✅ | |
| state | String | ✅ | |
| postalCode | String | ✅ | |
| country | String | ✅ | |
| currencyCode | String |
{
"data": {
"getTaxQuote": {
"verifiedAddress": {
"street1": "",
"state": "Tamil Nadu",
"postalCode": "",
"country": "IN",
"currencyCode": "USD"
},
"taxablePrice": 76.6724,
"totalTaxedPrice": 76.6724,
"totalTaxAmount": 0
}
}
}
NFT API can be access via hooks
following the api are
It can able to get favorite NFT list
import { useNFT, GetNFTFavoriteListByUserData } from "@mojito-inc/core-service";
const { getNFTFavoriteListByUser } = useNFT();
const response: Response<GetNFTFavoriteListByUserData> = await getNFTFavoriteListByUser({
orgId: <ORG_ID>,
searchKey: <SEARCH_KEY>,
filter: <FILTER>,
limit: <LIMIT>,
offset: <OFFSET>,
buyerAddress: <BUYER_ADDRESS>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| searchKey | Number | ||
| filter | enum | SavedNFTFilterInput | |
| limit | Int | ||
| offset | Int | ||
| buyerAddress | String |
| Enum Variable | value |
|---|---|
| recently_listed | recently_listed |
| recently_minted | recently_minted |
| initially_minted | initially_minted |
| price_low_to_high | price_low_to_high |
| most_saved | most_saved |
| purchased_from_org | purchased_from_org |
{
"data": {
"getNFTFavouriteListByUser": {
"totalCount": 1,
"data": [
{
"id":"6"
"title":"BasedHead #6"
"status":"OPEN_FOR_SALE"
"network":"Goerli Testnet"
"networkID":"c41db347-0ee3-4212-943a-ca213b8e0ea8"
"tokenURI":"https://drops.api.topdogstudios.io/basedAf/token/6"
}
]
}
}
}
It can able to add NFT to favorite
import { useNFT, AddNFTToFavoriteData } from "@mojito-inc/core-service";
const { addNFTToFavorite } = useNFT();
const response: Response<AddNFTToFavoriteData> = await addNFTToFavorite({
orgID: <ORG_ID>,
tokenId: <TOKEN_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| tokenId | UUID1 | ✅ |
{
"data": {
"addNFTToFavourite": true,
}
}
It can able to remove NFT from favorite
import { useNFT, RemoveNFTFromFavoriteData } from "@mojito-inc/core-service";
const { removeNFTFromFavorite } = useNFT();
const response: Response<RemoveNFTFromFavoriteData> = await removeNFTFromFavorite({
orgID: <ORG_ID>,
tokenId: <TOKEN_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| tokenId | UUID1 | ✅ |
{
"data": {
"removeNFTFromFavourite": true,
}
}
It can able to get NFT list
import { useNFT, GetAllRegistryTokensData } from "@mojito-inc/core-service";
const { getAllRegistryTokens } = useNFT();
const response: Response<GetAllRegistryTokensData> = await getAllRegistryTokens({
orgID: <ORG_ID>,
searchKey: <SEARCH_KEY>,
filter: <FILTER>,
limit: <LIMIT>,
offset: <OFFSET>,
marketplaceID: <MARKETPLACE_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgID | UUID1 | ✅ | |
| searchKey | Number | ||
| filter | enum | RegistryTokenFilterInput | |
| limit | Int | ||
| offset | Int | ||
| buyerAddress | String | ||
| sort | RegistryTokenSortInput | ||
| artistID | UUID1 | ||
| registryID | UUID1 | ||
| categorySlug | String | ||
| artistSlug | String |
| Enum Variable | value |
|---|---|
| recently_listed | recently_listed |
| recently_minted | recently_minted |
| initially_minted | initially_minted |
| price_low_to_high | price_low_to_high |
| price_high_to_low | price_high_to_low |
{
"data": {
"getAllRegistryTokens": {
"totalCount": 1,
"data": [
{
"ID":"7992bcb2-1d34-4158-b07b-e8725016b1d1"
"TokenName":"BasedHead #15"
"TokenID":"15"
"Status":"OPEN_FOR_SALE"
"TokenURI":"https://drops.api.topdogstudios.io/basedAf/token/15"
"NFTTokenID":"6bd80dcd-9cc8-4078-a7e2-02c5164d7ab4"
}
]
}
}
}
It can able to get NFT list
import { useNFT, GetNFTDetailsData } from "@mojito-inc/core-service";
const { getNFTDetails } = useNFT();
const response: Response<GetNFTDetailsData> = await getNFTDetails({
orgId: <ORG_ID>,
contractAddress: <CONTRACT_ADDRESS>,
onChainTokenID: <ONCHAIN_TOKEN_ID>,
ownerAddress: <OWNER_ADDRESS>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| contractAddress | String | ||
| onChainTokenID | BigInt | ||
| ownerAddress | String | ||
| buyerAddress | String | ||
| editionNumber | Int | ||
| nftTokenId | UUID1 | ||
| networkId | UUID1 |
{
"data": {
"getNFTDetails": {
"contractAddress":"0xd0e2fd21764f643fa32b06a4c7d7924f43138d90"
"tokenId":"7"
"network":"Goerli Testnet"
"networkID":"c41db347-0ee3-4212-943a-ca213b8e0ea8"
"contractName":"test"
"tokenType":"ERC1155"
"mintedAt":"2023-01-25T06:40:22Z"
"status":"SALE_PENDING"
}
}
}
It can able to get NFT history
import { useNFT, GetNFTHistoryData } from "@mojito-inc/core-service";
const { getNFTHistory } = useNFT();
const response: Response<GetNFTHistoryData> = await getNFTHistory({
orgId: <ORG_ID>,
contractAddress: <CONTRACT_ADDRESS>,
tokenId: <TOKEN_ID>,
networkId: <NETWORK_ID>,
ownerAddress: <OWNER_ADDRESS>,
nftTokenId: <NFT_TOKEN_ID>,
limit: <LIMIT>,
offset: <OFFSET>
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| contractAddress | String | ✅ | |
| networkId | UUID1 | ✅ | |
| tokenId | BigInt | ✅ | |
| nftTokenId | UUID1 | ||
| ownerAddress | String | ||
| limit | Int | ||
| offset | Int |
{
"data": {
"getNFTHistoryV2": {
"totalCount": 30,
"data": [
{
"hash":"0xd3cc350c9020a32f699bea54824b90aa5adad6fbc5e09a0dbc2b78ce1415ae03",
"from":"0xa77915a574e1f9b88db152525ceBfEAA8c71bAa4",
"to":"test"
"blockTimestamp":"2023-01-27T12:41:23Z"
"eventType":"Sale"
"fromUserAvatar":"qvx3wQZawwkDtws2"
}
]
}
}
}
It can able to get NFT Traits
import { useNFT, GetNFTAttributesRarityData } from "@mojito-inc/core-service";
const { getNFTAttributesRarity } = useNFT();
const response: Response<GetNFTAttributesRarityData> = await getNFTAttributesRarity({
contractAddress: <CONTRACT_ADDRESS>,
tokenID: <TOKEN_ID>,
networkID: <NETWORK_ID>,
refreshCatch: <REFRESH_CACHE>,
});
| Param | type | Required | Description |
|---|---|---|---|
| contractAddress | String | ✅ | |
| networkID | UUID1 | ✅ | |
| tokenID | BigInt | ✅ | |
| refreshCatch | Boolean |
{
"data": {
"getNFTAttributesRarity": [
{
"traitType":"Brand",
"displayType":"",
"maxValue":0,
"prevalance":0,
"value": {
"__typename":"AttributeValueString",
"stringValue":"DGAF"
}
}
]
}
}
It can able to get order details
import { useNFT, InitiateBuyNFTData } from "@mojito-inc/core-service";
const { initiateBuyNFT } = useNFT();
const response: Response<InitiateBuyNFTData> = await initiateBuyNFT({
nftTokenId: <NFT_TOKEN_ID>,
buyerAddress: <BUYER_ADDRESS>,
orgId: <ORG_ID>,
country: <COUNTRY>,
postalCode: <POSTAL_CODE>,
currencyId: <CURRENCY_ID>,
cryptoTax: <CRYPTO_TAX>,
taxAddress: <TAX_ADDRESS>
});
| Param | type | Required | Description |
|---|---|---|---|
| nftTokenId | UUID1 | ✅ | |
| buyerAddress | String | ✅ | |
| orgId | UUID1 | ✅ | |
| country | String | ||
| postalCode | String | ||
| currencyId | UUID1 | ||
| cryptoTax | CryptoTax | ||
| taxAddress | TaxAddressInput |
{
"data": {
"initiateBuyNFT": {
"proofOfApproval":"0x28a9e439e3c091e737ff6209a1aa6f6022d8e7d16d738b2cbbc2fe8fad86630c341602d2653fcda2d02034278aee2a4fce9d6a48b7662ab67c5893c0fd857cf01c"
}
}
}
It can able to update the transaction hash
import { useNFT, UpdateTransactionHashData } from "@mojito-inc/core-service";
const { updateTransactionHash } = useNFT();
const response: Response<UpdateTransactionHashData> = await updateTransactionHash({
nftTokenId: <NFT_TOKEN_ID>,
orgId: <ORG_ID>,
buyerAddress: <BUYER_ADDRESS>,
transactionHash: <TRANSACTION_HASH>,
orderId: <ORDER_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| nftTokenId | UUID1 | ✅ | |
| orgId | UUID1 | ✅ | |
| buyerAddress | String | ✅ | |
| transactionHash | String | ✅ | |
| orderId | UUID1 |
{
"data": {
"updateTransactionHash": {
"success":false,
"newNFTID":"2bb1fec0-94be-499c-989c-1a2a75ceb478"
}
}
}
It will give a url to download invoice as a PDF format
import { useNFT, GenerateSecondaryInvoiceData } from "@mojito-inc/core-service";
const { generateSecondaryInvoice } = useNFT();
const response: Response<GenerateSecondaryInvoiceData> =
await generateSecondaryInvoice({
invoiceID: <INVOICE_ID>,
orderID: <ORDER_ID>,
activityName: <ACTIVITY_NAME>,
invoiceResType: <INVOICE_RES_TYPE>,
});
| Param | type | Required | Description |
|---|---|---|---|
| invoiceID | UUID1 | ✅ | |
| orderID | UUID1 | ✅ | |
| activityName | enum | ✅ | ActivityName |
| invoiceResType | enum | ✅ | InvoiceResType |
| Enum Variable | value |
|---|---|
| Listed_Item | Listed_Item |
| Listed_Item_Removed | Listed_Item_Removed |
| Sold_Item | Sold_Item |
| Offered | Offered |
| Offer_Cancelled | Offer_Cancelled |
| Offer_Rejected | Offer_Rejected |
| Offer_Expired | Offer_Expired |
| Bought_Item | Bought_Item |
| Enum Variable | value |
|---|---|
| base64 | base64 |
{
"data: {
"generateSecondaryInvoice": "https://storage.googleapis.com/mojito-dev-public/organizations/8fb128bd-f55d-4bcc-8b6c-0beb684e4d4e/invoices/208af15b-ae03-47c7-aa79-27ce453bcb2d_buyer.pdf"
}
}
It will give a url to download invoice as a PDF format
import { useNFT, GeneratePrimaryInvoiceData } from "@mojito-inc/core-service";
const { generatePrimaryInvoice } = useNFT();
const response: Response<GeneratePrimaryInvoiceData> =
await generatePrimaryInvoice({
invoiceID: <INVOICE_ID>,
invoiceResType: <INVOICE_RES_TYPE>,
});
| Param | type | Required | Description |
|---|---|---|---|
| invoiceID | UUID1 | ✅ | |
| invoiceResType | enum | ✅ | InvoiceResType |
| Enum Variable | value |
|---|---|
| base64 | base64 |
{
"data: {
"generatePrimaryInvoice": "https://storage.googleapis.com/mojito-dev-public/organizations/8fb128bd-f55d-4bcc-8b6c-0beb684e4d4e/invoices/208af15b-ae03-47c7-aa79-27ce453bcb2d_buyer.pdf"
}
}
It will provide a user order activity data
import { useUser, UserOrderActivityData } from "@mojito-inc/core-service";
const { userOrderActivity } = useUser();
const response: Response<UserOrderActivityData> = await userOrderActivity({
orgId: <ORG_ID>,
filter: <FILTER>,
limit: <LIMIT>,
offset: <OFFSET>
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| filter | enum | ✅ | OrderActivityFilters |
| limit | Int | ✅ | |
| offset | Int | ✅ |
| Enum Variable | value |
|---|---|
| LATEST_TO_OLDEST | LATEST_TO_OLDEST |
| LATEST_TO_OLDEST | LATEST_TO_OLDEST |
{
"data: {
"getUserOrderActivity": {
"totalCount": 529,
"data": [
{
"CreatedAt": "2023-03-29T10:52:18Z",
"nftImageUrl": "https://ipfs.io/ipfs/Qmf3YhCWVyansFPqunCfpCfKz9xNGzeMwYze7b359JR5xU",
"ActivityName": "Offered",
"TokenName": "BasedHead #8",
"TokenID": "8",
"NFTTokenID": "527ef338-2e68-4b62-a5d3-d1cb1ec81b30",
"ContractName": "test",
"ContractAddress": "0xd0e2fd21764f643fa32b06a4c7d7924f43138d90",
"Price": [
{
"value": 72.5217,
"unit": "USD"
},
{
"value": 0.04,
"unit": "WETH"
}
],
"NetworkID": "c41db347-0ee3-4212-943a-ca213b8e0ea8",
"TransactionHash": "",
"FromUserName": "rajesh1",
"ToUserName": "mainnet3",
"FromUserAvatar": "U0BpDFXLEKmMNPly",
"ToUserAvatar": "Ph9sz1la6hyMY3sd",
"FromWallet": {
"id": "4e89c916-3663-4d53-b549-1767c1e1a8d1",
"name": "rajesh account wallet",
"address": "0xc7e893488a039a341d935959e52f86085976f865"
},
"ToWallet": {
"id": "02eb2545-1c70-4f68-a856-aa7ed25bd013",
"name": "",
"address": "0xeAE67de0b3e913Ecb1Fae4d3bB936CD8dc282dD8"
},
"InvoiceURL": "",
"InvoiceID": null,
"OrderID": "c24a1370-9350-4516-82ab-6312b8ee571a",
"Status": "EXPIRED",
"cryptoTax": {
"cryptoTaxPrice": 0,
"cryptoTotalPrice": 0.04,
"USDUnitprice": 0.5,
"taxPercentage": 0
},
"order": {
"platformFee": 0.001,
"creatorFee": 0
}
}
]
}
}
}
It can be able to transfer NFT
import { useNFT, TransferNFTData } from "@mojito-inc/core-service";
const { transferNFT } = useNFT();
const response: Response<TransferNFTData> = await transferNFT({
walletId: <WALLET_ID>,
orgId: <ORG_ID>,
contractAddress: <CONTRACT_ADDRESS>,
tokenType: <TOKEN_TYPE>,
tokenOnChainId: <TOKEN_ONCHAIN_ID>,
amount: <AMOUNT>,
transferTo: <TRANSFER_TO>,
isClaimedToken: <IS_CLAIMEDTOKEN>,
});
| Param | type | Required | Description |
|---|---|---|---|
| walletId | UUID1 | ✅ | |
| orgId | UUID1 | ✅ | |
| contractAddress | string | ✅ | |
| tokenType | TokenType | ||
| tokenOnChainId | Int | ✅ | |
| amount | Int | ||
| transferTo | string | ✅ | |
| isClaimedToken | boolean |
{
"data": {
"transferToken": "transfered",
}
}
It will provide all the invoices data
import { useNFT, getAllInvoices } from "@mojito-inc/core-service";
const { getAllInvoices } = useNFT();
const response: Response<GetAllInvoicesData> = await getAllInvoices({
orgID: <ORG_ID>,
filter: <FILTER>,
limit: <LIMIT>,
offset: <OFFSET>
});
| Param | type | Required | Description |
|---|---|---|---|
| orgID | UUID1 | ✅ | |
| filter | enum | ✅ | OrderActivityFilters |
| limit | Int | ✅ | |
| offset | Int | ✅ |
| Enum Variable | value |
|---|---|
| LATEST_TO_OLDEST | LATEST_TO_OLDEST |
| LATEST_TO_OLDEST | LATEST_TO_OLDEST |
{
"data: {
"getAllInvoices": {
"count": 633,
"data": [
{
"id": "bec11a55-e92e-4491-b215-fa466717537c",
"createdAt": "2023-08-28T11:06:40Z",
"isSecondary": true,
"userID": "aae0fe77-1c48-45cd-a10c-55115713e4d7",
"status": "COMPLETED",
"totalPrice": 0.04,
"PriceCrypto": 0.04,
"usdItemPrice": 65.44640000000001,
"quantity": 1,
"transactionHash": "0x15ebacc1025202c0a9c3bf2200ec38ab4a55b0f446376ebab1acebef5ca7b422",
"invoiceID": "1cf8d0ab-3b1a-4f9a-bcd8-8e6d9d6d37aa",
"invoiceNumber": 27388,
"itemID": "890ee587-50ec-471d-9283-88b61655f5d0",
"tokenID": "3f24646a-7abe-414b-b510-e51a5e58e9fe",
"contractAddress": "0xe016a4a7ffa5b3305d1c2e1cdda13d92e11bb2da",
"onChainTokenID": "2",
"networkID": null,
"eventType": "List",
"fromWalletAddress": "0xa77915a574e1f9b88db152525ceBfEAA8c71bAa4",
"toWalletAddress": null,
"image": "https://storage.googleapis.com/mojito-dev-public/organizations/960ce62a-412d-43ee-b60d-da21ee1ea217/nft/assets/3f24646a-7abe-414b-b510-e51a5e58e9fe_2023-08-28T11:24:51.276062873Z.gif",
"itemName": "The Plague #2"
}
]
}
}
}
It can be able to get the FileSignedURL
import { useNFT, FileSignedUrlData } from "@mojito-inc/core-service";
const { getFileSignedUrl } = useNFT();
const response: Response<FileSignedUrlData> = await getFileSignedUrl({
urlInput: <FileSignedWithURL>,
input: <FileSignedWithGatingInput>,
});
| Param | type | Required | Description |
|---|---|---|---|
| urlInput | FileSignedWithURL | ||
| input | FileSignedWithGatingInput |
{
"data": {
"getFileSignedURL": {
mediaURL: "https://storage.cloud.google.com/mojito-dev-private/nft/0x0b1ee1de78a9d2db7b647834423a86e6c5bf1bdb/videos/1.mp4",
type: 'mp4'
},
}
}
Offer API can be access via hooks
following the api are
It can able to accept offer for an NFT
import { useOffer, AcceptOfferData } from "@mojito-inc/core-service";
const { acceptOffer } = useOffer();
const response: Response<AcceptOfferData> = await acceptOffer({
orgId: <ORG_ID>,
orderId: <ORDER_ID>,
transactionHash: <TRANSACTION_HASH>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| orderId | UUID1 | ✅ | |
| transactionHash | String | ✅ |
{
"data": {
"acceptOffer": {
"success":false
"newNFTID":"5bc739a6-f5d3-4417-b4af-91687e0af525"
}
}
}
It can able to cancel offer for an NFT
import { useOffer, CancelOfferData } from "@mojito-inc/core-service";
const { cancelOffer } = useOffer();
const response: Response<CancelOfferData> = await cancelOffer({
orgId: <ORG_ID>,
orderId: <ORDER_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| orderId | UUID1 | ✅ |
{
"data": {
"cancelOffer": "Offer cancelled."
}
}
It can able to create offer for an NFT
import { useOffer, CreateOfferData } from "@mojito-inc/core-service";
const { createOffer } = useOffer();
const response: Response<CreateOfferData> = await createOffer({
orgId: <ORG_ID>,
nftTokenId: <NFT_TOKEN_ID>,
buyerAddress: <BUYER_ADDRESS>,
offerPrice: <OFFER_PRICE>,
expiryDate: <EXPIRY_DATE>,
paymentToken: <PAYMENT_TOKEN>,
currencyId: <CURRENCY_ID>,
cryptoTax: <CRYPTO_TAX>,
taxAddress: <TAX_ADDRESS>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| nftTokenId | UUID1 | ✅ | |
| buyerAddress | String | ✅ | |
| offerPrice | Number | ✅ | |
| expiryDate | String | ✅ | |
| paymentToken | String | ✅ | |
| currencyId | String | ||
| cryptoTax | CryptoTax | ||
| taxAddress | TaxAddressInput |
{
"data": {
"createOffer": {
"messageToSign":"0xf94d966f32828f3313c3aaa72559ee78bd4c784a6c1b0c4763c297e20f720a96",
"order": {
"id":"ac444a12-703a-4495-8e99-b5634bab63ea"
"nftTokenId":"1942008c-3329-405f-980e-48b2f0ee9a08"
"tokenId":"10"
"tokenContract":"0xd0e2fd21764f643fa32b06a4c7d7924f43138d90"
"quantity":1
"nftOwnerAddress":"0xf724aE0B5662b8ad6D155D50522eb097247271cB"
"fixedPrice":0.04
}
}
}
}
It can able to get offers list for an NFT
import { useOffer, GetOffersData } from "@mojito-inc/core-service";
const { getOffers } = useOffer();
const response: Response<GetOffersData> = await getOffers({
orgId: <ORG_ID>,
nftTokenId: <NFT_TOKEN_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| nftTokenId | UUID1 | ✅ |
{
"data": {
"getOffers": [
{
"id": "ac444a12-703a-4495-8e99-b5634bab63ea"
"offerExpiryDate": "2023-04-14T10:40:00Z"
"nftOwnerAddress": "0xf724aE0B5662b8ad6D155D50522eb097247271cB"
"tokenType": "ERC1155"
"tokenId": "10"
"tokenContract": "0xd0e2fd21764f643fa32b06a4c7d7924f43138d90"
"orderStatus": "PENDING"
"buyerTax": 0
"buyerAddress": "0xC7e893488A039A341d935959E52f86085976F865"
"fixedPrice": 0.04
"updatedAt": "2023-04-13T10:40:55Z"
"createdAt": "2023-04-13T10:40:51Z"
}
]
}
}
It can able to get signature approval data for an NFT
import { useOffer, GetSignatureForOfferApprovalData } from "@mojito-inc/core-service";
const { getSignatureForOfferApproval } = useOffer();
const response: Response<GetSignatureForOfferApprovalData> = await getSignatureForOfferApproval({
orgId: <ORG_ID>,
orderId: <ORDER_ID>,
creatorFee: <CREATOR_FEE>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| orderId | UUID1 | ✅ | |
| creatorFee | Int |
{
"data": {
"getSignatureForOfferApproval": {
"proofOfApproval":"0xaf6e0275ba209ae723fdfe1b5411bebdf51f376d103ff9b227cedcc7b317974d09e698d1b9aea58e698a3724acd2fc8d3352eef96cb634bd735898f56f945da21c",
"order": {
"id":"d7bef205-2938-4443-b5b9-7f55db25da9a"
"nftTokenId":"5bc739a6-f5d3-4417-b4af-91687e0af525"
"tokenId":"6"
"tokenType":"ERC1155"
"quantity":1
"nftOwnerAddress":"0xc7e893488a039a341d935959e52f86085976f865"
"fixedPrice":0.04
}
}
}
}
It can able to reject offer for an NFT
import { useOffer, RejectOfferData } from "@mojito-inc/core-service";
const { rejectOffer } = useOffer();
const response: Response<RejectOfferData> = await rejectOffer({
orgId: <ORG_ID>,
orderId: <ORDER_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| orderId | UUID1 | ✅ |
{
"data": {
"rejectOffer": "Offer rejected."
}
}
It can able to submit proof of offer for an NFT
import { useOffer, SubmitProofOfOfferData } from "@mojito-inc/core-service";
const { submitProofOfOffer } = useOffer();
const response: Response<SubmitProofOfOfferData> = await submitProofOfOffer({
orgId: <ORG_ID>,
orderId: <ORDER_ID>,
signature: <SIGNATURE>,
});
| Param | type | Required | Description |
|---|---|---|---|
| orgId | UUID1 | ✅ | |
| orderId | UUID1 | ✅ | |
| signature | String | ✅ |
{
"data": {
"submitProofOfOffer":"Signature updated."
}
}
Token Gating API can be access via hooks
following the api are
This API is used to create a Token Gating for an NFT.
import { useTokenGating, CreateTokenGatingData } from "@mojito-inc/core-service";
const { createTokenGating } = useTokenGating();
const response: Response<CreateTokenGatingData> = await createTokenGating({
input: {
orgID: <ORG_ID>,
networkId: <NETWORK_ID>,
rule: <GatingRule>,
groupName: <GROUP_NAME>,
groupId: <GROUP_ID>,
}
});
| Param | type | Required | Description |
|---|---|---|---|
| orgID | UUID1 | ✅ | |
| networkId | UUID1 | ✅ | |
| groupId | UUID1 | ||
| groupName | String | ||
| rule | GatingRule | ✅ | GatingRule |
| Param | type | Required | Description |
|---|---|---|---|
| ruleType | enum | ✅ | RuleType |
| contractAddress | String | ||
| contractAddressWithTokenId | contractAddressWithTokenId | ContractAddressWithTokenIDGating | |
| metaData | MetaDataGating | MetaDataGating | |
| onchain | enum | OnchainGating |
| Param | type | Required | Description |
|---|---|---|---|
| contractAddress | String | ||
| tokenID | Int |
| Param | type | Required | Description |
|---|---|---|---|
| key | String | ||
| value | String |
| Enum Variable | value |
|---|---|
| ContractAddress | ContractAddress |
| ContractAddressWithTokenID | ContractAddressWithTokenID |
| MetaData | MetaData |
| Onchain | Onchain |
| Enum Variable | value |
|---|---|
| ONCHAIN | ONCHAIN |
{
"data": {
"createTokenGatingRule": {
"id": "8bb24c9a-6b46-44d0-a2f7-3439c4bdd4ef",
"groupName": "TEST GATING SEPOLIA",
"networkID": "b260424b-bb37-4a3e-86d0-0866175e5e68",
"organizationID": "f2f5c627-5421-4c40-9913-edfd09dd98b3",
"rules": [
{
"id": "85d9b667-44c2-4bec-9e8a-ddf0e04cc107",
"gatingGroupId": "8bb24c9a-6b46-44d0-a2f7-3439c4bdd4ef",
"ruleType": "MetaData",
"rules": {
"metaData": [
{
"key": "name",
"value": "Milady 1"
},
{
"key": "description",
"value": "Milady Maker is a collection of 10,000 generative pfpNFT's in a aesthetic inspired by street style tribes."
}
]
}
}
]
}
}
}
This API is used to check whether the nft is Gated or not.
import { useTokenGating, CheckTokenGatingData } from "@mojito-inc/core-service";
const { checkTokenGating } = useTokenGating();
const response: Response<CheckTokenGatingData> = await checkTokenGating({
groupID: <GROUP_ID>,
ruleID: <RULE_ID>,
buyerAddress: <BUYER_ADDRESS>,
contractAddress: <CONTRACT_ADDRESS>,
tokenId: <TOKEN_ID>,
});
| Param | type | Required | Description |
|---|---|---|---|
| groupID | UUID1 | ✅ | |
| ruleID | UUID1 | ||
| buyerAddress | String | ||
| contractAddress | String | ||
| tokenId | String |
{
"data": {
"checkTokenGating": {
"isGated": true,
"gatedTokens": [
{
"id": "1",
"title": "Milady 1",
"description": "Milady Maker is a collection of 10,000 generative pfpNFT's in a aesthetic inspired by street style tribes.",
"tokenURI": "https://www.miladymaker.net/milady/json/1",
"tokenType": "ERC721",
"contractName": "Milady",
"contractAddress": "0x3e9d45ad0da57683b5375d0f3d5bc606429128f9",
"metadata": {
"name": "Milady 1",
"description": "Milady Maker is a collection of 10,000 generative pfpNFT's in a aesthetic inspired by street style tribes.",
"image": "https://www.miladymaker.net/milady/1.png",
"attributes": [
{
"traitType": "Background",
"value": {
"stringValue": "bjork"
}
}
],
"animationURL": "",
"openSeaImageURL": ""
}
}
]
}
}
}
This API is used to check whether the nft is Gated or not.
import { useTokenGating, CheckTokenGatingV2Data } from "@mojito-inc/core-service";
const { checkTokenGatingV2 } = useTokenGating();
const response: Response<CheckTokenGatingV2Data> = await checkTokenGatingV2({
groupID: <GROUP_ID>,
ruleID: <RULE_ID>,
buyerAddress: <BUYER_ADDRESS>,
});
| Param | type | Required | Description |
|---|---|---|---|
| groupID | UUID1 | ✅ | |
| ruleID | UUID1 | ||
| buyerAddress | String | ✅ |
{
"data": {
"checkTokenGatingV2": {
"isGated": true,
"gatedTokens": [
{
"id": "1",
"title": "Milady 1",
"description": "Milady Maker is a collection of 10,000 generative pfpNFT's in a aesthetic inspired by street style tribes.",
"tokenURI": "https://www.miladymaker.net/milady/json/1",
"tokenType": "ERC721",
"contractName": "Milady",
"contractAddress": "0x3e9d45ad0da57683b5375d0f3d5bc606429128f9",
"metadata": {
"name": "Milady 1",
"description": "Milady Maker is a collection of 10,000 generative pfpNFT's in a aesthetic inspired by street style tribes.",
"image": "https://www.miladymaker.net/milady/1.png",
"attributes": [
{
"traitType": "Background",
"value": {
"stringValue": "bjork"
}
}
],
"animationURL": "",
"openSeaImageURL": ""
}
}
]
}
}
}
FAQs
Mojito Core API service for auction, payment, token
The npm package @mojito-inc/core-service receives a total of 218 weekly downloads. As such, @mojito-inc/core-service popularity was classified as not popular.
We found that @mojito-inc/core-service demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 0 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Socket's package search now displays weekly downloads for npm packages, helping developers quickly assess popularity and make more informed decisions.
Security News
A Stanford study reveals 9.5% of engineers contribute almost nothing, costing tech $90B annually, with remote work fueling the rise of "ghost engineers."
Research
Security News
Socket’s threat research team has detected six malicious npm packages typosquatting popular libraries to insert SSH backdoors.