Transaction types

function makeSTXTokenTransfer(options: STXTokenTransferOptions): Promise<StacksTransaction>

import { makeSTXTokenTransfer, AnchorMode } from '@stacks/transactions';

const transaction = await makeSTXTokenTransfer({
  recipient: 'SP2J6Y09JMFWWZCT4VJX0BA5W7A9HZP5EX96Y6VZY',
  amount: 1000000n, // 1 STX
  senderKey: 'b244296d5907de9864c0b0d51f98a13c52890be0404e83f273144cd5b9960eed01',
  network: 'mainnet'
});

const transaction = await makeSTXTokenTransfer({
  recipient: 'SP2J6Y09JMFWWZCT4VJX0BA5W7A9HZP5EX96Y6VZY',
  amount: 500000n, // 0.5 STX
  senderKey: privateKey,
  memo: 'Invoice #12345',
  fee: 200n,
  anchorMode: AnchorMode.OnChainOnly
});

function makeContractCall(options: ContractCallOptions): Promise<StacksTransaction>

import { makeContractCall, uintCV } from '@stacks/transactions';

const transaction = await makeContractCall({
  contractAddress: 'SP2J6Y09JMFWWZCT4VJX0BA5W7A9HZP5EX96Y6VZY',
  contractName: 'counter',
  functionName: 'increment',
  functionArgs: [uintCV(1)],
  senderKey: privateKey,
  network: 'testnet'
});

import { makeContractCall, uintCV, stringAsciiCV, Pc, PostConditionMode } from '@stacks/transactions';

const postCondition = Pc.principal(senderAddress)
  .willSendLte(500000n)
  .ustx();

const transaction = await makeContractCall({
  contractAddress: 'SP2J6Y09JMFWWZCT4VJX0BA5W7A9HZP5EX96Y6VZY',
  contractName: 'marketplace',
  functionName: 'list-item',
  functionArgs: [
    uintCV(1000000),
    stringAsciiCV('Digital Art #42')
  ],
  senderKey: privateKey,
  postConditions: [postCondition],
  postConditionMode: PostConditionMode.Deny
});

function makeContractDeploy(options: ContractDeployOptions): Promise<StacksTransaction>

import { makeContractDeploy } from '@stacks/transactions';

const contractCode = `
(define-public (get-message)
  (ok "Hello, Stacks!"))
`;

const transaction = await makeContractDeploy({
  contractName: 'hello-world',
  codeBody: contractCode,
  senderKey: privateKey,
  network: 'mainnet'
});

import { makeContractDeploy, ClarityVersion } from '@stacks/transactions';

const clarityV2Contract = `
;; Using Clarity 2 features
(define-public (get-block-info)
  (ok block-height))
`;

const transaction = await makeContractDeploy({
  contractName: 'advanced-contract',
  codeBody: clarityV2Contract,
  clarityVersion: ClarityVersion.Clarity2,
  senderKey: privateKey,
  fee: 50000n // Higher fee for complex contracts
});

function sponsorTransaction(options: SponsorOptions): StacksTransaction

import { makeSTXTokenTransfer, sponsorTransaction } from '@stacks/transactions';

// User creates transaction with sponsored flag
const userTx = await makeSTXTokenTransfer({
  recipient: 'SP2J6Y09JMFWWZCT4VJX0BA5W7A9HZP5EX96Y6VZY',
  amount: 1000000n,
  senderKey: userPrivateKey,
  sponsored: true,
  fee: 0n
});

// Sponsor signs and pays
const sponsoredTx = sponsorTransaction({
  transaction: userTx,
  sponsorPrivateKey: sponsorKey,
  fee: 1000n
});

const userTx = await makeContractCall({
  contractAddress: 'SP2J6Y09JMFWWZCT4VJX0BA5W7A9HZP5EX96Y6VZY',
  contractName: 'nft-marketplace',
  functionName: 'list-item',
  functionArgs: [uintCV(tokenId)],
  senderKey: userPrivateKey,
  sponsored: true
});

const sponsoredTx = sponsorTransaction({
  transaction: userTx,
  sponsorPrivateKey: platformSponsorKey
});

function makeUnsignedSTXTokenTransfer(options: UnsignedSTXOptions): Promise<StacksTransaction>

import {
  makeUnsignedSTXTokenTransfer,
  createMultiSigSpendingCondition,
  pubKeyfromPrivKey,
  nextSignature,
  TransactionSigner
} from '@stacks/transactions';

// Setup 2-of-3 multisig
const pubKeys = [
  pubKeyfromPrivKey(privateKey1),
  pubKeyfromPrivKey(privateKey2),
  pubKeyfromPrivKey(privateKey3)
];

const address = createMultiSigSpendingCondition(2, pubKeys);

// Create unsigned transaction
const unsignedTx = await makeUnsignedSTXTokenTransfer({
  recipient: 'SP2J6Y09JMFWWZCT4VJX0BA5W7A9HZP5EX96Y6VZY',
  amount: 1000000n,
  publicKey: address.address,
  network: 'mainnet'
});

// Sign with first key
const signer = new TransactionSigner(unsignedTx);
signer.signOrigin(privateKey1);

// Sign with second key
nextSignature(privateKey2).signOrigin(signer);

const signedTx = signer.transaction;

import { estimateTransactionFee } from '@stacks/transactions';

// Build transaction first
const transaction = await makeContractCall({...});

// Estimate fee
const fee = await estimateTransactionFee(transaction);
console.log('Estimated fee:', fee);

// Apply estimated fee
transaction.setFee(fee);

import { getNonce } from '@stacks/transactions';

// Get current nonce
const nonce = await getNonce(senderAddress, network);

// Use in transaction
const transaction = await makeSTXTokenTransfer({
  recipient: 'SP2J6Y09JMFWWZCT4VJX0BA5W7A9HZP5EX96Y6VZY',
  amount: 1000000n,
  senderKey: privateKey,
  nonce: nonce + 1n // Next nonce
});

import { broadcastTransaction } from '@stacks/transactions';

async function sendAndMonitor(transaction: StacksTransaction) {
  // Broadcast
  const result = await broadcastTransaction(transaction);
  console.log('Broadcast successful:', result.txid);
  
  // Poll for confirmation
  const txId = result.txid;
  let confirmed = false;
  
  while (!confirmed) {
    const response = await fetch(
      `https://api.mainnet.hiro.so/extended/v1/tx/${txId}`
    );
    const txInfo = await response.json();
    
    if (txInfo.tx_status === 'success') {
      console.log('Transaction confirmed!');
      confirmed = true;
    } else if (txInfo.tx_status.startsWith('abort')) {
      throw new Error(`Transaction failed: ${txInfo.tx_status}`);
    }
    
    // Wait before next check
    await new Promise(resolve => setTimeout(resolve, 10000));
  }
}

## Further reading

- [Transaction building](/reference/stacks.js/local-accounts/transaction-building)
- [Contract calls](/reference/stacks.js/local-accounts/contract-calls)
- [Post-conditions](/reference/stacks.js/security-postconditions/understanding-postconditions)