Skip to main content

@silvana-one/api

Index

Functions

Type Aliases

Type Aliases

AdvancedNftCollectionAdminData

AdvancedNftCollectionAdminData: { allowChangeAdmin?: boolean; allowChangeBaseUri?: boolean; allowChangeCreator?: boolean; allowChangeName?: boolean; allowChangeRoyalty?: boolean; allowChangeTransferFee?: boolean; canPause?: boolean; isPaused?: boolean }

Type declaration

  • optionalallowChangeAdmin?: boolean

    Indicates whether the contract can change the admin

  • optionalallowChangeBaseUri?: boolean

    Indicates whether the contract can change the base URI

  • optionalallowChangeCreator?: boolean

    Indicates whether the contract can change the creator

  • optionalallowChangeName?: boolean

    Indicates whether the contract can change the name

  • optionalallowChangeRoyalty?: boolean

    Indicates whether the contract can change the royalty fee

  • optionalallowChangeTransferFee?: boolean

    Indicates whether the contract can change the transfer fee

  • optionalcanPause?: boolean

    Indicates whether the contract can be paused

  • optionalisPaused?: boolean

    Indicates whether the contract is currently paused

AirdropTokensData

AirdropTokensData: { body: TokenAirdropTransactionParams; path?: never; query?: never; url: /token/airdrop }

Type declaration

AirdropTokensError

AirdropTokensError: AirdropTokensErrors[keyof AirdropTokensErrors]

AirdropTokensErrors

AirdropTokensErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

AirdropTokensResponse

AirdropTokensResponse: AirdropTokensResponses[keyof AirdropTokensResponses]

AirdropTokensResponses

AirdropTokensResponses: { 200: AirdropTransactionResponse }

Type declaration

AirdropTransactionResponse

AirdropTransactionResponse: { txs?: TokenTransaction[] }

Type declaration

  • optionaltxs?: TokenTransaction[]

    List of token transactions created for the airdrop.

ApproveNftData

ApproveNftData: { body: NftApproveTransactionParams; path?: never; query?: never; url: /nft/approve }

Type declaration

ApproveNftError

ApproveNftError: ApproveNftErrors[keyof ApproveNftErrors]

ApproveNftErrors

ApproveNftErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

ApproveNftResponse

ApproveNftResponse: ApproveNftResponses[keyof ApproveNftResponses]

ApproveNftResponses

ApproveNftResponses: { 200: NftTransaction }

Type declaration

BalanceRequestParams

BalanceRequestParams: { address: string; tokenAddress?: string; tokenId?: string }

Type declaration

  • address: string

    The Mina address for which to retrieve the balance.

  • optionaltokenAddress?: string

    The address of the token contract (optional).

  • optionaltokenId?: string

    The token ID (optional).

BalanceResponse

BalanceResponse: { address: string; balance?: number; hasAccount?: boolean; tokenAddress?: string; tokenId?: string }

Type declaration

  • address: string

    The Mina address for which the balance was requested.

  • optionalbalance?: number

    The balance of the token for the specified address.

  • optionalhasAccount?: boolean

    Indicates whether the account exists.

  • optionaltokenAddress?: string

    The address of the token contract (optional).

  • optionaltokenId?: string

    The token ID (optional).

BurnTokensData

BurnTokensData: { body: TokenBurnTransactionParams; path?: never; query?: never; url: /token/burn }

Type declaration

BurnTokensError

BurnTokensError: BurnTokensErrors[keyof BurnTokensErrors]

BurnTokensErrors

BurnTokensErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

BurnTokensResponse

BurnTokensResponse: BurnTokensResponses[keyof BurnTokensResponses]

BurnTokensResponses

BurnTokensResponses: { 200: TokenTransaction }

Type declaration

BuyNftData

BuyNftData: { body: NftBuyTransactionParams; path?: never; query?: never; url: /nft/buy }

Type declaration

BuyNftError

BuyNftError: BuyNftErrors[keyof BuyNftErrors]

BuyNftErrors

BuyNftErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

BuyNftResponse

BuyNftResponse: BuyNftResponses[keyof BuyNftResponses]

BuyNftResponses

BuyNftResponses: { 200: NftTransaction }

Type declaration

BuyTokensData

BuyTokensData: { body: TokenBuyTransactionParams; path?: never; query?: never; url: /token/offer/buy }

Type declaration

BuyTokensError

BuyTokensError: BuyTokensErrors[keyof BuyTokensErrors]

BuyTokensErrors

BuyTokensErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

BuyTokensResponse

BuyTokensResponse: BuyTokensResponses[keyof BuyTokensResponses]

BuyTokensResponses

BuyTokensResponses: { 200: TokenTransaction }

Type declaration

Chain

Chain: { chain: mina | zeko; network: devnet | mainnet }

Type declaration

  • chain: mina | zeko

    The chain name

  • network: devnet | mainnet

    The network name

ClientOptions

ClientOptions: { baseUrl: https://minatokens.com/api/v1/ | https://devnet.minatokens.com/api/v1/ | https://zekotokens.com/api/v1/ | (string & {}) }

Type declaration

  • baseUrl: https://minatokens.com/api/v1/ | https://devnet.minatokens.com/api/v1/ | https://zekotokens.com/api/v1/ | (string & {})

CmsReadNftData

CmsReadNftData: { body: { chain: Chain; collectionAddress: string; nftName?: string; signature?: string; signatureExpiry?: number }; path?: never; query?: never; url: /nft/cms/read }

Type declaration

  • body: { chain: Chain; collectionAddress: string; nftName?: string; signature?: string; signatureExpiry?: number }
    • chain: Chain
    • collectionAddress: string

      The address of the NFT collection

    • optionalnftName?: string

      The name of the NFT. If not provided, all NFTs will be returned that can be minted now.

    • optionalsignature?: string

      The signature of the Collection creator. Required to get NFTs that cannot be minted now.

    • optionalsignatureExpiry?: number

      The expiry time of the request (unix timestamp in ms)

  • optionalpath?: never
  • optionalquery?: never
  • url: /nft/cms/read

CmsReadNftError

CmsReadNftError: CmsReadNftErrors[keyof CmsReadNftErrors]

CmsReadNftErrors

CmsReadNftErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

CmsReadNftResponse

CmsReadNftResponse: CmsReadNftResponses[keyof CmsReadNftResponses]

CmsReadNftResponses

CmsReadNftResponses: { 200: { nfts?: CmsnftData[] } }

Type declaration

  • 200: { nfts?: CmsnftData[] }

    Successfully retrieved NFTs from CMS.

    • optionalnfts?: CmsnftData[]

      The NFTs data retrieved from CMS

CmsReserveNftData

CmsReserveNftData: { body: { chain: Chain; collectionAddress: string; nftName: string; reserve?: boolean; signature?: string; signatureExpiry?: number }; path?: never; query?: never; url: /nft/cms/reserve }

Type declaration

  • body: { chain: Chain; collectionAddress: string; nftName: string; reserve?: boolean; signature?: string; signatureExpiry?: number }
    • chain: Chain
    • collectionAddress: string

      The address of the NFT collection

    • nftName: string

      The name of the NFT

    • optionalreserve?: boolean

      Indicates whether the NFT should be reserved in CMS or the reserve should be removed. Default is true.

    • optionalsignature?: string

      The signature of the Collection creator. Required if reserve is false.

    • optionalsignatureExpiry?: number

      The expiry time of the request( unix timestamp in ms). Required if reserve is false.

  • optionalpath?: never
  • optionalquery?: never
  • url: /nft/cms/reserve

CmsReserveNftError

CmsReserveNftError: CmsReserveNftErrors[keyof CmsReserveNftErrors]

CmsReserveNftErrors

CmsReserveNftErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

CmsReserveNftResponse

CmsReserveNftResponse: CmsReserveNftResponses[keyof CmsReserveNftResponses]

CmsReserveNftResponses

CmsReserveNftResponses: { 200: { nft?: CmsnftData; reserved?: boolean } }

Type declaration

  • 200: { nft?: CmsnftData; reserved?: boolean }

    Successfully built transfer transaction.

    • optionalnft?: CmsnftData

      The NFT data retrieved from CMS

    • optionalreserved?: boolean

      Indicates whether the NFT was successfully reserved in CMS

CmsStoreNftData

CmsStoreNftData: { body: { chain: Chain; nft: CmsnftData; signature: string; signatureExpiry: number }; path?: never; query?: never; url: /nft/cms/store }

Type declaration

  • body: { chain: Chain; nft: CmsnftData; signature: string; signatureExpiry: number }
    • chain: Chain
    • nft: CmsnftData
    • signature: string

      The signature of the Collection creator

    • signatureExpiry: number

      The expiry time of the request( unix timestamp in ms)

  • optionalpath?: never
  • optionalquery?: never
  • url: /nft/cms/store

CmsStoreNftError

CmsStoreNftError: CmsStoreNftErrors[keyof CmsStoreNftErrors]

CmsStoreNftErrors

CmsStoreNftErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

CmsStoreNftResponse

CmsStoreNftResponse: CmsStoreNftResponses[keyof CmsStoreNftResponses]

CmsStoreNftResponses

CmsStoreNftResponses: { 200: { success?: boolean } }

Type declaration

  • 200: { success?: boolean }

    Successfully built transfer transaction.

    • optionalsuccess?: boolean

      Indicates whether the NFT was successfully stored in CMS

CmsnftData

CmsnftData: { chain: Chain; collectionAddress: string; description?: string; imageURL: string; mintEnd?: number; mintStart?: number; name: string; nftData?: NftData; price?: number; symbol?: string; traits?: Trait[] }

Type declaration

  • chain: Chain
  • collectionAddress: string

    The address of the NFT collection

  • optionaldescription?: string

    Optional description of the NFT

  • imageURL: string

    URL to the NFT image

  • optionalmintEnd?: number

    The end time of the minting period( unix timestamp in ms)

  • optionalmintStart?: number

    The start time of the minting period( unix timestamp in ms)

  • name: string

    The name of the NFT

  • optionalnftData?: NftData

    Data associated with the NFT

  • optionalprice?: number

    The price of the NFT

  • optionalsymbol?: string

    The symbol of the NFT

  • optionaltraits?: Trait[]

    Array of traits associated with the NFT

CollectionData

CollectionData: { isPaused?: boolean; mintingIsLimited?: boolean; requireTransferApproval?: boolean; royaltyFee?: number; transferFee?: number }

Type declaration

  • optionalisPaused?: boolean

    Indicates whether the collection is currently paused

  • optionalmintingIsLimited?: boolean

    If true, the minting is stopped and cannot be resumed

  • optionalrequireTransferApproval?: boolean

    If true, transferring NFTs requires approval from the admin contract

  • optionalroyaltyFee?: number

    The royalty fee percentage (e.g., 1000 = 1%, 100 = 0.1%, 10000 = 10%, 100000 = 100%)

  • optionaltransferFee?: number

    The transfer fee amount

CollectionInfo

CollectionInfo: { adminAddress: string; banner?: string; baseURL: string; chain: string; collectionAddress: string; collectionIsPaused: boolean; collectionName: string; contractType: collection; contractVerificationKeyHash: string; contractVersion: number; created: number; creator: string; isPaused: boolean; likes?: number; masterNFT: NftInfo; mintingIsLimited: boolean; rating: number; requireTransferApproval: boolean; royaltyFee: number; status: string; symbol: string; tokenId: string; transferFee: string; updated: number; uri: string }

Type declaration

  • adminAddress: string
  • optionalbanner?: string
  • baseURL: string
  • chain: string
  • collectionAddress: string
  • collectionIsPaused: boolean
  • collectionName: string
  • contractType: collection
  • contractVerificationKeyHash: string

    The verification key hash of the contract.

  • contractVersion: number

    The version number of the contract.

  • created: number
  • creator: string
  • isPaused: boolean
  • optionallikes?: number
  • masterNFT: NftInfo
  • mintingIsLimited: boolean
  • rating: number
  • requireTransferApproval: boolean
  • royaltyFee: number
  • status: string
  • symbol: string
  • tokenId: string
  • transferFee: string
  • updated: number
  • uri: string

ContractInfo

ContractInfo: { address: ContractProperty & { type?: address }; derivedTokenId: ContractProperty & { type?: tokenId }; name: ContractProperty & { type?: name }; symbol: ContractProperty & { type?: symbol }; tokenId: ContractProperty & { type?: tokenId }; uri: ContractProperty & { type?: uri }; verificationKey: ContractProperty & { type?: verificationKey }; verificationKeyHash: ContractProperty & { type?: verificationKeyHash }; zkappVersion: ContractProperty & { type?: zkappVersion } }

Type declaration

ContractInfoRequest

ContractInfoRequest: { address: string; tokenId?: string }

Type declaration

  • address: string

    The contract address.

  • optionaltokenId?: string

    Optional. The tokenId.

ContractProperty

ContractProperty: { presentation?: string; type: ContractPropertyType; value: string }

Type declaration

ContractPropertyType

ContractPropertyType: name | role | address | tokenId | verificationKey | verificationKeyHash | zkappVersion | bigint | number | field | boolean | ipfs | string | uri | symbol | bondingCurveMintPrice | bondingCurveRedeemPrice

DeployedNftCollectionTransactionBaseParams

DeployedNftCollectionTransactionBaseParams: NftTransactionBaseParams & { collectionAddress: string }

DeployedNftTransactionBaseParams

DeployedNftTransactionBaseParams: NftTransactionBaseParams & { collectionAddress: string; nftAddress: string }

DeployedTokenTransactionBaseParams

DeployedTokenTransactionBaseParams: TokenTransactionBaseParams & { tokenAddress: string }

ErrorResponse

ErrorResponse: { error?: string }

Type declaration

  • optionalerror?: string

    Error message detailing the issue.

FaucetData

FaucetData: { body: FaucetParams; path?: never; query?: never; url: /faucet }

Type declaration

  • body: FaucetParams
  • optionalpath?: never
  • optionalquery?: never
  • url: /faucet

FaucetError

FaucetError: FaucetErrors[keyof FaucetErrors]

FaucetErrors

FaucetErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

FaucetParams

FaucetParams: { address: string }

Type declaration

  • address: string

    The Mina address (public key) to receive the test tokens.

FaucetResponse

FaucetResponse: { error?: string; hash?: string; success?: boolean }

Type declaration

  • optionalerror?: string

    Error message if the request failed.

  • optionalhash?: string

    The transaction hash of the faucet transfer if successful.

  • optionalsuccess?: boolean

    Indicates whether the faucet request was successful.

FaucetResponse2

FaucetResponse2: FaucetResponses[keyof FaucetResponses]

FaucetResponses

FaucetResponses: { 200: FaucetResponse }

Type declaration

GetContractInfoData

GetContractInfoData: { body: ContractInfoRequest; path?: never; query?: never; url: /info/contract }

Type declaration

GetContractInfoError

GetContractInfoError: GetContractInfoErrors[keyof GetContractInfoErrors]

GetContractInfoErrors

GetContractInfoErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

GetContractInfoResponse

GetContractInfoResponse: GetContractInfoResponses[keyof GetContractInfoResponses]

GetContractInfoResponses

GetContractInfoResponses: { 200: ContractInfo[] }

Type declaration

  • 200: ContractInfo[]

    Successful retrieval of contract info for the given contract and his admin contract and other contracts that are related to it.

GetNftInfoData

GetNftInfoData: { body: NftRequestParams; path?: never; query?: never; url: /info/nft }

Type declaration

GetNftInfoError

GetNftInfoError: GetNftInfoErrors[keyof GetNftInfoErrors]

GetNftInfoErrors

GetNftInfoErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

GetNftInfoResponse

GetNftInfoResponse: GetNftInfoResponses[keyof GetNftInfoResponses]

GetNftInfoResponses

GetNftInfoResponses: { 200: NftRequestAnswer }

Type declaration

GetNftV2InfoData

GetNftV2InfoData: { body: NftRequestParams; path?: never; query?: never; url: /info/nft-v2 }

Type declaration

  • body: NftRequestParams
  • optionalpath?: never
  • optionalquery?: never
  • url: /info/nft-v2

GetNftV2InfoError

GetNftV2InfoError: GetNftV2InfoErrors[keyof GetNftV2InfoErrors]

GetNftV2InfoErrors

GetNftV2InfoErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

GetNftV2InfoResponse

GetNftV2InfoResponse: GetNftV2InfoResponses[keyof GetNftV2InfoResponses]

GetNftV2InfoResponses

GetNftV2InfoResponses: { 200: NftV2RequestAnswer }

Type declaration

GetNonceData

GetNonceData: { body: NonceRequestParams; path?: never; query?: never; url: /info/nonce }

Type declaration

GetNonceError

GetNonceError: GetNonceErrors[keyof GetNonceErrors]

GetNonceErrors

GetNonceErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

GetNonceResponse

GetNonceResponse: GetNonceResponses[keyof GetNonceResponses]

GetNonceResponses

GetNonceResponses: { 200: NonceResponse }

Type declaration

GetProofData

GetProofData: { body: JobId; path?: never; query?: never; url: /transaction/proof }

Type declaration

  • body: JobId
  • optionalpath?: never
  • optionalquery?: never
  • url: /transaction/proof

GetProofError

GetProofError: GetProofErrors[keyof GetProofErrors]

GetProofErrors

GetProofErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

GetProofResponse

GetProofResponse: GetProofResponses[keyof GetProofResponses]

GetProofResponses

GetProofResponses: { 200: JobResults }

Type declaration

  • 200: JobResults

    Successfully retrieved job status and proofs.

GetTokenBalanceData

GetTokenBalanceData: { body: BalanceRequestParams; path?: never; query?: never; url: /info/balance }

Type declaration

GetTokenBalanceError

GetTokenBalanceError: GetTokenBalanceErrors[keyof GetTokenBalanceErrors]

GetTokenBalanceErrors

GetTokenBalanceErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

GetTokenBalanceResponse

GetTokenBalanceResponse: GetTokenBalanceResponses[keyof GetTokenBalanceResponses]

GetTokenBalanceResponses

GetTokenBalanceResponses: { 200: BalanceResponse }

Type declaration

GetTokenHoldersData

GetTokenHoldersData: { body: TokenHoldersRequestParams; path?: never; query?: never; url: /info/holders }

Type declaration

GetTokenHoldersError

GetTokenHoldersError: GetTokenHoldersErrors[keyof GetTokenHoldersErrors]

GetTokenHoldersErrors

GetTokenHoldersErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

GetTokenHoldersResponse

GetTokenHoldersResponse: GetTokenHoldersResponses[keyof GetTokenHoldersResponses]

GetTokenHoldersResponses

GetTokenHoldersResponses: { 200: TokenHoldersResponse }

Type declaration

GetTokenInfoData

GetTokenInfoData: { body: TokenInfoRequestParams; path?: never; query?: never; url: /info/token }

Type declaration

GetTokenInfoError

GetTokenInfoError: GetTokenInfoErrors[keyof GetTokenInfoErrors]

GetTokenInfoErrors

GetTokenInfoErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

GetTokenInfoResponse

GetTokenInfoResponse: GetTokenInfoResponses[keyof GetTokenInfoResponses]

GetTokenInfoResponses

GetTokenInfoResponses: { 200: TokenState }

Type declaration

  • 200: TokenState

    Successful retrieval of token information.

GetTransactionsData

GetTransactionsData: { body: TransactionsListRequestParams; path?: never; query?: never; url: /info/transactions }

Type declaration

GetTransactionsError

GetTransactionsError: GetTransactionsErrors[keyof GetTransactionsErrors]

GetTransactionsErrors

GetTransactionsErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

GetTransactionsResponse

GetTransactionsResponse: GetTransactionsResponses[keyof GetTransactionsResponses]

GetTransactionsResponses

GetTransactionsResponses: { 200: TransactionsListResponse }

Type declaration

JobId

JobId: { jobId: string }

Type declaration

  • jobId: string

    The job ID returned by the /prove endpoint.

JobResult

JobResult: { error?: string; hash?: string; status?: string; success: boolean; tx?: string }

Type declaration

  • optionalerror?: string

    Error message if proof generation failed for this transaction.

  • optionalhash?: string

    The transaction hash if broadcasted.

  • optionalstatus?: string

    The status of the transaction.

  • success: boolean

    Indicates whether the proof generation for this transaction was successful.

  • optionaltx?: string

    The transaction data.

JobResults

JobResults: { error?: string; jobStatus?: created | started | finished | failed | used | restarted; results?: JobResult[]; success?: boolean }

Type declaration

  • optionalerror?: string

    Error message if the job failed.

  • optionaljobStatus?: created | started | finished | failed | used | restarted

    The current status of the job.

  • optionalresults?: JobResult[]

    Results for each transaction in the job.

  • optionalsuccess?: boolean

    Indicates whether the job was successful.

LaunchNftCollectionAdvancedAdminParams

LaunchNftCollectionAdvancedAdminParams: LaunchNftCollectionTransactionBaseParams & { adminContract: advanced; adminData?: AdvancedNftCollectionAdminData; upgradeAuthority: string; whitelist?: Whitelist }

LaunchNftCollectionData

LaunchNftCollectionData: { body: LaunchNftCollectionStandardAdminParams | LaunchNftCollectionAdvancedAdminParams; path?: never; query?: never; url: /nft/launch }

Type declaration

LaunchNftCollectionError

LaunchNftCollectionError: LaunchNftCollectionErrors[keyof LaunchNftCollectionErrors]

LaunchNftCollectionErrors

LaunchNftCollectionErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

LaunchNftCollectionResponse

LaunchNftCollectionResponse: LaunchNftCollectionResponses[keyof LaunchNftCollectionResponses]

LaunchNftCollectionResponses

LaunchNftCollectionResponses: { 200: NftTransaction }

Type declaration

LaunchNftCollectionStandardAdminParams

LaunchNftCollectionStandardAdminParams: LaunchNftCollectionTransactionBaseParams & { adminContract: standard }

LaunchNftCollectionTransactionBaseParams

LaunchNftCollectionTransactionBaseParams: NftTransactionBaseParams & { adminContract?: standard | advanced; adminContractAddress?: string; adminContractPrivateKey?: string; baseURL?: string; collectionAddress?: string; collectionContractPrivateKey?: string; collectionData?: CollectionData; collectionName: string; creator?: string; masterNFT: NftMintParams; symbol?: string; txType?: nft:launch; url?: string }

LaunchTokenAdvancedAdminParams

LaunchTokenAdvancedAdminParams: LaunchTokenTransactionBaseParams & { adminContract: advanced; canMint: whitelist | anyone; requireAdminSignatureForMint?: boolean; totalSupply?: number; whitelist?: Whitelist }

LaunchTokenBondingCurveAdminParams

LaunchTokenBondingCurveAdminParams: LaunchTokenTransactionBaseParams & { adminContract: bondingCurve }

LaunchTokenData

LaunchTokenData: { body: LaunchTokenStandardAdminParams | LaunchTokenAdvancedAdminParams | LaunchTokenBondingCurveAdminParams; path?: never; query?: never; url: /token/launch }

Type declaration

LaunchTokenError

LaunchTokenError: LaunchTokenErrors[keyof LaunchTokenErrors]

LaunchTokenErrors

LaunchTokenErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

LaunchTokenResponse

LaunchTokenResponse: LaunchTokenResponses[keyof LaunchTokenResponses]

LaunchTokenResponses

LaunchTokenResponses: { 200: TokenTransaction }

Type declaration

LaunchTokenStandardAdminParams

LaunchTokenStandardAdminParams: LaunchTokenTransactionBaseParams & { adminContract: standard }

LaunchTokenTransactionBaseParams

LaunchTokenTransactionBaseParams: TokenTransactionBaseParams & { adminContract: standard | advanced | bondingCurve; adminContractAddress?: string; adminContractPrivateKey?: string; decimals?: number; symbol: string; tokenAddress?: string; tokenContractPrivateKey?: string; txType?: token:launch; uri: string | TokenInfo }

MintNftData

MintNftData: { body: NftMintTransactionParams; path?: never; query?: never; url: /nft/mint }

Type declaration

MintNftError

MintNftError: MintNftErrors[keyof MintNftErrors]

MintNftErrors

MintNftErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

MintNftResponse

MintNftResponse: MintNftResponses[keyof MintNftResponses]

MintNftResponses

MintNftResponses: { 200: NftTransaction }

Type declaration

MintTokensData

MintTokensData: { body: TokenMintTransactionParams; path?: never; query?: never; url: /token/mint }

Type declaration

MintTokensError

MintTokensError: MintTokensErrors[keyof MintTokensErrors]

MintTokensErrors

MintTokensErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

MintTokensResponse

MintTokensResponse: MintTokensResponses[keyof MintTokensResponses]

MintTokensResponses

MintTokensResponses: { 200: TokenTransaction }

Type declaration

NftApproveParams

NftApproveParams: { to?: string }

Type declaration

  • optionalto?: string

    The address of the recipient. If not provided, the existing approval will be removed.

NftApproveTransactionParams

NftApproveTransactionParams: DeployedNftTransactionBaseParams & { nftApproveParams: NftApproveParams; txType: nft:approve }

NftBuyParams

NftBuyParams: { buyer?: string }

Type declaration

  • optionalbuyer?: string

    The address of the buyer

NftBuyTransactionParams

NftBuyTransactionParams: DeployedNftTransactionBaseParams & { nftBuyParams: NftBuyParams; txType: nft:buy }

NftData

NftData: { approved?: string; canApprove?: boolean; canChangeMetadata?: boolean; canChangeMetadataVerificationKeyHash?: boolean; canChangeName?: boolean; canChangeOwnerByProof?: boolean; canChangeStorage?: boolean; canPause?: boolean; canTransfer?: boolean; id?: string; isPaused?: boolean; owner?: string; requireOwnerAuthorizationToUpgrade?: boolean; version?: number }

Type declaration

  • optionalapproved?: string

    The public key of the approved address of the NFT

  • optionalcanApprove?: boolean

    Specifies if the NFT's approved address can be changed (readonly)

  • optionalcanChangeMetadata?: boolean

    Indicates whether the NFT's metadata can be updated (readonly)

  • optionalcanChangeMetadataVerificationKeyHash?: boolean

    Indicates whether the verification key hash for the metadata can be changed (readonly)

  • optionalcanChangeName?: boolean

    Specifies if the name of the NFT can be changed (readonly)

  • optionalcanChangeOwnerByProof?: boolean

    Determines whether the NFT's ownership can be changed via a zero-knowledge proof (readonly)

  • optionalcanChangeStorage?: boolean

    Determines whether the storage associated with the NFT can be altered (readonly)

  • optionalcanPause?: boolean

    Specifies if the NFT contract can be paused, preventing certain operations (readonly)

  • optionalcanTransfer?: boolean

    Specifies if the NFT's ownership can be transferred (readonly)

  • optionalid?: string

    The unique identifier of the NFT within the collection. A bigint encoded as a string.

  • optionalisPaused?: boolean

    Indicates whether the NFT contract is currently paused

  • optionalowner?: string

    The public key of the owner of the NFT

  • optionalrequireOwnerAuthorizationToUpgrade?: boolean

    Determines whether the owner's authorization is required to upgrade the NFT's verification key (readonly)

  • optionalversion?: number

    The version number of the NFT state

NftInfo

NftInfo: { approved?: string; approvedType?: string; approvedVerificationKeyHash?: string; canApprove: boolean; canChangeMetadata: boolean; canChangeMetadataVerificationKeyHash: boolean; canChangeName: boolean; canChangeOwnerByProof: boolean; canChangeStorage: boolean; canPause: boolean; canTransfer: boolean; chain: string; collectionAddress: string; collectionBaseURL?: string; collectionName: string; collectionSymbol?: string; collectionUri?: string; contractType: nft; contractVerificationKeyHash: string; contractVersion: number; created: number; description?: string; id: string; image: string; isPaused: boolean; likes?: number; metadata: {}; metadataRoot: string; metadataVerificationKeyHash: string; name: string; owner: string; price?: number; rating: number; requireOwnerAuthorizationToUpgrade: boolean; status: string; storage: string; symbol: string; tokenAddress: string; tokenId: string; type: nft | collection; updated: number; uri: string; version: number }

Type declaration

  • optionalapproved?: string
  • optionalapprovedType?: string
  • optionalapprovedVerificationKeyHash?: string
  • canApprove: boolean
  • canChangeMetadata: boolean
  • canChangeMetadataVerificationKeyHash: boolean
  • canChangeName: boolean
  • canChangeOwnerByProof: boolean
  • canChangeStorage: boolean
  • canPause: boolean
  • canTransfer: boolean
  • chain: string
  • collectionAddress: string
  • optionalcollectionBaseURL?: string

    The base URL of the collection.

  • collectionName: string
  • optionalcollectionSymbol?: string

    The symbol of the collection.

  • optionalcollectionUri?: string

    The URI of the collection.

  • contractType: nft
  • contractVerificationKeyHash: string

    The verification key hash of the contract.

  • contractVersion: number

    The version number of the contract.

  • created: number
  • optionaldescription?: string
  • id: string
  • image: string
  • isPaused: boolean
  • optionallikes?: number
  • metadata: {}
    • [key string]: unknown
  • metadataRoot: string
  • metadataVerificationKeyHash: string
  • name: string
  • owner: string
  • optionalprice?: number
  • rating: number
  • requireOwnerAuthorizationToUpgrade: boolean
  • status: string
  • storage: string
  • symbol: string
  • tokenAddress: string
  • tokenId: string
  • type: nft | collection
  • updated: number
  • uri: string
  • version: number

NftMetadata

NftMetadata: { banner?: string; description?: string; image: string; name: string; traits?: Trait[] }

Type declaration

  • optionalbanner?: string

    Optional banner image URL or IPFS hash. Required for Collection Master NFT.

  • optionaldescription?: string

    Optional description of the NFT

  • image: string

    The image URL or IPFS hash associated with the NFT

  • name: string

    The name of the NFT

  • optionaltraits?: Trait[]

    Array of traits associated with the NFT

NftMintParams

NftMintParams: { address?: string; addressPrivateKey?: string; data: NftData; expiry?: number; fee?: number; metadata: string | NftMetadata; metadataVerificationKeyHash?: string; name: string; storage?: string; tokenId?: number }

Type declaration

  • optionaladdress?: string

    The address of the NFT contract

  • optionaladdressPrivateKey?: string

    The private key of the NFT contract

  • data: NftData

    The data associated with the NFT, including owner, approved, version, id, permissions and flags

  • optionalexpiry?: number

    The expiry time slot for minting the NFT

  • optionalfee?: number

    The fee associated with minting the NFT

  • metadata: string | NftMetadata

    The metadata associated with the NFT, Field as a string or NftMetadata object

  • optionalmetadataVerificationKeyHash?: string

    The hash of the verification key used for metadata proofs, Field as a string

  • name: string

    The name of the NFT

  • optionalstorage?: string

    The off-chain storage information (e.g., IPFS hash)

  • optionaltokenId?: number

    The token ID of the NFT

NftMintTransactionParams

NftMintTransactionParams: DeployedNftCollectionTransactionBaseParams & { nftMintParams: NftMintParams; txType: nft:mint }

NftRequestAnswer

NftRequestAnswer: { collection: CollectionInfo; nft: NftInfo }

Type declaration

NftRequestParams

NftRequestParams: { collectionAddress: string; nftAddress?: string }

Type declaration

  • collectionAddress: string

    Always set to B62qs2NthDuxAT94tTFg6MtuaP1gaBxTZyNv9D3uQiQciy1VsaimNFT for Mina NFT V2.

  • optionalnftAddress?: string

    The unique NFT address.

NftSellParams

NftSellParams: { offerAddress?: string; offerPrivateKey?: string; price: number }

Type declaration

  • optionalofferAddress?: string

    The address of the offer contract

  • optionalofferPrivateKey?: string

    The private key of the offer contract

  • price: number

    The price of the NFT

NftSellTransactionParams

NftSellTransactionParams: DeployedNftTransactionBaseParams & { nftSellParams: NftSellParams; txType: nft:sell }

NftTransaction

NftTransaction: TransactionPayloads & { collectionName: string; map?: {}; metadataRoot?: string; nftName: string; privateMetadata?: string; request: NftTransactionParams & { txType: NftTransactionType }; storage?: string; symbol: string }

NftTransactionBaseParams

NftTransactionBaseParams: { collectionAddress?: string; developerFee?: number; memo?: string; nftAddress?: string; nonce?: number; sender: string; senderPrivateKey?: string; txType?: NftTransactionType }

Type declaration

  • optionalcollectionAddress?: string

    Optional. The address of the NFT collection.

  • optionaldeveloperFee?: number

    Optional. The developer fee for the transaction.

  • optionalmemo?: string

    Optional. A memo for the transaction.

  • optionalnftAddress?: string

    Optional. The address of the NFT.

  • optionalnonce?: number

    Optional. The nonce for the transaction.

  • sender: string

    The address (public key) of the sender.

  • optionalsenderPrivateKey?: string

    The private key of the sender. It is NOT recommended to use this field. Please use the sender field instead. Use this field at your own risk and only if you know what you are doing and do not have access to mina-signer or wallet to get the signature.

  • optionaltxType?: NftTransactionType

    Type of the NFT transaction.

NftTransactionParams

NftTransactionParams: LaunchNftCollectionStandardAdminParams | LaunchNftCollectionAdvancedAdminParams | NftMintTransactionParams | NftSellTransactionParams | NftBuyTransactionParams | NftTransferTransactionParams | NftApproveTransactionParams

NftTransactionType

NftTransactionType: nft:launch | nft:mint | nft:transfer | nft:approve | nft:sell | nft:buy

NftTransactions

NftTransactions: { txs: NftTransaction[] }

Type declaration

NftTransferParams

NftTransferParams: { context?: { custom?: string[] }; from?: string; price?: number; requireApproval?: boolean; to: string }

Type declaration

  • optionalcontext?: { custom?: string[] }

    The custom context for the transfer

    • optionalcustom?: string[]

      The custom context for the transfer, 3 Fields

  • optionalfrom?: string

    The address of the owner or approved

  • optionalprice?: number

    The price of the NFT being transferred

  • optionalrequireApproval?: boolean

    If true, the transfer requires approval from the admin contract

  • to: string

    The address of the recipient

NftTransferTransactionParams

NftTransferTransactionParams: DeployedNftTransactionBaseParams & { nftTransferParams: NftTransferParams; txType: nft:transfer }

NftV2RequestAnswer

NftV2RequestAnswer: { algolia?: {}; contractAddress?: string; contractUri?: string; metadata?: {}; metadataRoot?: { data?: string; kind?: string }; name?: string; nftAddress?: string; owner?: string; price?: number; storage?: string; tokenId?: string; tokenSymbol?: string; version?: number }

Type declaration

  • optionalalgolia?: {}
    • [key string]: unknown
  • optionalcontractAddress?: string
  • optionalcontractUri?: string
  • optionalmetadata?: {}
    • [key string]: unknown
  • optionalmetadataRoot?: { data?: string; kind?: string }
    • optionaldata?: string
    • optionalkind?: string
  • optionalname?: string
  • optionalnftAddress?: string
  • optionalowner?: string
  • optionalprice?: number
  • optionalstorage?: string
  • optionaltokenId?: string
  • optionaltokenSymbol?: string
  • optionalversion?: number

NonceRequestParams

NonceRequestParams: { address: string }

Type declaration

  • address: string

    The Mina address for which to retrieve the nonce.

NonceResponse

NonceResponse: { address: string; hasAccount?: boolean; nonce?: number }

Type declaration

  • address: string

    The Mina address for which the nonce was requested.

  • optionalhasAccount?: boolean

    Indicates whether the account exists.

  • optionalnonce?: number

    The nonce for the specified address.

Options

Options<TData, ThrowOnError>: ClientOptions<TData, ThrowOnError> & { client?: Client; meta?: Record<string, unknown> }

Type parameters

  • TData: TDataShape = TDataShape
  • ThrowOnError: boolean = boolean

ProofResult

ProofResult: { error?: string; hash?: string; success?: boolean }

Type declaration

  • optionalerror?: string

    Error message if proof generation failed.

  • optionalhash?: string

    The transaction hash if the proof was successfully applied.

  • optionalsuccess?: boolean

    Indicates whether the proof generation was successful.

ProveData

ProveData: { body: ProveTokenTransaction | ProveTokenTransactions | ProveNftTransaction | ProveNftTransactions; path?: never; query?: never; url: /transaction/prove }

Type declaration

ProveError

ProveError: ProveErrors[keyof ProveErrors]

ProveErrors

ProveErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

ProveNftTransaction

ProveNftTransaction: { sendTransaction?: boolean; signedData: string; tx: NftTransaction }

Type declaration

  • optionalsendTransaction?: boolean

    Optional. Whether to broadcast the transaction after proving.

  • signedData: string

    The signed data for the transaction.

  • tx: NftTransaction

    The transaction object.

ProveNftTransactions

ProveNftTransactions: { txs: ProveNftTransaction[] }

Type declaration

ProveResponse

ProveResponse: ProveResponses[keyof ProveResponses]

ProveResponses

ProveResponses: { 200: JobId }

Type declaration

  • 200: JobId

    Successfully initiated proof generation.

ProveTokenTransaction

ProveTokenTransaction: { sendTransaction?: boolean; signedData: string; tx: TokenTransaction }

Type declaration

  • optionalsendTransaction?: boolean

    Optional. Whether to broadcast the transaction after proving.

  • signedData: string

    The signed data for the transaction.

  • tx: TokenTransaction

    The transaction object.

ProveTokenTransactions

ProveTokenTransactions: { txs: ProveTokenTransaction[] }

Type declaration

RedeemTokensData

RedeemTokensData: { body: TokenRedeemTransactionParams; path?: never; query?: never; url: /token/redeem }

Type declaration

RedeemTokensError

RedeemTokensError: RedeemTokensErrors[keyof RedeemTokensErrors]

RedeemTokensErrors

RedeemTokensErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

RedeemTokensResponse

RedeemTokensResponse: RedeemTokensResponses[keyof RedeemTokensResponses]

RedeemTokensResponses

RedeemTokensResponses: { 200: TokenTransaction }

Type declaration

SellNftData

SellNftData: { body: NftSellTransactionParams; path?: never; query?: never; url: /nft/sell }

Type declaration

SellNftError

SellNftError: SellNftErrors[keyof SellNftErrors]

SellNftErrors

SellNftErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

SellNftResponse

SellNftResponse: SellNftResponses[keyof SellNftResponses]

SellNftResponses

SellNftResponses: { 200: NftTransaction }

Type declaration

SellTokensData

SellTokensData: { body: TokenSellTransactionParams; path?: never; query?: never; url: /token/bid/sell }

Type declaration

SellTokensError

SellTokensError: SellTokensErrors[keyof SellTokensErrors]

SellTokensErrors

SellTokensErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

SellTokensResponse

SellTokensResponse: SellTokensResponses[keyof SellTokensResponses]

SellTokensResponses

SellTokensResponses: { 200: TokenTransaction }

Type declaration

SendTransactionData

SendTransactionData: { body: SendTransactionParams; path?: never; query?: never; url: /transaction/send }

Type declaration

SendTransactionError

SendTransactionError: SendTransactionErrors[keyof SendTransactionErrors]

SendTransactionErrors

SendTransactionErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

SendTransactionParams

SendTransactionParams: { transaction: string }

Type declaration

  • transaction: string

    The transaction to send.

SendTransactionReply

SendTransactionReply: { error?: {}; hash?: string; status?: string; success: boolean }

Type declaration

  • optionalerror?: {}

    Error details if the transaction failed.

    • [key string]: unknown
  • optionalhash?: string

    The transaction hash if successful.

  • optionalstatus?: string

    The status of the transaction.

  • success: boolean

    Whether the transaction was sent to the network.

SendTransactionResponse

SendTransactionResponse: SendTransactionResponses[keyof SendTransactionResponses]

SendTransactionResponses

SendTransactionResponses: { 200: SendTransactionReply }

Type declaration

TokenAirdropTransactionParams

TokenAirdropTransactionParams: DeployedTokenTransactionBaseParams & { recipients: { address: string; amount: number; memo?: string }[]; txType?: token:airdrop }

TokenBidData

TokenBidData: { body: TokenBidTransactionParams; path?: never; query?: never; url: /token/bid/create }

Type declaration

TokenBidError

TokenBidError: TokenBidErrors[keyof TokenBidErrors]

TokenBidErrors

TokenBidErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

TokenBidResponse

TokenBidResponse: TokenBidResponses[keyof TokenBidResponses]

TokenBidResponses

TokenBidResponses: { 200: TokenTransaction }

Type declaration

TokenBidTransactionParams

TokenBidTransactionParams: DeployedTokenTransactionBaseParams & { amount: number; bidAddress?: string; bidPrivateKey?: string; price: number; txType?: token:bid:create; whitelist?: Whitelist }

TokenBurnTransactionParams

TokenBurnTransactionParams: DeployedTokenTransactionBaseParams & { amount: number; from: string; txType?: token:burn }

TokenBuyTransactionParams

TokenBuyTransactionParams: DeployedTokenTransactionBaseParams & { amount: number; offerAddress: string; txType?: token:offer:buy }

TokenHolder

TokenHolder: { address: string; balance: number; isZkappAccount: boolean; percentage: number }

Type declaration

  • address: string

    The address of the token holder

  • balance: number

    The total token balance held by this address

  • isZkappAccount: boolean

    Whether this holder is a zkApp account

  • percentage: number

    The percentage of total token supply held by this address

TokenHoldersRequestParams

TokenHoldersRequestParams: { address: string }

Type declaration

  • address: string

    The Mina address for which to retrieve the holders

TokenHoldersResponse

TokenHoldersResponse: { holders: TokenHolder[] }

Type declaration

  • holders: TokenHolder[]

    Array of token holders and their balances

TokenInfo

TokenInfo: { adminContractsCode?: string[]; description?: string; discord?: string; facebook?: string; imageBase64?: string; imageUrl?: string; instagram?: string; name?: string; symbol?: string; telegram?: string; tokenContractCode?: string; twitter?: string; website?: string }

Type declaration

  • optionaladminContractsCode?: string[]

    Optional. Code for the admin contracts.

  • optionaldescription?: string

    Optional. Description of the token.

  • optionaldiscord?: string

    Optional. Discord link associated with the token.

  • optionalfacebook?: string

    Optional. Facebook page associated with the token.

  • optionalimageBase64?: string

    Optional. Base64-encoded image data (max 1 MB).

  • optionalimageUrl?: string

    Optional. URL of the token image.

  • optionalinstagram?: string

    Optional. Instagram handle associated with the token.

  • optionalname?: string

    Optional. The name of the token.

  • optionalsymbol?: string

    The symbol of the token.

  • optionaltelegram?: string

    Optional. Telegram link associated with the token.

  • optionaltokenContractCode?: string

    Optional. Code for the token contract.

  • optionaltwitter?: string

    Optional. Twitter handle associated with the token.

  • optionalwebsite?: string

    Optional. Official website of the token.

TokenInfoRequestParams

TokenInfoRequestParams: { tokenAddress: string }

Type declaration

  • tokenAddress: string

    The address of the token contract.

TokenMintTransactionParams

TokenMintTransactionParams: DeployedTokenTransactionBaseParams & { amount: number; price?: number; to: string; txType?: token:mint }

TokenOfferData

TokenOfferData: { body: TokenOfferTransactionParams; path?: never; query?: never; url: /token/offer/create }

Type declaration

TokenOfferError

TokenOfferError: TokenOfferErrors[keyof TokenOfferErrors]

TokenOfferErrors

TokenOfferErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

TokenOfferResponse

TokenOfferResponse: TokenOfferResponses[keyof TokenOfferResponses]

TokenOfferResponses

TokenOfferResponses: { 200: TokenTransaction }

Type declaration

TokenOfferTransactionParams

TokenOfferTransactionParams: DeployedTokenTransactionBaseParams & { amount: number; offerAddress?: string; offerPrivateKey?: string; price: number; txType?: token:offer:create; whitelist?: Whitelist }

TokenRedeemTransactionParams

TokenRedeemTransactionParams: DeployedTokenTransactionBaseParams & { amount: number; price: number; slippage?: number; txType?: token:redeem }

TokenSellTransactionParams

TokenSellTransactionParams: DeployedTokenTransactionBaseParams & { amount: number; bidAddress: string; txType?: token:bid:sell }

TokenState

TokenState: { adminAddress: string; adminContractAddress: string; adminTokenBalance: number; adminTokenSymbol: string; adminUri: string; adminVerificationKeyHash: string; adminVersion: number; decimals: number; isPaused: boolean; tokenAddress: string; tokenId: string; tokenSymbol: string; totalSupply: number; uri: string; verificationKeyHash: string; version: number }

Type declaration

  • adminAddress: string

    The address of the administrator.

  • adminContractAddress: string

    The address of the admin contract.

  • adminTokenBalance: number

    The token balance of the administrator.

  • adminTokenSymbol: string

    The symbol of the admin token.

  • adminUri: string

    The URI of the admin token metadata.

  • adminVerificationKeyHash: string

    The verification key hash of the admin contract.

  • adminVersion: number
  • decimals: number

    The number of decimal places the token uses.

  • isPaused: boolean

    Indicates if the token contract is paused.

  • tokenAddress: string

    The address of the token contract.

  • tokenId: string

    The unique identifier of the token.

  • tokenSymbol: string

    The symbol of the token.

  • totalSupply: number

    The total supply of the token.

  • uri: string

    The URI of the token metadata.

  • verificationKeyHash: string

    The verification key hash of the token contract.

  • version: number

    The version number of the token contract.

TokenSymbolAndAdmin

TokenSymbolAndAdmin: { adminAddress: string; adminContractAddress: string; tokenAddress: string; tokenSymbol: string }

Type declaration

  • adminAddress: string

    The address of the administrator.

  • adminContractAddress: string

    The address of the admin contract.

  • tokenAddress: string

    The address of the token contract.

  • tokenSymbol: string

    The symbol of the token.

TokenTransaction

TokenTransaction: TransactionPayloads & { request: TokenTransactionParams & { txType: TokenTransactionType }; symbol: string }

TokenTransactionBaseParams

TokenTransactionBaseParams: { developerFee?: number; memo?: string; nonce?: number; sender: string; senderPrivateKey?: string; tokenAddress?: string; txType?: TokenTransactionType }

Type declaration

  • optionaldeveloperFee?: number

    Optional. The developer fee for the transaction.

  • optionalmemo?: string

    Optional. A memo for the transaction.

  • optionalnonce?: number

    Optional. The nonce for the transaction.

  • sender: string

    The address (public key) of the sender.

  • optionalsenderPrivateKey?: string

    The private key of the sender. It is NOT recommended to use this field. Please use the sender field instead. Use this field at your own risk and only if you know what you are doing and do not have access to mina-signer or wallet to get the signature.

  • optionaltokenAddress?: string

    Optional. The address of the token contract.

  • optionaltxType?: TokenTransactionType

    Type of the token transaction.

TokenTransactionParams

TokenTransactionParams: LaunchTokenStandardAdminParams | LaunchTokenAdvancedAdminParams | TokenMintTransactionParams | TokenBurnTransactionParams | TokenRedeemTransactionParams | TokenTransferTransactionParams | TokenAirdropTransactionParams | TokenOfferTransactionParams | TokenBidTransactionParams | TokenBuyTransactionParams | TokenSellTransactionParams | TokenWithdrawBidTransactionParams | TokenWithdrawOfferTransactionParams | TokenUpdateBidWhitelistTransactionParams | TokenUpdateOfferWhitelistTransactionParams | TokenUpdateAdminWhitelistTransactionParams

TokenTransactionType

TokenTransactionType: token:launch | token:mint | token:burn | token:redeem | token:transfer | token:bid:create | token:offer:create | token:offer:buy | token:bid:sell | token:airdrop | token:bid:withdraw | token:offer:withdraw | token:bid:whitelist | token:offer:whitelist | token:admin:whitelist

TokenTransactions

TokenTransactions: { txs: TokenTransaction[] }

Type declaration

TokenTransferTransactionParams

TokenTransferTransactionParams: DeployedTokenTransactionBaseParams & { amount: number; to: string; txType?: token:transfer }

TokenUpdateAdminWhitelistTransactionParams

TokenUpdateAdminWhitelistTransactionParams: DeployedTokenTransactionBaseParams & { adminAddress: string; txType?: token:admin:whitelist; whitelist: Whitelist }

TokenUpdateBidWhitelistTransactionParams

TokenUpdateBidWhitelistTransactionParams: DeployedTokenTransactionBaseParams & { bidAddress: string; txType?: token:bid:whitelist; whitelist: Whitelist }

TokenUpdateOfferWhitelistTransactionParams

TokenUpdateOfferWhitelistTransactionParams: DeployedTokenTransactionBaseParams & { offerAddress: string; txType?: token:offer:whitelist; whitelist: Whitelist }

TokenWithdrawBidTransactionParams

TokenWithdrawBidTransactionParams: DeployedTokenTransactionBaseParams & { amount: number; bidAddress: string; txType?: token:bid:withdraw }

TokenWithdrawOfferTransactionParams

TokenWithdrawOfferTransactionParams: DeployedTokenTransactionBaseParams & { amount: number; offerAddress: string; txType?: token:offer:withdraw }

Trait

Trait: { isPrivate?: boolean; key: string; type: string | text | image | url | field | number | address | map | tree; value: string | {} }

Type declaration

  • optionalisPrivate?: boolean

    Optional flag indicating if this trait is private

  • key: string

    The trait key/name

  • type: string | text | image | url | field | number | address | map | tree

    The type of the trait value

  • value: string | {}

    The trait value, can be a string or complex object depending on type

TransactionData

TransactionData: { accountUpdatesCount: number; fee: number; hash: string; isZkappAccount: boolean; memo: string; proverAddress: string; status: string; timestamp: number; updatedAccounts: { accountAddress: string; isZkappAccount: boolean; verificationKeyHash?: string }[] }

Type declaration

  • accountUpdatesCount: number

    Number of account updates in the transaction

  • fee: number

    Transaction fee

  • hash: string

    Transaction hash

  • isZkappAccount: boolean

    Whether this is a zkApp account

  • memo: string

    Transaction memo

  • proverAddress: string

    Address of the prover

  • status: string

    Status of the transaction

  • timestamp: number

    Timestamp of the transaction

  • updatedAccounts: { accountAddress: string; isZkappAccount: boolean; verificationKeyHash?: string }[]

TransactionPayloads

TransactionPayloads: { fee: number; memo: string; minaSignerPayload: { feePayer: { fee?: number; feePayer?: string; memo?: string; nonce?: number }; zkappCommand: {} }; nonce: number; proverPayload: string; sendTransaction?: boolean; sender: string; signedData: string; transaction: string; walletPayload: { feePayer?: { fee?: number; memo?: string }; nonce?: number; onlySign?: boolean; transaction?: string } }

Type declaration

  • fee: number

    The fee for the transaction.

  • memo: string

    A memo for the transaction.

  • minaSignerPayload: { feePayer: { fee?: number; feePayer?: string; memo?: string; nonce?: number }; zkappCommand: {} }
    • feePayer: { fee?: number; feePayer?: string; memo?: string; nonce?: number }
      • optionalfee?: number

        The fee for the transaction.

      • optionalfeePayer?: string

        The fee payer's address.

      • optionalmemo?: string

        A memo for the transaction.

      • optionalnonce?: number

        The nonce for the transaction.

    • zkappCommand: {}

      The zkApp command data.

      • [key string]: unknown
  • nonce: number

    The nonce for the transaction.

  • proverPayload: string

    The payload for the prover.

  • optionalsendTransaction?: boolean

    Optional. Whether to broadcast the transaction after proving.

  • sender: string

    The address initiating the transaction.

  • signedData: string

    The signed data for the transaction.

  • transaction: string

    The raw transaction data.

  • walletPayload: { feePayer?: { fee?: number; memo?: string }; nonce?: number; onlySign?: boolean; transaction?: string }
    • optionalfeePayer?: { fee?: number; memo?: string }
      • optionalfee?: number

        The fee for the transaction.

      • optionalmemo?: string

        A memo for the transaction.

    • optionalnonce?: number

      The nonce for the transaction.

    • optionalonlySign?: boolean

      Indicates if only signature is needed.

    • optionaltransaction?: string

      The transaction data.

TransactionStatus

TransactionStatus: { details?: { blockHeight?: number; blockStatus?: string; stateHash?: string; timestamp?: number; txHash?: string; txStatus?: string }; error?: string; hash?: string; status?: pending | applied | failed | unknown }

Type declaration

  • optionaldetails?: { blockHeight?: number; blockStatus?: string; stateHash?: string; timestamp?: number; txHash?: string; txStatus?: string }

    The details of the transaction.

    • optionalblockHeight?: number

      The height of the block containing the transaction.

    • optionalblockStatus?: string

      The status of the block.

    • optionalstateHash?: string

      The state hash of the block.

    • optionaltimestamp?: number

      The timestamp of the block.

    • optionaltxHash?: string

      The transaction hash.

    • optionaltxStatus?: string

      The status of the transaction in the block.

  • optionalerror?: string

    The transaction hash.

  • optionalhash?: string

    The transaction hash.

  • optionalstatus?: pending | applied | failed | unknown

    The status of the transaction.

TransactionStatusParams

TransactionStatusParams: { hash: string }

Type declaration

  • hash: string

    The transaction hash to check the status of.

TransactionsListRequestParams

TransactionsListRequestParams: { address?: string; tokenAddress?: string; tokenId?: string }

Type declaration

  • optionaladdress?: string

    The Mina address for which to retrieve the transactions. Optional

  • optionaltokenAddress?: string

    The address of the token contract (optional). One of tokenAddress or tokenId is required.

  • optionaltokenId?: string

    The token ID (optional). One of tokenAddress or tokenId is required.

TransactionsListResponse

TransactionsListResponse: { transactions: TransactionData[] }

Type declaration

TransferNftData

TransferNftData: { body: NftTransferTransactionParams; path?: never; query?: never; url: /nft/transfer }

Type declaration

TransferNftError

TransferNftError: TransferNftErrors[keyof TransferNftErrors]

TransferNftErrors

TransferNftErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

TransferNftResponse

TransferNftResponse: TransferNftResponses[keyof TransferNftResponses]

TransferNftResponses

TransferNftResponses: { 200: NftTransaction }

Type declaration

TransferTokensData

TransferTokensData: { body: TokenTransferTransactionParams; path?: never; query?: never; url: /token/transfer }

Type declaration

TransferTokensError

TransferTokensError: TransferTokensErrors[keyof TransferTokensErrors]

TransferTokensErrors

TransferTokensErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

TransferTokensResponse

TransferTokensResponse: TransferTokensResponses[keyof TransferTokensResponses]

TransferTokensResponses

TransferTokensResponses: { 200: TokenTransaction }

Type declaration

TxStatus

TxStatus: { blockHeight?: number; blockStatus?: string; stateHash?: string; timestamp?: number; txHash?: string; txStatus?: string }

Type declaration

  • optionalblockHeight?: number

    The height of the block containing the transaction.

  • optionalblockStatus?: string

    The status of the block.

  • optionalstateHash?: string

    The state hash of the block.

  • optionaltimestamp?: number

    The timestamp of the block.

  • optionaltxHash?: string

    The transaction hash.

  • optionaltxStatus?: string

    The status of the transaction in the block.

TxStatusData

TxStatusData: { body: TransactionStatusParams; path?: never; query?: never; url: /transaction/status }

Type declaration

TxStatusError

TxStatusError: TxStatusErrors[keyof TxStatusErrors]

TxStatusErrors

TxStatusErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

TxStatusResponse

TxStatusResponse: TxStatusResponses[keyof TxStatusResponses]

TxStatusResponses

TxStatusResponses: { 200: TransactionStatus }

Type declaration

UpdateTokenAdminWhitelistData

UpdateTokenAdminWhitelistData: { body: TokenUpdateAdminWhitelistTransactionParams; path?: never; query?: never; url: /token/admin/whitelist }

Type declaration

UpdateTokenAdminWhitelistError

UpdateTokenAdminWhitelistError: UpdateTokenAdminWhitelistErrors[keyof UpdateTokenAdminWhitelistErrors]

UpdateTokenAdminWhitelistErrors

UpdateTokenAdminWhitelistErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

UpdateTokenAdminWhitelistResponse

UpdateTokenAdminWhitelistResponse: UpdateTokenAdminWhitelistResponses[keyof UpdateTokenAdminWhitelistResponses]

UpdateTokenAdminWhitelistResponses

UpdateTokenAdminWhitelistResponses: { 200: TokenTransaction }

Type declaration

UpdateTokenBidWhitelistData

UpdateTokenBidWhitelistData: { body: TokenUpdateBidWhitelistTransactionParams; path?: never; query?: never; url: /token/bid/whitelist }

Type declaration

UpdateTokenBidWhitelistError

UpdateTokenBidWhitelistError: UpdateTokenBidWhitelistErrors[keyof UpdateTokenBidWhitelistErrors]

UpdateTokenBidWhitelistErrors

UpdateTokenBidWhitelistErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

UpdateTokenBidWhitelistResponse

UpdateTokenBidWhitelistResponse: UpdateTokenBidWhitelistResponses[keyof UpdateTokenBidWhitelistResponses]

UpdateTokenBidWhitelistResponses

UpdateTokenBidWhitelistResponses: { 200: TokenTransaction }

Type declaration

UpdateTokenOfferWhitelistData

UpdateTokenOfferWhitelistData: { body: TokenUpdateOfferWhitelistTransactionParams; path?: never; query?: never; url: /token/offer/whitelist }

Type declaration

UpdateTokenOfferWhitelistError

UpdateTokenOfferWhitelistError: UpdateTokenOfferWhitelistErrors[keyof UpdateTokenOfferWhitelistErrors]

UpdateTokenOfferWhitelistErrors

UpdateTokenOfferWhitelistErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

UpdateTokenOfferWhitelistResponse

UpdateTokenOfferWhitelistResponse: UpdateTokenOfferWhitelistResponses[keyof UpdateTokenOfferWhitelistResponses]

UpdateTokenOfferWhitelistResponses

UpdateTokenOfferWhitelistResponses: { 200: TokenTransaction }

Type declaration

Whitelist

Whitelist: { address: string; amount?: number }[] | string

Optional. List of whitelisted addresses with optional amounts, or a string.

WithdrawTokenBidData

WithdrawTokenBidData: { body: TokenWithdrawBidTransactionParams; path?: never; query?: never; url: /token/bid/withdraw }

Type declaration

WithdrawTokenBidError

WithdrawTokenBidError: WithdrawTokenBidErrors[keyof WithdrawTokenBidErrors]

WithdrawTokenBidErrors

WithdrawTokenBidErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

WithdrawTokenBidResponse

WithdrawTokenBidResponse: WithdrawTokenBidResponses[keyof WithdrawTokenBidResponses]

WithdrawTokenBidResponses

WithdrawTokenBidResponses: { 200: TokenTransaction }

Type declaration

WithdrawTokenOfferData

WithdrawTokenOfferData: { body: TokenWithdrawOfferTransactionParams; path?: never; query?: never; url: /token/offer/withdraw }

Type declaration

WithdrawTokenOfferError

WithdrawTokenOfferError: WithdrawTokenOfferErrors[keyof WithdrawTokenOfferErrors]

WithdrawTokenOfferErrors

WithdrawTokenOfferErrors: { 400: ErrorResponse; 401: ErrorResponse; 403: ErrorResponse; 429: ErrorResponse; 500: ErrorResponse; 503: ErrorResponse }

Type declaration

WithdrawTokenOfferResponse

WithdrawTokenOfferResponse: WithdrawTokenOfferResponses[keyof WithdrawTokenOfferResponses]

WithdrawTokenOfferResponses

WithdrawTokenOfferResponses: { 200: TokenTransaction }

Type declaration

Page Options