Interact with smart contracts

Create transactions to work with smart contracts.

Lock Assets in Smart Contract

Token locking is a feature where certain assets are reserved on the smart contract. The assets can only be unlocked when certain conditions are met, for example, when making a purchase.

In this showcase, we will lock selected assets from your wallet to analways succeed smart contract, where unlocking assets requires the correct datum. In practice, multiple assets (both native assets and lovelace) can be sent to the contract in a single transaction.

If you do not have the script address, in Mesh, we can resolve the script address with Resolve Script Address from the script's CBOR (4e4d01000033222220051200120011). Here's how you can do it:

import { resolvePlutusScriptAddress } from '@meshsdk/core';
import type { PlutusScript } from '@meshsdk/core';

const script: PlutusScript = {
  code: '4e4d01000033222220051200120011',
  version: 'V1',
};

const scriptAddress = resolvePlutusScriptAddress(script, 0);

To lock assets in this contract, here's the full code:

import { Transaction, Asset } from '@meshsdk/core';

// this is the script address of always succeed contract
const scriptAddress = 'addr_test1wpnlxv2xv9a9ucvnvzqakwepzl9ltx7jzgm53av2e9ncv4sysemm8';

const tx = new Transaction({ initiator: wallet })
  .sendAssets(
    {
      address: scriptAddress,
      datum: {
        value: 'supersecret',
      },
    },
    [
      {
        unit: "64af286e2ad0df4de2e7de15f8ff5b3d27faecf4ab2757056d860a424d657368546f6b656e",
        quantity: "1",
      },
    ],
  );

const unsignedTx = await tx.build();
const signedTx = await wallet.signTx(unsignedTx);
const txHash = await wallet.submitTx(signedTx);

If the transaction is successful, you may want to copy one of the asset's unit and the datum you used in this transaction. These information are required to unlock the assets.

Lock assets in smart contract

Define a datum and select assets to lock in smart contract. Note: this demo only works on preprod network.

Lock assets in smart contract
No wallets installed

Unlock Assets from Smart Contract

As we may have locked assets in the contract, you can create transactions to unlock the assets with a redeemer that corresponds to the datum. Define the corresponding code to create the datum, only a transaction with the corrent datum hash is able to unlock the asset. Define the unit of the locked asset to search for the UTXO in the smart contract, which is required for the transaction's input.

First, let's create a function to fetch input UTXO from the script address. This input UTXO is needed for transaction builder. In this demo, we are using KoiosProvider, but this can be interchange with other providers that Mesh provides, see Providers.

async function _getAssetUtxo({ scriptAddress, asset, datum }) {
  const koios = new KoiosProvider('preprod');

  const utxos = await koios.fetchAddressUTxOs(
    scriptAddress,
    asset
  );

  const dataHash = resolveDataHash(datum);

  let utxo = utxos.find((utxo: any) => {
    return utxo.output.dataHash == dataHash;
  });

  return utxo;
}

Then, we query the script address for the UTXO that contain the data hash:

// fetch input UTXO
const assetUtxo = await _getAssetUtxo({
  scriptAddress: 'addr_test1wpnlxv2xv9a9ucvnvzqakwepzl9ltx7jzgm53av2e9ncv4sysemm8',
  asset: '64af286e2ad0df4de2e7de15f8ff5b3d27faecf4ab2757056d860a424d657368546f6b656e',
  datum: 'supersecret',
});

Then, we create the transaction. 4e4d01000033222220051200120011 is the script CBOR for always succeed smart contract.

// create the unlock asset transaction
const tx = new Transaction({ initiator: wallet })
  .redeemValue({
    value: assetUtxo,
    script: {
      version: 'V1',
      code: '4e4d01000033222220051200120011',
    },
    datum: 'supersecret',
  })
  .sendValue(address, assetUtxo) // address is recipient address
  .setRequiredSigners([address]);

Lastly, we build and sign the transaction. Note that here we need to set partial sign to true.

const unsignedTx = await tx.build();
// note that the partial sign is set to true
const signedTx = await wallet.signTx(unsignedTx, true);

Putting them all together, here's the code to unlock assets from smart contract:

async function _getAssetUtxo({ scriptAddress, asset, datum }) {
  const koios = new KoiosProvider('preprod');

  const utxos = await koios.fetchAddressUTxOs(
    scriptAddress,
    asset
  );

  const dataHash = resolveDataHash(datum);

  let utxo = utxos.find((utxo: any) => {
    return utxo.output.dataHash == dataHash;
  });

  return utxo;
}

// fetch input UTXO
const assetUtxo = await _getAssetUtxo({
  scriptAddress: 'addr_test1wpnlxv2xv9a9ucvnvzqakwepzl9ltx7jzgm53av2e9ncv4sysemm8',
  asset: '64af286e2ad0df4de2e7de15f8ff5b3d27faecf4ab2757056d860a424d657368546f6b656e',
  datum: 'supersecret',
});

// get wallet change address
const address = await wallet.getChangeAddress();

// create the unlock asset transaction
const tx = new Transaction({ initiator: wallet })
  .redeemValue({
    value: assetUtxo,
    script: {
      version: 'V1',
      code: '4e4d01000033222220051200120011',
    },
    datum: 'supersecret',
  })
  .sendValue(address, assetUtxo) // address is recipient address
  .setRequiredSigners([address]);

const unsignedTx = await tx.build();
// note that the partial sign is set to true
const signedTx = await wallet.signTx(unsignedTx, true);
const txHash = await wallet.submitTx(signedTx);
Unlock assets from smart contract

Define the datum and asset's unit to unlock assets in smart contract. Note: give some time for the transaction to confirm before attempt unlocking. This demo only works on preview network.

Unlock assets in smart contract
No wallets installed

Minting Assets with Smart Contract

In this demo, we will use a Plutus Script to mint tokens. This script is designed to always succeed, meaning that anyone can sign and mint tokens with it, as there are no validation on this script.

Firstly, we create a new PlutusScript and redeemer (Action):

import { Action, PlutusScript } from '@meshsdk/core';

const script: PlutusScript = {
  code: plutusMintingScriptCbor,
  version: 'V2',
};

const redeemer: Partial<Action> = {
  tag: 'MINT',
};

You can get the always succeed Plutus script CBOR (to replace plutusMintingScriptCbor) from this gist.

Then, we define the assets and its metadata, and add the script (PlutusScript), redeemer (Action), and theasset (Mint) to the transaction:

import { AssetMetadata, Mint } from '@meshsdk/core';

const assetMetadata1: AssetMetadata = {
  "name": "Mesh Token",
  ...
}

const asset: Mint = {
  assetName: 'MeshToken',
  ...
}

tx.mintAsset(script, asset, redeemer);

Here is the full code:

import { Transaction } from '@meshsdk/core';
import { AssetMetadata, Mint, Action, PlutusScript } from '@meshsdk/core';

const script: PlutusScript = {
  code: plutusMintingScriptCbor,
  version: 'V2',
};

const redeemer: Partial<Action> = {
  tag: 'MINT',
};

const tx = new Transaction({ initiator: wallet });

// define asset#1 metadata
const assetMetadata1: AssetMetadata = {
  "name": "Mesh Token",
  "image": "ipfs://QmRzicpReutwCkM6aotuKjErFCUD213DpwPq6ByuzMJaua",
  "mediaType": "image/jpg",
  "description": "This NFT is minted by Mesh (https://meshjs.dev/)."
};
const asset1: Mint = {
  assetName: 'MeshToken',
  assetQuantity: '1',
  metadata: assetMetadata1,
  label: '721',
  recipient: 'addr_test1vpvx0sacufuypa2k4sngk7q40zc5c4npl337uusdh64kv0c7e4cxr',
};
tx.mintAsset(
  script,
  asset1,
  redeemer,
);

const unsignedTx = await tx.build();
const signedTx = await wallet.signTx(unsignedTx);
const txHash = await wallet.submitTx(signedTx);
Mint assets and send to recipients

Add or remove recipients, input the address and define the asset metadata to mint and send to recipients.

Recipients
Recipient #1
No wallets installed

Designing Datum

With Mesh, you can freely design the datum into any structure according to the plutus smart contract requirements. You can import the Data type to help you design the datum.

import { resolveDataHash } from '@meshsdk/core';
import type { Data } from '@meshsdk/core';

A string

A datum as simple as just a string, preferably a hex string.

A number

It can also be a number.

An array

Or an array, where each item can be a string, number, a list, or a map.

A Map

It can also be a map, where both the keys and its values can be a string, number, a list, or a map.

With constructor

Or a datum with a constructor, where alternative is a number, and fields is an array.

Using Redeemer

You can design the redeemer with a similar logic as datum. Redeemer is with type Action. With Mesh, you can only supply the Data part to construct the redeemer.

import { resolvePaymentKeyHash } from '@meshsdk/core';
import type { Data } from '@meshsdk/core';

Designing Redeemer

A redeemer could be designed in a similar manner as datum, but it has to be supplied differently.

Supplying the StartRedeemer as defined above with the first Used Address as input:

Supplying the SecondRedeemer as defined above:

Supplying the EndRedeemer as defined above:

Transaction construction

We can define the redeemer in redeemValue: