',
'Content-Type': 'multipart/form-data'
},
body: JSON.stringify({
username: 'newName',
password: 'password',
phoneNumber: '1234567890',
image: 'base64 encoded image'
})
})
.then(response => {
console.log(response.json());
})
.catch(err => {
console.error(err);
});
```
{% endtab %}
{% endtabs %}
# Blockchain Smart-Contract
Stage Meta TPAs smart-contract public methods documentation:
{% hint style="success" %}
you can get our latest smart-contract details from [`Latest contract API`](/reference/api-reference/latest-contract-api).
{% endhint %}
## Plaque price method:
The `plaquePrice()` is a `public` method that allows users to get the current TPA price.
{% content-ref url="/pages/1IPFKesRpHmgyMlKfSB6" %}
[Plaque Price Method](/reference/blockchain-smart-contract/plaque-price-method)
{% endcontent-ref %}
## Check mintTransfer method:
The `checkMintTransfer()` is a `public` method that allows users to check whether the given TPA names are available for purchase or have already been minted. It takes two input parameters: `_names`, an array of `bytes32` representing the TPA names to be checked, and `_amounts`, an array of `uint32` representing the amount of TPAs to be checked.
{% content-ref url="/pages/LZd1ITw3jN1F773uoclY" %}
[Check mintTranfer Method](/reference/blockchain-smart-contract/check-minttranfer-method)
{% endcontent-ref %}
## MintTransfer method:
The `mintTransfer()` is a `payable` method that allows users to buy newly minted TPAs. To use this method, you need to send `plaquePrice * _names.length` amount of `value` in Wei to this transaction as TPAs price.
{% content-ref url="/pages/Oaz09GkYo7leW0Iw548U" %}
[MintTransfer method](/reference/blockchain-smart-contract/minttransfer-method)
{% endcontent-ref %}
## Token owners method:
The `tokenOwners()` is a `public` method that takes a plaque ID `_plaqueId` as input and returns an array of addresses of token owners who own the plaque with the given ID.
{% content-ref url="/pages/NZZ2MnRQqJXUWkrzCA6y" %}
[Token Owners Method](/reference/blockchain-smart-contract/token-owners-method)
{% endcontent-ref %}
{% hint style="info" %}
If you're using `typescript` code examples in methods page, before every example use this code here to prepare your provider to web3, ethereum wallet, smart-contract instance and abi.
{% endhint %}
import axios from "axios";
import { ethers, providers, utils } from "ethers";
const provider = new providers.WebSocketProvider(
"wss://eth-sepolia.g.alchemy.com/v2/ATnZ4...." // provider
);
const signer = new ethers.Wallet(
"aab5433a31f1bb3e...", // your ethereum wallet private key
provider
);
const res = await axios.get(
"https://cdn.stagemeta.dev/contracts/2.0.0.json" // StageMeta smart-contract contract abi
);
const abi = JSON.stringify(res.data);
const inter = new utils.Interface(abi);
const stageMetaContract = new ethers.Contract(
"0x4b39ceb401769e3e...", // StageMeta smart-contract address
abi,
signer
);
# Plaque Price Method
The `plaquePrice()` is a `public` method that allows users to get the current TPA price.
function plaquePrice() public view (uint256)
#### Input & Output
This method takes no input parameters. It returns a `uint256` value representing the current `TPA price` in wei.
#### Usage
To use this method in your web3 code, you can create a new instance of the StageMeta contract and call the `plaquePrice()` method like this:
```typescript
const tpaPriceWei = await stageMetaContract.plaquePrice()
console.log("TPA Price in eth:", utils.formatEther(tpaPriceWei));
```
# Check mintTranfer Method
The `checkMintTransfer()` is a `public` method that allows users to check whether the given TPA names are available for purchase or have already been minted. It takes two input parameters: `_names`, an array of `bytes32` representing the TPA names to be checked, and `_amounts`, an array of `uint32` representing the amount of TPAs to be checked.
```solidity
function checkMintTransfer(bytes32[] _names, uint32[] _amounts) public view returns(bool)
```
#### Input & Output
* `_names`: an array of `bytes32` representing the TPA names to be checked.
* `_amounts`: an array of `uint32` representing the amount of TPAs to be checked. The length of this array should be the same as the length of the `_names` array, and all elements should be set to 1.
* This function returns a boolean value indicating whether the given TPAs are available for purchase (`true`) or have already been minted (`false`).
#### Usage
For example:
const result = await stageMetaContract.checkMintTransfer(
[
ethers.utils.formatBytes32String("aaa-000"),
ethers.utils.formatBytes32String("bbb-000")
],
[1, 1]);
console.log("check result:", result);
# MintTransfer method
The `mintTransfer()` is a `payable` method that allows users to buy newly minted TPAs. To use this method, you need to send `plaquePrice * _names.length` amount of `value` in Wei to this transaction as TPAs price.
```solidity
function mintTransfer(bytes32[] _names, uint32[] _amounts, string _outputData) external payable
```
#### Input & Output
* `_names`: an array of `bytes32` representing the TPA names to be minted.
* `_amounts`: an array of `uint32` representing the amount of TPAs to be minted. The length of this array should be the same as the length of the `_names` array, and all elements should be set to 1.
* `_outputData`: a string representing the output data to be sent to us. It should be a JSON-encoded object with either a "username" or a "name" property. Recording the username or TPA name in the output data and pinging someone is optional. However, it's worth noting that to ping a TPA, the TPA owner must have registered their username on the platform. Additionally, you cannot use both the "username" and "name" properties simultaneously.
* This function doesn't return anything, only a transaction hash to follow your transaction with.
#### Usage
To use this method, you can create a new instance of the StageMeta smart-contract and call the `mintTransfer()` method, like this:
const options = {
value: ethers.utils.parseEther("0.06498719370006499"), // TPAs price
gasLimit: 500000,
};
const mintTransferResult = await stageMetaContract.mintTransfer(
[
ethers.utils.formatBytes32String("aaa-888"),
ethers.utils.formatBytes32String("aaa-999")
],
[1, 1],
JSON.stringify({
name: 'aaa-000', //or username: 'stagemeta'
}),
options
);
console.log("mintTransferResult:", mintTransferResult);
# Token Owners Method
The `tokenOwners()` is a `public` method that takes a plaque ID `_plaqueId` as input and returns an array of addresses of token owners who own the plaque with the given ID.
```solidity
function tokenOwners(uint32 _plaqueId) public view returns(address[] memory)
```
#### Input & Output
* `_plaqueId`: The ID of the plaque for which to retrieve the owners.
* `address[]`: An array of addresses representing the owners of the plaque with the given ID.
#### Usage
In the example below, the `tokenOwners` function is called with plaque ID `1234` and returns an array of addresses representing the owners of plaque ID `1234`.
```typescript
const result = await stageMetaContract.tokenOwners(1234);
console.log("TPA Owners:", result);
```