sdk.pallets.<palletName>.queries  // Read-only storage queries
sdk.pallets.<palletName>.manager  // Transaction/extrinsic methods

// Queries
const balance = await sdk.pallets.balances.queries.account(address);
const total = await sdk.pallets.balances.queries.totalIssuance();
const locks = await sdk.pallets.balances.queries.locks(address);

// Transactions
const tx = sdk.pallets.balances.manager.transfer({ dest, value });
const txKeepAlive = sdk.pallets.balances.manager.transferKeepAlive({
  dest,
  value,
});
const txAll = sdk.pallets.balances.manager.transferAll({
  dest,
  keepAlive: true,
});

// Queries
const validators = await sdk.pallets.staking.queries.validators();
const era = await sdk.pallets.staking.queries.activeEra();
const ledger = await sdk.pallets.staking.queries.ledger(address);

// Transactions
const bondTx = sdk.pallets.staking.manager.bond({ value, payee });
const nominateTx = sdk.pallets.staking.manager.nominate({ targets });
const unbondTx = sdk.pallets.staking.manager.unbond({ value });

// Queries
const validators = await sdk.pallets.session.queries.validators();
const currentIndex = await sdk.pallets.session.queries.currentIndex();
const keys = await sdk.pallets.session.queries.nextKeys(address);

// Transactions
const setKeysTx = sdk.pallets.session.manager.setKeys({ keys, proof });
const purgeKeysTx = sdk.pallets.session.manager.purgeKeys();

// Batch multiple calls
const batchTx = sdk.pallets.utility.manager.batch({ calls: [call1, call2] });
const batchAllTx = sdk.pallets.utility.manager.batchAll({
  calls: [call1, call2],
});
const forceBatchTx = sdk.pallets.utility.manager.forceBatch({
  calls: [call1, call2],
});

// Queries
const referendums = await sdk.pallets.democracy.queries.referendumInfoOf(index);
const proposals = await sdk.pallets.democracy.queries.publicProps();
const votingOf = await sdk.pallets.democracy.queries.votingOf(address);

// Transactions
const proposeTx = sdk.pallets.democracy.manager.propose({
  proposalHash,
  value,
});
const voteTx = sdk.pallets.democracy.manager.vote({ refIndex, vote });
const delegateTx = sdk.pallets.democracy.manager.delegate({
  to,
  conviction,
  balance,
});

// Queries
const members = await sdk.pallets.council.queries.members();
const proposals = await sdk.pallets.council.queries.proposals();
const voting = await sdk.pallets.council.queries.voting(proposalHash);

// Transactions
const voteTx = sdk.pallets.council.manager.vote({ proposal, index, approve });
const proposeTx = sdk.pallets.council.manager.propose({
  threshold,
  proposal,
  lengthBound,
});

// Queries
const proposals = await sdk.pallets.treasury.queries.proposals(index);
const approvals = await sdk.pallets.treasury.queries.approvals();
const proposalCount = await sdk.pallets.treasury.queries.proposalCount();

// Transactions
const proposalTx = sdk.pallets.treasury.manager.proposeSpend({
  value,
  beneficiary,
});
const approveTx = sdk.pallets.treasury.manager.approveProposal({ proposalId });
const rejectTx = sdk.pallets.treasury.manager.rejectProposal({ proposalId });

// Queries
const members = await sdk.pallets.elections.queries.members();
const candidates = await sdk.pallets.elections.queries.candidates();
const voting = await sdk.pallets.elections.queries.voting(address);

// Transactions
const voteTx = sdk.pallets.elections.manager.vote({ votes, value });
const submitCandidacyTx = sdk.pallets.elections.manager.submitCandidacy({
  candidateCount,
});
const removeVoterTx = sdk.pallets.elections.manager.removeVoter();

// Queries
const members = await sdk.pallets.technicalCommittee.queries.members();
const proposals = await sdk.pallets.technicalCommittee.queries.proposals();

// Transactions
const voteTx = sdk.pallets.technicalCommittee.manager.vote({
  proposal,
  index,
  approve,
});

// Queries
const account = await sdk.pallets.evm.queries.accountBasic(evmAddress);
const code = await sdk.pallets.evm.queries.accountCodes(evmAddress);
const storage = await sdk.pallets.evm.queries.accountStorages(evmAddress, slot);

// Transactions - Deploy contract
const createTx = sdk.pallets.evm.manager.create({
  source: evmAddress,
  init: bytecode,
  value: 0n,
  gasLimit: 1000000n,
  maxFeePerGas: 1000000000n,
});

// Transactions - Call contract
const callTx = sdk.pallets.evm.manager.call({
  source: evmAddress,
  target: contractAddress,
  input: encodedData,
  value: 0n,
  gasLimit: 100000n,
  maxFeePerGas: 1000000000n,
});

// Transactions - Deploy with CREATE2
const create2Tx = sdk.pallets.evm.manager.create2({
  source: evmAddress,
  init: bytecode,
  salt: saltBytes,
  value: 0n,
  gasLimit: 1000000n,
  maxFeePerGas: 1000000000n,
});

// Queries
const blockHash = await sdk.pallets.ethereum.queries.blockHash(blockNumber);
const currentBlock = await sdk.pallets.ethereum.queries.currentBlock();
const pending = await sdk.pallets.ethereum.queries.pending();

// Transactions
const tx = sdk.pallets.ethereum.manager.transact({ transaction });

// Queries
const baseFee = await sdk.pallets.dynamicEvmBaseFee.queries.baseFeePerGas();
const targetGas =
  await sdk.pallets.dynamicEvmBaseFee.queries.targetGasPerSecond();

// Transactions (sudo)
const setBaseFee = sdk.pallets.dynamicEvmBaseFee.manager.setBaseFeePerGas({
  fee,
});

// Queries
const contractInfo = await sdk.pallets.contracts.queries.contractInfoOf(
  address
);
const code = await sdk.pallets.contracts.queries.codeInfoOf(codeHash);
const pristineCode = await sdk.pallets.contracts.queries.pristineCode(codeHash);

// Transactions
const instantiateTx = sdk.pallets.contracts.manager.instantiate({
  value,
  gasLimit,
  storageDepositLimit,
  code,
  data,
  salt,
});
const callTx = sdk.pallets.contracts.manager.call({
  dest,
  value,
  gasLimit,
  storageDepositLimit,
  data,
});
const uploadCodeTx = sdk.pallets.contracts.manager.uploadCode({
  code,
  storageDepositLimit,
  determinism,
});

// Call EVM contract from WASM context
const xvmCallTx = sdk.pallets.xvm.manager.call({
  vmId,
  to,
  input,
  value,
});

// Queries
const identity = await sdk.pallets.identity.queries.identityOf(address);
const superOf = await sdk.pallets.identity.queries.superOf(address);
const subsOf = await sdk.pallets.identity.queries.subsOf(address);

// Transactions
const setIdentityTx = sdk.pallets.identity.manager.setIdentity({ info });
const clearIdentityTx = sdk.pallets.identity.manager.clearIdentity();
const requestJudgementTx = sdk.pallets.identity.manager.requestJudgement({
  regIndex,
  maxFee,
});

// Queries
const proxies = await sdk.pallets.proxy.queries.proxies(address);
const announcements = await sdk.pallets.proxy.queries.announcements(address);

// Transactions
const addProxyTx = sdk.pallets.proxy.manager.addProxy({
  delegate,
  proxyType,
  delay,
});
const removeProxyTx = sdk.pallets.proxy.manager.removeProxy({
  delegate,
  proxyType,
  delay,
});
const proxyTx = sdk.pallets.proxy.manager.proxy({ real, forceProxyType, call });

// Queries
const multisigs = await sdk.pallets.multisig.queries.multisigs(
  address,
  callHash
);

// Transactions
const asMultiTx = sdk.pallets.multisig.manager.asMulti({
  threshold,
  otherSignatories,
  maybeTimepoint,
  call,
  maxWeight,
});
const approveAsMultiTx = sdk.pallets.multisig.manager.approveAsMulti({
  threshold,
  otherSignatories,
  maybeTimepoint,
  callHash,
  maxWeight,
});
const cancelAsMultiTx = sdk.pallets.multisig.manager.cancelAsMulti({
  threshold,
  otherSignatories,
  timepoint,
  callHash,
});

// Queries
const vesting = await sdk.pallets.vesting.queries.vesting(address);

// Transactions
const vestTx = sdk.pallets.vesting.manager.vest();
const vestOtherTx = sdk.pallets.vesting.manager.vestOther({ target });
const vestedTransferTx = sdk.pallets.vesting.manager.vestedTransfer({
  target,
  schedule,
});

// Queries
const authorities = await sdk.pallets.aleph.queries.authorities();
const sessionPeriod = await sdk.pallets.aleph.queries.sessionPeriod();
const emergencyFinalizer = await sdk.pallets.aleph.queries.emergencyFinalizer();

// Transactions (sudo)
const setEmergencyFinalizerTx = sdk.pallets.aleph.manager.setEmergencyFinalizer(
  {
    emergencyFinalizer,
  }
);

// Queries
const sessionValidators =
  await sdk.pallets.committeeManagement.queries.sessionValidatorBlockCount(
    address
  );
const underperformedCount =
  await sdk.pallets.committeeManagement.queries.underperformedValidatorSessionCount(
    address
  );
const banConfig = await sdk.pallets.committeeManagement.queries.banConfig();

// Transactions (sudo)
const banFromCommitteeTx =
  sdk.pallets.committeeManagement.manager.banFromCommittee({
    banned,
    banReason,
  });

// Queries
const pool = await sdk.pallets.nominationPools.queries.bondedPools(poolId);
const members = await sdk.pallets.nominationPools.queries.poolMembers(address);
const metadata = await sdk.pallets.nominationPools.queries.metadata(poolId);

// Transactions
const joinTx = sdk.pallets.nominationPools.manager.join({ amount, poolId });
const createTx = sdk.pallets.nominationPools.manager.create({
  amount,
  root,
  nominator,
  bouncer,
});
const claimTx = sdk.pallets.nominationPools.manager.claimPayout();
const unbondTx = sdk.pallets.nominationPools.manager.unbond({
  memberAccount,
  unbondingPoints,
});

// Transactions
const perbillPayoutTx = sdk.pallets.operations.manager.perbillPayout({
  accounts,
  ratio,
});
const fixedPayout = sdk.pallets.operations.manager.fixedPayout({
  accounts,
  amount,
});

// Queries
const key = await sdk.pallets.sudo.queries.key();

// Transactions
const sudoTx = sdk.pallets.sudo.manager.sudo({ call });
const sudoUncheckedWeightTx = sdk.pallets.sudo.manager.sudoUncheckedWeight({
  call,
  weight,
});
const setKeyTx = sdk.pallets.sudo.manager.setKey({ newKey });
const sudoAsTx = sdk.pallets.sudo.manager.sudoAs({ who, call });

// Queries
const agenda = await sdk.pallets.scheduler.queries.agenda(blockNumber);
const lookup = await sdk.pallets.scheduler.queries.lookup(taskId);

// Transactions
const scheduleTx = sdk.pallets.scheduler.manager.schedule({
  when,
  maybePeriodic,
  priority,
  call,
});
const cancelTx = sdk.pallets.scheduler.manager.cancel({ when, index });

// Queries
const status = await sdk.pallets.preimage.queries.statusFor(hash);
const preimageFor = await sdk.pallets.preimage.queries.preimageFor(hash, len);

// Transactions
const notePreimageTx = sdk.pallets.preimage.manager.notePreimage({ bytes });
const unnotePreimageTx = sdk.pallets.preimage.manager.unnotePreimage({ hash });

// Queries
const enteredUntil = await sdk.pallets.safeMode.queries.enteredUntil();

// Transactions (governance)
const enterTx = sdk.pallets.safeMode.manager.enter();
const extendTx = sdk.pallets.safeMode.manager.extend();
const forceEnterTx = sdk.pallets.safeMode.manager.forceEnter();
const forceExitTx = sdk.pallets.safeMode.manager.forceExit();

// Queries
const pausedCalls = await sdk.pallets.txPause.queries.pausedCalls(pallet, call);

// Transactions (sudo/governance)
const pauseTx = sdk.pallets.txPause.manager.pause({ fullName });
const unpauseTx = sdk.pallets.txPause.manager.unpause({ ident });

// Get an extrinsic
const tx = sdk.pallets.balances.manager.transfer({ dest, value });

// Sign and send
const result = await tx.signAndSend(signer, { nonce: -1 });

// Or with callback for status updates
await tx.signAndSend(signer, {}, (result) => {
  if (result.status.isInBlock) {
    console.log(`In block: ${result.status.asInBlock}`);
  }
  if (result.status.isFinalized) {
    console.log(`Finalized: ${result.status.asFinalized}`);
  }
});

try {
  const tx = sdk.pallets.balances.manager.transfer({ dest, value });
  const result = await tx.signAndSend(signer);

  // Check for errors in events
  result.events.forEach(({ event }) => {
    if (sdk.api.events.system.ExtrinsicFailed.is(event)) {
      const [error] = event.data;
      if (error.isModule) {
        const decoded = sdk.api.registry.findMetaError(error.asModule);
        throw new Error(`${decoded.section}.${decoded.name}: ${decoded.docs}`);
      }
    }
  });
} catch (error) {
  console.error("Transaction failed:", error);
}

// Create multiple calls
const transfer1 = sdk.pallets.balances.manager.transfer({
  dest: addr1,
  value: val1,
});
const transfer2 = sdk.pallets.balances.manager.transfer({
  dest: addr2,
  value: val2,
});

// Batch them (all or nothing)
const batchTx = sdk.pallets.utility.manager.batchAll({
  calls: [transfer1, transfer2],
});
await batchTx.signAndSend(signer);