@glittr-sdk/sdk NPM

Glittr Client SDK

The Glittr-SDK is a JavaScript/TypeScript library that provides a simple interface for interacting with the Glittr ecosystem. It allows you to create and broadcast Glittr transactions, such as creating contracts, minting, transferring, and more.

Installation

To use the Glittr-SDK, you'll need to install it as a dependency in your project:

npm install @glittr-sdk/sdk

API Key

You need API key to be able to interact with Glittr APIs. You can go to Glittr Dev Portal and signup for api key.

Usage

Here’s an example of how to use the Glittr-SDK to create and broadcast a Deploy Free Mint contract using a prebuilt transaction:

Prebuilt Transaction

import { Account, GlittrSDK, GlittrTransaction } from "@glittr-sdk/sdk";

async function main() {
  const NETWORK = 'regtest'

  const client = new GlittrSDK({
    network: NETWORK,
    apiKey: <your api key>,
    glittrApi: "https://devnet-core-api.glittr.fi", // devnet
    electrumApi: "https://devnet-electrum.glittr.fi" // devnet
  });
  const account = new Account({
    network: NETWORK,
    wif: <your WIF key>
  });
  const transaction = new GlittrTransaction({
    account: account,
    client: client
  })

  const txid = await transaction.contractDeployment.freeMint("PONDS", 18, "100", "100000000") 
  console.log("Transaction ID:", txid);
}

main();

or you can use our helper functions to construct the transaction (input and output) manually:

Manual Transaction

import { Account, addFeeToTx, BitcoinUTXO, electrumFetchNonGlittrUtxos, GlittrSDK, OpReturnMessage, Output, txBuilder } from "@glittr-sdk/sdk";

async function deployFreeMintContract() {
  const NETWORK = 'regtest'
  
  const client = new GlittrSDK({
    network: NETWORK,
    apiKey: <your api key>,
  })
  const account = new Account({
    network: NETWORK,
    wif: <your WIF key>,
  })
  
  const tx: OpReturnMessage = {
    contract_creation: {
      contract_type: {
        moa: {
          divisibility: 18,
          live_time: 0,
          supply_cap: "1000000000",
          ticker: "FKBTC",
          mint_mechanism: { free_mint: { amount_per_mint: "10", supply_cap: "1000000000" } }
        }
      },
    },
  };

  // Helper function to fetch non Glittr UTXOs
  const utxos = await electrumFetchNonGlittrUtxos(client, account.p2wpkh().address)
  
  const nonFeeInputs: BitcoinUTXO[] = []
  const nonFeeOutputs: Output[] = [
    { script: txBuilder.compile(tx), value: 0 } // Output #0 should always be the OP_RETURN message
  ]

  // Helper function to include fee into the tx
  const { inputs, outputs } = await addFeeToTx(
    NETWORK,
    account.p2wpkh().address,
    utxos,
    nonFeeInputs,
    nonFeeOutputs
  )

  const txid = await client.createAndBroadcastRawTx({
    account: account.p2wpkh(),
    inputs,
    outputs
  })
  console.log("Transaction ID:", txid);
}

deployFreeMintContract()

Prebuilt Transaction

The SDK provides prebuilt methods for creating Glittr transaction messages.

Transfer

const txid = await transaction.transfer(
    [
      {
        amount: '1000',
        contractId: '108018:1',
        receiver: 'mroHGEtVBLxKoo34HSHbHdmKz1ooJdA3ew'
      }
    ]
)

Deploy Free Mint Contract

const txid = await transaction.contractDeployment.freeMint("GLITTR", 18, "100", "100000000")

Deploy Paid Mint Contract

const txid = await transaction.contractDeployment.paidMint(
  "GLITTR",
  18,
  { input_asset: "raw_btc", ratio: { fixed: { ratio: [1, 1] } } },
  "1000000000"
)

Manual Message Build

This SDK allows you to construct custom messages by defining them in TypeScript using our supported message format. To do this, create a new variable and cast it to the OpReturnMessage type.

Transfer

  const t: OpReturnMessage = {
    transfer: {
      transfers: [
          {
            amount: "100",
            asset: [108170, 1],
            output: 1
          },
          {
            amount: "200",
            asset: [110180, 1],
            output: 2
          }
      ],
    },
  };

Deploy Free Mint Contract

  const t: OpReturnMessage = {
    contract_creation: {
      contract_type: {
        moa: {
          divisibility: 18,
          live_time: 0,
          supply_cap: 2000n.toString(),
          ticker: "GLITTR",
          mint_mechanism: {
            free_mint: {
              amount_per_mint: 10n.toString(),
              supply_cap: 2000n.toString(),
            },
          },
        },
      },
    },
  };

Deploy Paid Mint Contract

  const t: OpReturnMessage = {
    contract_creation: {
      contract_type: {
        moa: {
          divisibility: 18,
          live_time: 0,
          supply_cap: 2000n.toString(),
          ticker: "GLITTR",
          mint_mechanism: {
            purchase: {
              input_asset: "raw_btc",
              ratio: { fixed: { ratio: [1, 1] } },
            },
          },
        },
      },
    },
  };

APIs

GlittrTransaction

The GlittrTransaction class provides high-level methods for creating various types of Glittr transactions. Each method and its parameters are described below:

`transfer`

async transaction.transfer(transfers: TransferParams[]): Promise<string>

Parameters:

transfers: Array of transfer objects with the following structure:

type TransferParams = {
  contractId: string;    // Format: "block:txIndex"
  amount: string;        // Amount to transfer
  receiver: string;      // Receiver's address
}

Returns:
- Promise<string>: Transaction ID of the broadcasted transaction

Contract Deployment Methods

The contractDeployment property provides methods for deploying different types of contracts:

`freeMint`

async transaction.contractDeployment.freeMint(
  ticker: string,
  divisibility: number,
  amountPerMint: string,
  supplyCap?: string
): Promise<string>

Parameters:
- ticker: Token ticker symbol
- divisibility: Number of decimal places
- amountPerMint: Amount that can be minted per transaction
- supplyCap: Optional maximum supply cap
Returns:
- Promise<string>: Transaction ID of the broadcasted transaction

`paidMint`

async transaction.contractDeployment.paidMint(
  ticker: string,
  divisibility: number,
  mechanism: PurchaseBurnSwap,
  supplyCap?: string
): Promise<string>

Parameters:
- ticker: Token ticker symbol
- divisibility: Number of decimal places
- mechanism: Object containing:
```
type PurchaseBurnSwap = {
  input_asset: string;
  pay_to_key?: string;
  ratio: {
    fixed: {
      ratio: [number, number]
    }
  }
}
```
- supplyCap: Optional maximum supply cap
Returns:
- Promise<string>: Transaction ID of the broadcasted transaction

`liquidityPoolInitiate`

async transaction.contractDeployment.liquidityPoolInitiate(
  inputAsset: [string, string],
  inputAmount: [string, string]
): Promise<string>

Parameters:
- inputAsset: Tuple of two asset IDs in format "block:txIndex", "block:txIndex"
- inputAmount: Tuple of amounts for each asset
Returns:
- Promise<string>: Transaction ID of the broadcasted transaction

Contract Call Methods

The contractCall property provides methods for interacting with deployed contracts:

`mint`

async transaction.contractCall.mint(
  contractId: string,
  receiver: string,
  oracleMessage?: OracleMessageSigned
): Promise<string>

Parameters:
- contractId: Contract ID in format "block:txIndex"
- receiver: Address to receive the minted tokens
- oracleMessage: Optional signed oracle message for specific mint types
Returns:
- Promise<string>: Transaction ID of the broadcasted transaction