ITransaction interface

// Offline: Manual TAPOS
const tx = wax.createTransactionWithTaPoS(headBlockId, "+1m");

// Online: Automatic TAPOS
const tx = await chain.createTransaction("+5m");

// From existing JSON
const tx = wax.createTransactionFromJson(apiTxJson);

// From protobuf
const tx = wax.createTransactionFromProto(protoTx);

pushOperation(op: operation | OperationBase): this;

tx.pushOperation({
  vote: {
    voter: "alice",
    author: "bob",
    permlink: "example-post",
    weight: 10000
  }
});

import { BlogPostOperation } from '@hiveio/wax';

tx.pushOperation(new BlogPostOperation({
  author: "alice",
  category: "hive-174695",
  title: "My awesome post",
  body: "This is the post content",
  permlink: "my-awesome-post",
  tags: ["blog", "travel"],
  description: "A post about my travels"
}));

get id(): TTransactionId;

get legacy_id(): TTransactionId;

get sigDigest(): THexString;

get legacy_sigDigest(): THexString;

get transaction(): transaction;

get impactedAccounts(): Set<TAccountName>;

get signatureKeys(): Array<THexString>;

get requiredAuthorities(): TTransactionRequiredAuthorities;

get binaryViewMetadata(): IBinaryViewOutputData;

addSignature(signature: THexString): this;

import { createHiveChain } from '@hiveio/wax';
import { createBeekeeperSigner } from '@hiveio/wax-signers-beekeeper';

const chain = await createHiveChain();
const signer = await createBeekeeperSigner({
  /* beekeeper config */
});

// Create transaction
const tx = await chain.createTransaction();

tx.pushOperation({
  vote: {
    voter: "alice",
    author: "bob",
    permlink: "example-post",
    weight: 10000
  }
});

// Sign with provider
const signature = await signer.signTransaction(tx.sigDigest);
tx.addSignature(signature);

// Broadcast
await chain.api.network_broadcast_api.broadcast_transaction({
  trx: tx.toApiJson()
});

isSigned(): boolean;

validate(): void;

try {
  tx.validate();
  console.log('Transaction is valid');
} catch (error) {
  console.error('Validation failed:', error.message);
}

toApi(): string;

toApiJson(): ApiTransaction;

toLegacyApi(): string;

toString(): string;

toBinaryForm(stripToUnsignedTransaction?: boolean): THexString;

startEncrypt(
  mainEncryptionKey: TPublicKey,
  otherEncryptionKey?: TPublicKey
): this & IEncryptingTransaction<this>;

const tx = await chain.createTransaction();

tx.startEncrypt(myPublicKey)
  .pushOperation({
    transfer: {
      from: "alice",
      to: "bob",
      amount: chain.hiveCoins(10),
      memo: "This will be encrypted"
    }
  })
  .stopEncrypt();

// Sign with encryption provider
const signature = await encryptionProvider.signTransaction(tx);
tx.addSignature(signature);

stopEncrypt(): this;

decrypt(wallet: ISignatureProvider): transaction;

interface transaction {
  ref_block_num: number;
  ref_block_prefix: number;
  expiration: string;
  operations: Array<operation>;
  extensions: Array<any>;
  signatures: Array<string>;
}

interface ApiTransaction {
  ref_block_num: number;
  ref_block_prefix: number;
  expiration: string;
  operations: Array<ApiOperation>;
  extensions: object[];
  signatures: string[];
}

interface ApiOperation {
  type: string;
  value: Record<string, any>;
}

type TTransactionRequiredAuthorities = {
  posting: Set<string>;
  active: Set<string>;
  owner: Set<string>;
  other: Array<authority>;
};

import { createHiveChain } from '@hiveio/wax';
import { BlogPostOperation } from '@hiveio/wax';
import { createBeekeeperSigner } from '@hiveio/wax-signers-beekeeper';

// Initialize
const chain = await createHiveChain();
const signer = await createBeekeeperSigner({ /* config */ });

// Create transaction
const tx = await chain.createTransaction("+5m");

// Add blog post
tx.pushOperation(new BlogPostOperation({
  author: "alice",
  category: "hive-174695",
  title: "My First Post",
  body: "Hello Hive!",
  permlink: "my-first-post",
  tags: ["introduction", "blog"],
  description: "My introduction to Hive"
}));

// Validate
tx.validate();

// Check required authorities
console.log('Required authorities:', tx.requiredAuthorities);

// Sign
const signature = await signer.signTransaction(tx.sigDigest);
tx.addSignature(signature);

// Verify signed
console.log('Is signed:', tx.isSigned());
console.log('Transaction ID:', tx.id);

// Broadcast
try {
  await chain.api.network_broadcast_api.broadcast_transaction({
    trx: tx.toApiJson()
  });
  console.log('Transaction broadcasted successfully!');
} catch (error) {
  console.error('Broadcast failed:', error);
}