☁️ Mojito Modules - Core Service

👨‍💻 React components for the Mojito Platform, Reference App and third-party projects, including Mojito's core service

Version: 1.0.0

Using this library in your project Core Service

You can install this project with one of these commands: npm i @mojito-inc/core-service

yarn add @mojito-inc/core-service

In order to use this package you must install this dependency

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.

For development URL

baseURL = https://api.mojito.xyz/query

For production URL

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

useAuth Hook to check whether session is Expired or Active

import { useAuth } from '@mojito-inc/core-service';
const { sessionStatus } = useAuth();

After setup with CoreServiceProvider, API can be access via hooks

following the api are

GetSignature Message
LoginWithSignature
RedeemClaimable Code
Redeem Earnable Item
getInvoiceDetails
Redeem Earnable Code
SignUpWithSignature
get Contract Details
complete Onchain Claim

GetSignatureMessage

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
orgId	UUID1	✅
networkID	UUID1	✅
walletAddress	string	✅

Response

 {
    "data:   {
        "getSignatureMessage": "This message is used for signature validation for organization caa and wallet address 0x6588ec22a85d611c8c3cd254d0c063d0be78a6c1 at 2023-02-22T04:39:23Z"
     }
 }

Error

error getting organization by id: record not found

LoginWithSignature

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>
        });

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	✅

Response

 {
    "data": {
          "loginWithSignature": {
            "token": "344fbc51-b6d4-4428-9783-b09dd9df95fb"
          }
        }
 }

Error

Challenge is too old, please request a new one

RedeemClaimableCode

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	✅

Response

 {
     "data": {
          "redeemClaimableCode": {
            "success": true
          }
        }
 }

Error

Challenge is too old, please request a new one

redeemEarnableItem

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

gating

Param	type	Required
ruleId	string	✅
contractAddress	string	✅
tokenId	string	✅
ownerWallet	string	✅

Error

Invalid claimableItemId.

getInvoiceDetails

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	✅

error

Invalid Invoice id

redeemEarnableCode

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

Response

 {
     "data": {
          "redeemEarnableCode": {
            "redeemInitiated": true,
            "invoiceID": "278806fb-d82c-4d9c-bda0-ace148452c00"
          }
        }
 }

Error

Invalid code

SignUpWithSignature

The request receiver retrieves the Signature security token

import { useClaims, Response, SignUpWithSignatureData } from "@mojito-inc/core-service";

  const { signUpWithSignature } = useClaims();

  const response: Response<SignUpWithSignatureData> = await signUpWithSignature({
          challenge: <GET_SIGNATURE_MESSAGE>,
          signature: <CROSS_MINT_SIGNATURE>,
          signer: <SIGNER_ADDRESS>,
          chainId: <CHAIN_ID>,
          orgId: <ORG_ID>,
          firstName: <FIRST_NAME>,
          lastName: <LAST_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	✅
firstName	String	✅
lastName	String	✅
email	String	✅

Response

 {
    "data": {
          "signUpWithSignature": {
            "token": "344fbc51-b6d4-4428-9783-b09dd9df95fb"
          }
        }
 }

Error

Challenge is too old, please request a new one

getContractDetails

It will provide a contract details

import { useClaims, Response, GetContractDetailsData } from "@mojito-inc/core-service";

  const { getContractDetails } = useClaims();

  const response: Response<GetContractDetailsData> = await getContractDetails({
          orgId: <ORG_ID>,
          networkId: <NETWORK_ID>,
          contractType: <CONTRACT_TYPE>,
        });

Param	type	Required
orgId	UUID1	✅
networkId	UUID1	✅
contractType	string	✅

Response

 {
    "data:   {
        "getContractDetails": {
          "id": "",
        }
     }
 }

Error

error getting organization by id: record not found

completeOnchainClaim

Complete onchain claim

import { useClaims, Response, CompleteOnchainClaimData } from "@mojito-inc/core-service";

  const { completeOnchainClaim } = useClaims();

  const response: Response<CompleteOnchainClaimData> = await completeOnchainClaim({
                            invoiceId: <invoiceId>,
                            txHash: <txHash>,
                         });

Param	type	Required	Description
invoiceId	string	✅
txHash	string	✅

Response

 {
     "data": {
          "completeOnchainClaim": true
        }
 }

Error

error getting invoice by id: record not found

GetUsdConversion

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

CryptoCurrencyCode

enum

Enum Variable	value
ETH	ETH
MATIC	MATIC
WETH	WETH
WMATIC	WMATIC

Response

{
  "data": {
    "getUSDPrice": {
      "amount": "1799.34",
      "currency": "USD",
      "base": "ETH",
    }
  }
}

Error

Expected type CryptoCurrenyCode!, found "".

GetSupportedCurrency

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	✅

Response

{
  "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"
        }
      },
    ]
  }
}

Error

error getting token by ID: record not found.

AuctionDetails

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	✅

Response

{
 "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,
           },
         }
       ],
     },
   }
 }
}

Error

uuid: incorrect UUID length.

VerifyOnchainBid

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
lotID	UUID	✅
orgID	UUID	✅
walletAddress	string	✅
amount	Int	✅

Response

{
 "data": {
   "verifyOnchainBid": {
     "amount": 0.0003,
     "tax": 0.000055575933397801415,
     "onChainAuctionContractAddress": "0xeed7f3e16a6018d65dffd63bc30ac252c034edc1",
     "commissionFee": 0.000005999999999999999,
     "platformFee": 0.000005999999999999999,
     "__typename": "OnChainBidResponse"
   }
 }
}

Error

jwt token invalid or has been expired
uuid: incorrect UUID length
error fetching user wallet: wallet by address by not found: record not found
amount is less then current bid + min increment

confirmOnchainBid

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<> });

Response

{
 "data": {
   "confirmOnchainBid": {
     "amount": 0.0005,
     "tax": 0.00007216969871926542,
     "__typename": "MarketplaceAuctionBid"
   }
 }
}

Error

jwt token invalid or has been expired
uuid: incorrect UUID length
error fetching user wallet: wallet by address by not found: record not found
error creating marketplace auction bid: bid amount is below the current bid

createMarketplaceAuctionBid

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> });

Response

{
 "data": {
   "createMarketplaceAuctionBid": {
     "id": "95962a20-2194-493e-ba2d-7abc5cea93bf",
     "marketplaceAuctionLotId": "95962a20-2194-493e-ba2d-7abc5cea93bf",
     "amount": 0.0005,
   }
 }
}

Error

jwt token invalid or has been expired
uuid: incorrect UUID length
error creating marketplace auction bid: bid amount is below the current bid

User API can be access via hooks

following the api are

me
updateUserOrgSettings

me

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	✅

Response

 {
    "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": ""
          }
        ]
      }
    }
 }

Error

access denied

updateUserOrgSettings

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
userOrgId	UUID1	✅
username	String	✅
avatar	String	✅
settingsJson	String
profilePic	String

Response

 {
    "data: {
      "updateUserOrgSettings": {
        "id": "d1a59f7e-8626-46f9-b0ca-b70477910c8c",
        "username": "test",
        "avatar": "U0BpDFXLEKmMNPly",
      }
    }
 }

Error

user is not authorized to update record within userOrgID

KYC API can be access via hooks

following the api are

createApplicant
createCheck
getApplicant
getSDKToken
updateApplicant

createApplicant

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	✅

Response

 {
    "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"
        }
      }
    }
 }

Error

error getting user organization KYC by applicant id: record not found

createCheck

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	✅

Response

 {
    "data: {
      "createCheck": {
        "id": "c2854107-93b6-4200-a1f7-ad28beaa9d1d",
        "success": true
      }
    }
 }

Error

error getting user organization KYC by applicant id: record not found

getApplicant

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	✅

Response

 {
    "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"
        }
      }
    }
 }

Error

error getting user organization KYC by applicant id: record not found

getSDKToken

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	✅

Response

 {
    "data: {
      "getSDKToken": {
        "token": "eyJhbGciOiJFUzUxMiJ9.eyJleHAiOjE2ODExMTgzNjEsInBheWxvYWQiOnsiYXBwIjoiNzU3OGFmYTYtY2I3ZS00NWNjLTgyZWYtNWM1ODIxZWJlYzQyIiwiY2xpZW50X3V1aWQiOiIyMmQyYzQ1NC0zNzMxLTQ4N2UtYmUzYS05N2I4NmQ4NWYzOWMiLCJpc19zYW5kYm94Ijp0cnVlLCJpc19zZWxmX3NlcnZpY2VfdHJpYWwiOmZhbHNlLCJpc190cmlhbCI6ZmFsc2UsInJlZiI6Imh0iHBzOi8vd2hpc2tleWV4Y2hhbmdlLWRldi5uZXRsaWZ5LmFwcC8iLCJzYXJkaW5lX3Nlc3Npb24iOiI1NzkxMGUyMC0yMTljLTQxZTItOTUzOS1lYjJhYjFmZDdiZTQifSwidXVpZCI6InBsYXRmb3JtX3N0YXRpY19hcGlfdG9rZW5fdXVpZCIsInVybHMiOnsiZGV0ZWN0X2RvY3VtZz50X3VybCI6Imh0dHBzOi8vc2RrLnVzLm9uZmlkby5jb20iLCJzeW5jX3VybCI6Imh0dHBzOi8vc3luYy5vbmZpZG8uY29tIiwiaG9zdGVkX3Nka191cmwiOiJodHRwczovL2lkLm9uZmlkby5jb20iLCJhdXRoX3VybCI6Imh0dHBzOi8vYXBpLnVzLm9uZmlkby5jb20iLCJvbmZpZG9fYXBpX3VybCI6Imh0dHBzOi8vYXBpLnVzLm9uZmlkby5jb20iLCJ0ZWxlcGhvbnlfdXJsIjoiaHR0cHM6Ly9hcGkudXMub25maWRvLmNvbSJ9fQ.MIGIAkIAtiM1UkIpaTKIGeTn6sYfX3GR4fTWPq_AeU1RxwQDQu5S7K3NM1z5hzh01sTo3KK_elpMh27XC0mhR9MkLt3kkroCQgG9gAW4w0vO1k1dXJKzbq3WDpklTqXtjT3plDbe5_bM8QujgjlbaW7nkASg68BYqa7P5UHOI5p-_QBayflaU3wXa"
      }
    }
 }

Error

error getting user organization KYC by applicant id: record not found

updateApplicant

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	✅

Response

 {
    "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"
        }
      }
    }
 }

Error

error getting user organization KYC by applicant id: record not found

Connect wallet API can be access via hooks

following the api are

connectExternalWallet
getActiveWalletsContent
getSupportedNetworks

connectExternalWallet

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
orgID	UUID1	✅
networkID	UUID1	✅
message	String	✅
signature	String	✅
address	String	✅

Response

 {
  "data": {
    "connectExternalWallet": true
  }
}

Error

challenge is too old, please request a new one

getActiveWalletsContent

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
orgID	UUID1	✅
networkId	UUID1	✅
walletAddress	String	✅
filters	ActiveWalletFilterInput
refreshCache	Boolean

Response

 {
  "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",
        },
      ]
    }
  }
}

Error

wallet by address by id not found: record not found

getSupportedNetworks

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

Response

 {
  "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
      },
    ]
  }
}

Error

encoding/hex: invalid byte: U+002D '-'

List item API can be access via hooks

following the api are

createSignatureToListNFTForSale
removeListing
submitProofOfApproval

createSignatureToListNFTForSale

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
orgId	UUID1	✅
nftTokenId	UUID1	✅
tokenType	TokenType	✅
quantity	Int	✅
nftOwnerAddress	String	✅
fixedPrice	Float	✅
paymentToken	String	✅
currencyId	UUID1	✅

Response

 {
  "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"
      }
    }
  }
}

Error

error getting organization by id: record not found

removeListing

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	✅

Response

 {
  "data": {
    "removeListing": "Listing removed."
  }
}

Error

error getting organization by id: record not found

submitProofOfApproval

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
orgID	UUID1	✅
nftTokenId	UUID1	✅
signature	String	✅
quantity	Int
fixedPrice	Float
paymentToken	String
currencyId	UUID1
creatorFee	TokenType

Response

 {
  "data": {
    "submitProofOfApproval":"Signature updated."
  }
}

Error

error getting organization by id: record not found

Tax and fee API can be access via hooks

following the api are

estimateTaxAndRoyaltyFee
getTaxQuote

estimateTaxAndRoyaltyFee

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
orgId	UUID1	✅
estimateType	TaxEstimateType	✅
nftTokenId	UUID1
orderId	UUID1
price	Float
country	String
postalCode	String

Response

 {
  "data": {
    "estimateTaxAndRoyaltyFee": {
      "taxPercentage": 0,
      "royaltyFee": 0,
      "platformFee": 2.5,
      "taxResponse": {
        "cryptoTaxPrice": 0,
        "cryptoTotalPrice": 1,
        "USDUnitprice": 1920.88,
        "taxPercentage": 0
      }
    }
  }
}

Error

error getting organization by id: record not found

getTaxQuote

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
orgID	UUID1	✅
taxablePrice	Float	✅
street1	String	✅
city	String	✅
state	String	✅
postalCode	String	✅
country	String	✅
currencyCode	String

Response

{
  "data": {
    "getTaxQuote": {
      "verifiedAddress": {
        "street1": "",
        "state": "Tamil Nadu",
        "postalCode": "",
        "country": "IN",
        "currencyCode": "USD"
      },
      "taxablePrice": 76.6724,
      "totalTaxedPrice": 76.6724,
      "totalTaxAmount": 0
    }
  }
}

Error

error getting organization by id: record not found

NFT API can be access via hooks

following the api are

getNFTFavoriteListByUser
addNFTToFavorite
removeNFTFromFavorite
getAllRegistryTokens
getNFTDetails
getNFTHistory
getNFTAttributesRarity
initiateBuyNFT
updateTransactionHash
generateSecondaryInvoice
userOrderActivity
transferNFT
getAllInvoices
generatePrimaryInvoice
getFileSignedURL

getNFTFavoriteListByUser

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

SavedNFTFilterInput

enum

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

Response

{
  "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"
        }
      ]
    }
  }
}

Error

error getting organization by id: record not found

addNFTToFavorite

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	✅

Response

{
  "data": {
    "addNFTToFavourite": true,
  }
}

Error

error getting token by ID: record not found

removeNFTFromFavorite

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	✅

Response

{
  "data": {
    "removeNFTFromFavourite": true,
  }
}

Error

error getting token by ID: record not found

getAllRegistryTokens

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

RegistryTokenFilterInput

enum

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

Response

{
  "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"
        }
      ]
    }
  }
}

Error

error getting organization by id: record not found

getNFTDetails

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
orgId	UUID1	✅
contractAddress	String
onChainTokenID	BigInt
ownerAddress	String
buyerAddress	String
editionNumber	Int
nftTokenId	UUID1
networkId	UUID1

Response

{
  "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"
    }
  }
}

Error

error getting organization by id: record not found

getNFTHistory

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
orgId	UUID1	✅
contractAddress	String	✅
networkId	UUID1	✅
tokenId	BigInt	✅
nftTokenId	UUID1
ownerAddress	String
limit	Int
offset	Int

Response

{
  "data": {
    "getNFTHistoryV2": {
      "totalCount": 30,
      "data": [
        {
          "hash":"0xd3cc350c9020a32f699bea54824b90aa5adad6fbc5e09a0dbc2b78ce1415ae03",
          "from":"0xa77915a574e1f9b88db152525ceBfEAA8c71bAa4",
          "to":"test"
          "blockTimestamp":"2023-01-27T12:41:23Z"
          "eventType":"Sale"
          "fromUserAvatar":"qvx3wQZawwkDtws2"
        }
      ]
    }
  }
}

Error

error getting organization by id: record not found

getNFTAttributesRarity

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
contractAddress	String	✅
networkID	UUID1	✅
tokenID	BigInt	✅
refreshCatch	Boolean

Response

{
  "data": {
    "getNFTAttributesRarity": [
      {
        "traitType":"Brand",
        "displayType":"",
        "maxValue":0,
        "prevalance":0,
        "value": {
          "__typename":"AttributeValueString",
          "stringValue":"DGAF"
        }
      }
    ]
  }
}

Error

error getting organization by id: record not found

initiateBuyNFT

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
nftTokenId	UUID1	✅
buyerAddress	String	✅
orgId	UUID1	✅
country	String
postalCode	String
currencyId	UUID1
cryptoTax	CryptoTax
taxAddress	TaxAddressInput

Response

{
  "data": {
    "initiateBuyNFT": {
      "proofOfApproval":"0x28a9e439e3c091e737ff6209a1aa6f6022d8e7d16d738b2cbbc2fe8fad86630c341602d2653fcda2d02034278aee2a4fce9d6a48b7662ab67c5893c0fd857cf01c"
    }
  }
}

Error

error getting organization by id: record not found

updateTransactionHash

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
nftTokenId	UUID1	✅
orgId	UUID1	✅
buyerAddress	String	✅
transactionHash	String	✅
orderId	UUID1

Response

{
  "data": {
    "updateTransactionHash": {
      "success":false,
      "newNFTID":"2bb1fec0-94be-499c-989c-1a2a75ceb478"
    }
  }
}

Error

error getting organization by id: record not found

generateSecondaryInvoice

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

ActivityName

enum

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

InvoiceResType

enum

Enum Variable	value
pdf	pdf
base64	base64

Response

 {
    "data: {
      "generateSecondaryInvoice": "https://storage.googleapis.com/mojito-dev-public/organizations/8fb128bd-f55d-4bcc-8b6c-0beb684e4d4e/invoices/208af15b-ae03-47c7-aa79-27ce453bcb2d_buyer.pdf"
    }
 }

Error

error getting invoice with id: record not found

generatePrimaryInvoice

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

InvoiceResType

enum

Enum Variable	value
pdf	pdf
base64	base64

Response

 {
    "data: {
      "generatePrimaryInvoice": "https://storage.googleapis.com/mojito-dev-public/organizations/8fb128bd-f55d-4bcc-8b6c-0beb684e4d4e/invoices/208af15b-ae03-47c7-aa79-27ce453bcb2d_buyer.pdf"
    }
 }

Error

error getting invoice with id: record not found

getUserOrderActivity

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	✅

OrderActivityFilters

enum

Enum Variable	value
LATEST_TO_OLDEST	LATEST_TO_OLDEST
LATEST_TO_OLDEST	LATEST_TO_OLDEST

Response

 {
    "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
            }
          }
        ]
      }
    }
 }

Error

error getting organization by id: record not found

transferNFT

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
walletId	UUID1	✅
orgId	UUID1	✅
contractAddress	string	✅
tokenType	TokenType
tokenOnChainId	Int	✅
amount	Int
transferTo	string	✅
isClaimedToken	boolean

Response

{
  "data": {
    "transferToken": "transfered",
  }
}

Error

error getting organization by id: record not found

getAllInvoices

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	✅

OrderActivityFilters

enum

Enum Variable	value
LATEST_TO_OLDEST	LATEST_TO_OLDEST
LATEST_TO_OLDEST	LATEST_TO_OLDEST

Response

 {
    "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",
          "tokenName": "The Plague #2",
          }
        ]
      }
    }
 }

Error

error getting organization by id: record not found

getMyInvoices

import { useNFT, getMyInvoices } from "@mojito-inc/core-service"; const { getMyInvoices } = useNFT();

const response: Response = await getMyInvoices({ returnAllStatuses: <RETURN_ALL_STATUSES>, filter: , limit: , offset: });

Param	type	Required	Description
returnAllStatuses	Boolean
filter	string		GetMyInvoiceFilterParam
limit	Int	✅
offset	Int	✅

GetMyInvoiceFilterParam

Variable	value
dropID	string
listingID	string

Response

 {
    "data: {
      "getAllInvoices": {
      "TotalCount": 3,
      "data": [
        {
          "invoiceID": "c9ae9cc1-15ca-4286-8f23-50aa1efec6a0",
          "invoiceCreatedAt": "2024-07-26T11:45:53.735655Z",
          "invoiceNumber": 31752,
          "status": "Paid",
          "items": [
            {
              "collectionItemTitle": "Test 1155 listing",
              "collectionItemID": "55c031f9-2e62-48d2-823c-c684026d0e64",
              "invoiceItemID": "b897f1a2-7e49-4798-9e3e-90818a388719",
              "destinationAddress": "0xC7B73dE4Ef961300Bb79E04b6CF75a1e32DFd1f2",
              "units": 1,
              "totalPrice": 0,
              "transactionHash": "0x1e2145464e2b21d3eeb9faf305f7928273be7779ba432819e99cef2fa9296a23",
              "transactionStatus": "Delivered",
              "nftImageUrl": "https://gateway.arweave.net/UDdgMysz7IoQWRxjLLBte0P0lbpipVU4oo32huIghU4",
              "nftDetails": [
                {
                  "contractAddress": "0xcc018fad58c8b2c2856ff9e885edcb9faf15d73e",
                  "networkId": "b260424b-bb37-4a3e-86d0-0866175e5e68",
                  "nftTokenID": "c6dcf74d-8261-44d8-8512-ec34ccb032e2",
                  "networkChainID": 11155111,
                  "isRevealed": false,
                  "tokenMetadata": {
                    "name": "1_Dog1_Glow_Blacksad1s",
                    "description": "Test token description",
                    "image": "https://gateway.arweave.net/UDdgMysz7IoQWRxjLLBte0P0lbpipVU4oo32huIghU4"
                  }
                }
              ]
            }
          ]
        }
      ]
    }
    }
 }

getFileSignedURL

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

Response

{
  "data": {
    "getFileSignedURL": {
      mediaURL: "https://storage.cloud.google.com/mojito-dev-private/nft/0x0b1ee1de78a9d2db7b647834423a86e6c5bf1bdb/videos/1.mp4",
      type: 'mp4'
    },
  }
}

Error

The gated NFT not belongs to the walletAddress

Offer API can be access via hooks

following the api are

acceptOffer
cancelOffer
createOffer
getOffers
getSignatureForOfferApproval
rejectOffer
submitProofOfOffer

acceptOffer

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
orgId	UUID1	✅
orderId	UUID1	✅
transactionHash	String	✅

Response

{
  "data": {
    "acceptOffer": {
      "success":false
      "newNFTID":"5bc739a6-f5d3-4417-b4af-91687e0af525"
    }
  }
}

Error

error getting organization by id: record not found

cancelOffer

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	✅

Response

{
  "data": {
    "cancelOffer": "Offer cancelled."
  }
}

Error

error getting organization by id: record not found

createOffer

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
orgId	UUID1	✅
nftTokenId	UUID1	✅
buyerAddress	String	✅
offerPrice	Number	✅
expiryDate	String	✅
paymentToken	String	✅
currencyId	String
cryptoTax	CryptoTax
taxAddress	TaxAddressInput

Response

{
  "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
      }
    }
  }
}

Error

error getting organization by id: record not found

getOffers

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	✅

Response

{
  "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"
      }
    ]
  }
}

Error

error getting organization by id: record not found

getSignatureForOfferApproval

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
orgId	UUID1	✅
orderId	UUID1	✅
creatorFee	Int

Response

{
  "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
      }
    }
  }
}

Error

error getting organization by id: record not found

rejectOffer

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	✅

Response

{
  "data": {
    "rejectOffer": "Offer rejected."
  }
}

Error

error getting organization by id: record not found

submitProofOfOffer

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
orgId	UUID1	✅
orderId	UUID1	✅
signature	String	✅

Response

{
  "data": {
    "submitProofOfOffer":"Signature updated."
  }
}

Error

error getting organization by id: record not found

Token Gating API can be access via hooks

following the api are

createTokenGating
checkTokenGating
checkTokenGatingV2

createTokenGating

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

GatingRule

Param	type	Required	Description
ruleType	enum	✅	RuleType
contractAddress	String
contractAddressWithTokenId	contractAddressWithTokenId		ContractAddressWithTokenIDGating
metaData	MetaDataGating		MetaDataGating
onchain	enum		OnchainGating

ContractAddressWithTokenIDGating

Param	type	Required	Description
contractAddress	String
tokenID	Int

MetaDataGating

Param	type	Required	Description
key	String
value	String

enum

RuleType

Enum Variable	value
ContractAddress	ContractAddress
ContractAddressWithTokenID	ContractAddressWithTokenID
MetaData	MetaData
Onchain	Onchain

OnchainGating

Enum Variable	value
ONCHAIN	ONCHAIN

Response

{
  "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."
              }
            ]
          }
        }
      ]
    }
  }
}

Error

error getting organization by id: orgID record not found

checkTokenGating

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
groupID	UUID1	✅
ruleID	UUID1
buyerAddress	String
contractAddress	String
tokenId	String

Response

{
  "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": ""
          }
        }
      ]
    }
  }
}

Error

error getting groupID by id: groupID record not found

checkTokenGatingV2

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
groupID	UUID1	✅
ruleID	UUID1
buyerAddress	String	✅

Response

{
  "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": ""
          }
        }
      ]
    }
  }
}

Error

error getting groupID by id: groupID record not found

Collection API can be access via hooks

following the api are

collectionBySlug

collectionBySlug

This API is used to check whether the nft is Gated or not.

import { useCollection, CollectionBySlugData } from "@mojito-inc/core-service";

const { collectionBySlug } = useCollection();

const response: Response<CollectionBySlugData> = await collectionBySlug({
         slug: <SLUG>,
         marketplaceID: <MARKETPLACE_ID>,
       });

Param	type	Required	Description
slug	string	✅
marketplaceID	String	✅

Response

{
  "data": {
    "collectionBySlug": {
      "id": "ad538b6a-8d32-4ae6-b12e-53ce8b47ef5c",
    }
  }
}

Error

error getting marketplaceID by id: marketplaceID record not found

development

Development setup