Deploy and mint equity tokens with the DALP TypeScript API

Create an equity token with the DALP TypeScript client, set the required roles, unpause the token, and mint verified shareholder supply.

Equity issuance connects a priced equity token, wallet verification, token roles, and verified shareholder wallets through DALP APIs.

Use the TypeScript client path below to create the token, grant supply roles, unpause the token, and mint shares. The runbook does not configure collateral, transfer rules, or issuer-specific legal terms.

Rendering diagram...

Prerequisites

Before running these commands, you need:

A running DALP instance and its platform URL.
A DALP API key for your account.
A wallet on that account with PINCODE verification enabled.
An admin operator who can grant the system tokenManager role.
Registered identities for every wallet that receives minted shares.

Your wallet address is available during onboarding and from the user.me response in Step 2.

The equity create request requires priceCurrency, basePrice, and countryCode. class, category, and uniqueIdentifier are optional. Use class and category when the share class fits DALP's equity taxonomy. Use uniqueIdentifier for an ISIN or other approved reporting identifier when the equity has one.

You can use an empty array [] for initialModulePairs to create the equity without initial compliance modules and configure modules later. To add collateral requirements, see Configure equity collateral.

Quick reference

Step	What	SDK call
1	Create client	`createDalpClient`
2	Get user info	`dalp.user.me`
3	Grant system roles	Platform role setup
4	Create equity token	`dalp.token.create` (type: `"equity"`)
5	Grant token roles	`dalp.token.grantRole`
6	Unpause token	`dalp.token.unpause`
7	Mint shares	`dalp.token.mint`
8	Verify holders	`dalp.token.holders`

Equity token lifecycle flow

This diagram shows the complete equity token deployment and minting workflow:

Rendering diagram...

Equity-specific controls:

Control	What to set	Why it matters
Price	`priceCurrency` and `basePrice`	Stores the reference share price used by the asset metadata and claim flow.
Jurisdiction	`countryCode`	Uses the ISO 3166-1 numeric country code for the token jurisdiction.
Classification	Optional `class` and `category`	Adds equity taxonomy data when the issuance fits the platform values.
Identifier	Optional `uniqueIdentifier`	Carries an ISIN or approved reporting identifier when one exists.
Wallet verification	`walletVerification` on state-changing calls	Authorizes token creation, role grants, unpause, and mint operations.
Identity registration	Registered recipient identities	Minting to an unregistered recipient fails before supply moves.
Token roles	`supplyManagement` and `emergency`	`supplyManagement` mints shares. `emergency` unpauses the token.

Step-by-step commands

Step 1: create the client

Create the SDK client with your platform URL and API key.

import { createDalpClient } from "@settlemint/dalp-sdk";

async function main() {
  // Step 1: Create the SDK client
  const dalp = createDalpClient({
    url: "https://your-platform.example.com",
    apiKey: "YOUR_API_KEY",
  });
  const pincode = "YOUR_PINCODE";

Step 2: check you're logged in

  // Step 2: Get your wallet address
  const me = await dalp.user.me({});
  const myWallet = me.data.wallet;
  if (!myWallet) {
    throw new Error("No wallet found. Create a wallet first via the DALP dashboard.");
  }
  console.log("Wallet:", myWallet);

Save your wallet address. You need it when you grant token roles, unpause the token, and mint shares.

Step 3: set up system roles

Grant the roles and identities before you create or mint the equity.

Grant tokenManager to the operator creating the token.
Grant identityManager to the operator creating or registering issuer and recipient identities.
For a wallet without a system identity, create the identity first. Then register the wallet in the identity registry.
Register the issuer wallet identity before minting to it.
Register every recipient wallet identity before Step 7.
Grant claimPolicyManager only when your setup also needs to manage trusted issuers or claim topics.

For the platform setup sequence, see First Administrator Setup.

If you do not have operator access, ask the platform administrator to grant the required system roles and register the required identities before continuing.

Step 4: create equity token

  // Step 4: Create equity token
  const equity = await dalp.token.create({
    body: {
      type: "equity",
      name: "Series B Voting Shares",
      symbol: "SBVS",
      decimals: 18,
      countryCode: "840",
      priceCurrency: "USD",
      basePrice: "10.00",
      class: "COMMON_EQUITY",
      category: "VOTING_COMMON_STOCK",
      uniqueIdentifier: "US0378331005",
      initialModulePairs: [],
      walletVerification: {
        secretVerificationCode: pincode,
        verificationType: "PINCODE",
      },
    },
  });

  if ("transactionId" in equity) {
    console.log("Equity creation queued:", equity.transactionId);
    return;
  }
  const tokenAddress = equity.data.id;
  console.log("Equity created:", tokenAddress);

Parameters:

type: Must be "equity"
name: Equity name (e.g., "Series B Voting Shares")
symbol: Equity symbol (e.g., "SBVS")
decimals: Use 0 for whole-share cap table parity or 18 for fractional ownership.
countryCode: ISO 3166-1 numeric country code as a string, such as "840" for the United States, "056" for Belgium, or "276" for Germany.
priceCurrency: ISO 4217 currency code for the reference share price, such as "USD".
basePrice: Decimal string for the reference price in priceCurrency, such as "10.00".
class: Optional equity class from DALP's equity taxonomy, such as COMMON_EQUITY, PREFERRED_EQUITY, or SECTOR_INDUSTRY_EQUITY.
category: Optional equity category from DALP's equity taxonomy, such as VOTING_COMMON_STOCK, DUAL_CLASS_SHARES, or RESTRICTED_STOCK.
uniqueIdentifier: Optional ISIN or approved reporting identifier. Omit it for private or pre-ISIN rounds.
initialModulePairs: Initial compliance modules. Use [] when you are creating the token first and adding modules later.
walletVerification: PINCODE or another enabled wallet verification type for the signing wallet.

The call returns the equity data with id, which is the token contract address. Save that address for Step 5.

Step 5: grant token roles

Grant supplyManagement and emergency on the equity contract before minting.

When you create a token, the creator receives the token admin role, which can grant other token roles. The mint call requires supplyManagement. The unpause call requires emergency.

  // Step 5: Grant token roles
  await dalp.token.grantRole({
    params: { tokenAddress },
    body: {
      accounts: [myWallet],
      role: "supplyManagement",
      walletVerification: {
        secretVerificationCode: pincode,
        verificationType: "PINCODE",
      },
    },
  });
  await dalp.token.grantRole({
    params: { tokenAddress },
    body: {
      accounts: [myWallet],
      role: "emergency",
      walletVerification: {
        secretVerificationCode: pincode,
        verificationType: "PINCODE",
      },
    },
  });
  console.log("Roles granted");

Expected: the role grant transaction completes. Wait for transaction confirmation before proceeding to Step 6.

Note: add governance to the roles array if you plan to change compliance modules or ROFR settings via API.

Step 6: unpause the equity

New tokens start paused. Unpause to enable transfers:

  // Step 6: Unpause the equity
  await dalp.token.unpause({
    params: { tokenAddress },
    body: {
      walletVerification: {
        secretVerificationCode: pincode,
        verificationType: "PINCODE",
      },
    },
  });
  console.log("Equity unpaused");

Note: this step requires the emergency role from Step 5. Make sure Step 5 completed successfully and the transaction was confirmed before unpausing.

Step 7: mint shares

The recipient wallet must be registered in the identity registry before minting. If you mint to your own wallet, register your own identity in Step 3. If you mint to investors or employee wallets, register those recipient identities first.

  // Step 7: Mint shares — 100 shares
  await dalp.token.mint({
    params: { tokenAddress },
    body: {
      recipients: [myWallet],
      amounts: [100_000_000_000_000_000_000n],
      walletVerification: {
        secretVerificationCode: pincode,
        verificationType: "PINCODE",
      },
    },
  });
  console.log("Minted shares");

Parameters:

tokenAddress: Equity contract address from Step 4.
recipients: Recipient wallet addresses. Every address must be registered in the identity registry.
amounts: Mint amounts in token units. The example mints 100_000_000_000_000_000_000n, which is 100 shares when the token uses 18 decimals.

The mint call requires the supplyManagement role from Step 5. If the platform returns RecipientNotVerified, register the recipient identity. Retry the mint after registration completes.

Step 8: verify holders

  // Step 8: Verify holders
  const holders = await dalp.token.holders({ params: { tokenAddress }, query: { limit: 200 } });
  console.log("Holders:", holders.data);

The response shows holders and balances for the equity token. You should see the recipient wallet with the minted share balance.

For cap table, tax, shareholder communication, or statutory reporting workflows, reconcile the holder data with the issuer's off-platform records and the compliance modules configured for the equity.

Full script

import { createDalpClient } from "@settlemint/dalp-sdk";

async function main() {
  // Step 1: Create the SDK client
  const dalp = createDalpClient({
    url: "https://your-platform.example.com",
    apiKey: "YOUR_API_KEY",
  });
  const pincode = "YOUR_PINCODE";

  // Step 2: Get your wallet address
  const me = await dalp.user.me({});
  const myWallet = me.data.wallet;
  if (!myWallet) {
    throw new Error("No wallet found. Create a wallet first via the DALP dashboard.");
  }
  console.log("Wallet:", myWallet);

  // Step 3: Set up system roles
  // Follow the Set Up Roles guide to grant yourself 'tokenManager'

  // Step 4: Create equity token
  const equity = await dalp.token.create({
    body: {
      type: "equity",
      name: "Series B Voting Shares",
      symbol: "SBVS",
      decimals: 18,
      countryCode: "840",
      priceCurrency: "USD",
      basePrice: "10.00",
      class: "COMMON_EQUITY",
      category: "VOTING_COMMON_STOCK",
      uniqueIdentifier: "US0378331005",
      initialModulePairs: [],
      walletVerification: {
        secretVerificationCode: pincode,
        verificationType: "PINCODE",
      },
    },
  });

  if ("transactionId" in equity) {
    console.log("Equity creation queued:", equity.transactionId);
    return;
  }
  const tokenAddress = equity.data.id;
  console.log("Equity created:", tokenAddress);

  // Step 5: Grant token roles
  await dalp.token.grantRole({
    params: { tokenAddress },
    body: {
      accounts: [myWallet],
      role: "supplyManagement",
      walletVerification: {
        secretVerificationCode: pincode,
        verificationType: "PINCODE",
      },
    },
  });
  await dalp.token.grantRole({
    params: { tokenAddress },
    body: {
      accounts: [myWallet],
      role: "emergency",
      walletVerification: {
        secretVerificationCode: pincode,
        verificationType: "PINCODE",
      },
    },
  });
  console.log("Roles granted");

  // Step 6: Unpause the equity
  await dalp.token.unpause({
    params: { tokenAddress },
    body: {
      walletVerification: {
        secretVerificationCode: pincode,
        verificationType: "PINCODE",
      },
    },
  });
  console.log("Equity unpaused");

  // Step 7: Mint shares — 100 shares
  await dalp.token.mint({
    params: { tokenAddress },
    body: {
      recipients: [myWallet],
      amounts: [100_000_000_000_000_000_000n],
      walletVerification: {
        secretVerificationCode: pincode,
        verificationType: "PINCODE",
      },
    },
  });
  console.log("Minted shares");

  // Step 8: Verify holders
  const holders = await dalp.token.holders({ params: { tokenAddress }, query: { limit: 200 } });
  console.log("Holders:", holders.data);
}

await main();

Equity token with on-chain governance parameters

Troubleshooting

Error or symptom	What to check
`Authentication missing`	Check the API key passed to `createDalpClient`.
`PINCODE_INVALID`	Re-enter the PINCODE or use another enabled wallet verification type.
`USER_NOT_AUTHORIZED` or missing `tokenManager`	Ask a system `admin` to grant `tokenManager` before token creation.
Permission denied during mint or unpause	Grant the token `supplyManagement` role for minting and `emergency` role for unpause.
Token is paused	Confirm Step 6 succeeded before testing transfers.
`RecipientNotVerified`	Register the recipient wallet in the identity registry, then retry the mint.
Invalid `class` or `category`	Use one of the values in the DALP equity taxonomy. These fields are optional when the issuance does not fit a taxonomy value.

Deploy and mint equity

On this page