Transaction Types

This reference documents all transaction types supported on the ACDC network, including their structure, encoding, and use cases.

Overview

ACDC supports different transaction types for each chain:

Chain	Transaction Model	Types
Alpha	UTXO/Record	Private transfers, record creation
Delta	Account	Transfers, contract calls, staking, governance

Delta Chain Transactions

Type 0: Legacy Transfer

Simple value transfer between accounts.

Structure:

interface LegacyTransfer {
  type: 0;
  nonce: number;
  gasPrice: bigint;
  gasLimit: bigint;
  to: string;
  value: bigint;
  data: string;        // '0x' for simple transfer
  v: number;
  r: string;
  s: string;
}

Example:

const tx = {
  type: 0,
  nonce: 42,
  gasPrice: parseUnits('10', 9),  // 10 gwei
  gasLimit: 21000n,
  to: 'dx1recipient...',
  value: parseUnits('1.0', 18),
  data: '0x'
};

Gas Cost: 21,000 (base transfer)

Type 1: Access List Transaction

Transfer with access list for gas optimization.

Structure:

interface AccessListTransaction {
  type: 1;
  chainId: number;
  nonce: number;
  gasPrice: bigint;
  gasLimit: bigint;
  to: string;
  value: bigint;
  data: string;
  accessList: AccessListEntry[];
  v: number;
  r: string;
  s: string;
}

interface AccessListEntry {
  address: string;
  storageKeys: string[];
}

Example:

const tx = {
  type: 1,
  chainId: 1,
  nonce: 42,
  gasPrice: parseUnits('10', 9),
  gasLimit: 50000n,
  to: 'dx1contract...',
  value: 0n,
  data: '0xa9059cbb...',  // transfer(address,uint256)
  accessList: [
    {
      address: 'dx1contract...',
      storageKeys: [
        '0x0000...0001',  // balances slot
        '0x0000...0002'   // allowances slot
      ]
    }
  ]
};

Type 2: EIP-1559 Transaction

Dynamic fee transaction with priority fee.

Structure:

interface EIP1559Transaction {
  type: 2;
  chainId: number;
  nonce: number;
  maxPriorityFeePerGas: bigint;
  maxFeePerGas: bigint;
  gasLimit: bigint;
  to: string;
  value: bigint;
  data: string;
  accessList: AccessListEntry[];
  v: number;
  r: string;
  s: string;
}

Example:

const tx = {
  type: 2,
  chainId: 1,
  nonce: 42,
  maxPriorityFeePerGas: parseUnits('2', 9),   // 2 gwei tip
  maxFeePerGas: parseUnits('100', 9),          // 100 gwei max
  gasLimit: 21000n,
  to: 'dx1recipient...',
  value: parseUnits('1.0', 18),
  data: '0x',
  accessList: []
};

Fee Calculation:

actualFee = gasUsed * min(maxFeePerGas, baseFee + maxPriorityFeePerGas)

Type 100: Staking Transaction

Stake delegation and management.

Structure:

interface StakingTransaction {
  type: 100;
  chainId: number;
  nonce: number;
  maxFeePerGas: bigint;
  maxPriorityFeePerGas: bigint;
  gasLimit: bigint;
  action: StakingAction;
  v: number;
  r: string;
  s: string;
}

type StakingAction =
  | { type: 'delegate'; validator: string; amount: bigint }
  | { type: 'undelegate'; validator: string; amount: bigint }
  | { type: 'redelegate'; from: string; to: string; amount: bigint }
  | { type: 'claimRewards' }
  | { type: 'registerValidator'; pubkey: string; commission: number };

Examples:

// Delegate stake
const delegateTx = {
  type: 100,
  action: {
    type: 'delegate',
    validator: 'dx1validator...',
    amount: parseUnits('1000', 18)
  },
  // ... other fields
};

// Claim rewards
const claimTx = {
  type: 100,
  action: { type: 'claimRewards' },
  // ... other fields
};

Type 101: Governance Transaction

Governance proposals and voting.

Structure:

interface GovernanceTransaction {
  type: 101;
  chainId: number;
  nonce: number;
  maxFeePerGas: bigint;
  maxPriorityFeePerGas: bigint;
  gasLimit: bigint;
  action: GovernanceAction;
  v: number;
  r: string;
  s: string;
}

type GovernanceAction =
  | { type: 'propose'; proposal: Proposal }
  | { type: 'vote'; proposalId: number; vote: 'yes' | 'no' | 'abstain' }
  | { type: 'delegate'; delegatee: string }
  | { type: 'execute'; proposalId: number };

Examples:

// Vote on proposal
const voteTx = {
  type: 101,
  action: {
    type: 'vote',
    proposalId: 42,
    vote: 'yes'
  },
  // ... other fields
};

// Create proposal
const proposeTx = {
  type: 101,
  action: {
    type: 'propose',
    proposal: {
      title: 'Increase gas limit',
      description: '...',
      actions: [
        {
          target: 'dx1params...',
          data: '0x...'
        }
      ]
    }
  },
  // ... other fields
};

Type 102: Bridge Transaction

Cross-chain transfers between Alpha and Delta.

Structure:

interface BridgeTransaction {
  type: 102;
  chainId: number;
  nonce: number;
  maxFeePerGas: bigint;
  maxPriorityFeePerGas: bigint;
  gasLimit: bigint;
  action: BridgeAction;
  v: number;
  r: string;
  s: string;
}

type BridgeAction =
  | { type: 'lockAndMint'; amount: bigint; targetAddress: string }
  | { type: 'burnAndRelease'; amount: bigint; targetAddress: string }
  | { type: 'claimBridged'; proof: string };

Alpha Chain Transactions

Private Transfer

Transfer records privately using zero-knowledge proofs.

Structure:

interface PrivateTransfer {
  type: 'private_transfer';
  inputs: RecordInput[];
  outputs: RecordOutput[];
  proof: string;        // ZK proof
  fee: bigint;
}

interface RecordInput {
  commitment: string;
  nullifier: string;    // Prevents double-spend
}

interface RecordOutput {
  commitment: string;
  encryptedData: string;  // Encrypted for recipient
}

Example:

const privateTx = {
  type: 'private_transfer',
  inputs: [
    {
      commitment: '0xabc123...',
      nullifier: '0xdef456...'
    }
  ],
  outputs: [
    {
      commitment: '0xghi789...',  // To recipient
      encryptedData: '0x...'
    },
    {
      commitment: '0xjkl012...',  // Change back to self
      encryptedData: '0x...'
    }
  ],
  proof: '0x...',  // ZK proof of valid transfer
  fee: parseUnits('0.001', 18)
};

Record Creation

Create new records (minting from bridge or rewards).

Structure:

interface RecordCreation {
  type: 'record_creation';
  outputs: RecordOutput[];
  authorization: string;  // Bridge or system authorization
  proof: string;
}

Join Transaction

Combine multiple records into one.

Structure:

interface JoinTransaction {
  type: 'join';
  inputs: RecordInput[];  // Multiple inputs
  output: RecordOutput;   // Single output
  proof: string;
}

Split Transaction

Split one record into multiple.

Structure:

interface SplitTransaction {
  type: 'split';
  input: RecordInput;      // Single input
  outputs: RecordOutput[]; // Multiple outputs
  proof: string;
}

Transaction Encoding

RLP Encoding (Delta)

import { RLP } from '@acdc/sdk';

const tx = {
  type: 2,
  chainId: 1,
  nonce: 42,
  // ... other fields
};

// Encode for signing
const encoded = RLP.encode([
  tx.chainId,
  tx.nonce,
  tx.maxPriorityFeePerGas,
  tx.maxFeePerGas,
  tx.gasLimit,
  tx.to,
  tx.value,
  tx.data,
  tx.accessList
]);

// Hash for signing
const hash = keccak256(concat([0x02], encoded));

Borsh Encoding (Alpha)

import { borsh } from '@acdc/sdk';

const tx = {
  type: 'private_transfer',
  inputs: [...],
  outputs: [...],
  proof: '0x...',
  fee: 1000000n
};

const encoded = borsh.serialize(PrivateTransferSchema, tx);

Transaction Signing

Delta Chain

import { Wallet, signTransaction } from '@acdc/sdk';

const wallet = Wallet.fromPrivateKey('0x...');

const tx = {
  type: 2,
  chainId: 1,
  nonce: 42,
  maxFeePerGas: parseUnits('100', 9),
  maxPriorityFeePerGas: parseUnits('2', 9),
  gasLimit: 21000n,
  to: 'dx1recipient...',
  value: parseUnits('1.0', 18),
  data: '0x'
};

const signedTx = await wallet.signTransaction(tx);
console.log('Signed TX:', signedTx);

Alpha Chain

import { AlphaWallet, createPrivateTransfer } from '@acdc/sdk';

const wallet = AlphaWallet.fromPrivateKey('0x...');

const privateTx = await wallet.createPrivateTransfer({
  to: 'ax1recipient...',
  amount: parseUnits('10', 18),
  records: inputRecords  // Your unspent records
});

// Proof is generated automatically
console.log('Private TX:', privateTx);

Gas Costs

Delta Chain Gas Schedule

Operation	Gas Cost
Base transfer	21,000
Contract creation	32,000 + code cost
Storage write (new)	20,000
Storage write (existing)	5,000
Storage read	200
Call (cold)	2,600
Call (warm)	100
Log topic	375
Log data (per byte)	8

Alpha Chain Fee Schedule

Operation	Base Fee
Private transfer	0.001 ACDC
Per input record	0.0001 ACDC
Per output record	0.0001 ACDC
Proof verification	0.0005 ACDC

Transaction Status

Status	Description
pending	In mempool, not yet included
included	In a block, awaiting confirmations
confirmed	Sufficient confirmations
failed	Execution reverted
dropped	Removed from mempool

Query Transaction

// Get transaction details
const tx = await client.getTransaction('0xhash...');

// Get receipt (after confirmation)
const receipt = await client.getTransactionReceipt('0xhash...');

console.log('Status:', receipt.status);  // 1 = success, 0 = failed
console.log('Gas Used:', receipt.gasUsed);
console.log('Block:', receipt.blockNumber);

Error Handling

Error	Description
NONCE_TOO_LOW	Nonce already used
NONCE_TOO_HIGH	Gap in nonce sequence
INSUFFICIENT_FUNDS	Not enough balance
GAS_TOO_LOW	Gas limit too low
GAS_PRICE_TOO_LOW	Below minimum gas price
EXECUTION_REVERTED	Contract execution failed
INVALID_SIGNATURE	Signature verification failed
INVALID_PROOF	ZK proof verification failed