# Example Transaction interface usage

import { createHiveChain, ReplyOperation } from '@hiveio/wax';

// Initialize chain
const chain = await createHiveChain();

// Retrieve the signers
const { signer1, signer2 } = globalThis.snippetsBeekeeperData;

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

// Use the ReplyOperation to create a reply operation
tx.pushOperation(new ReplyOperation({
  parentAuthor: 'parent-author',
  parentPermlink: 'parent-permlink',
  author: 'author',
  body: 'body',
  beneficiaries: [{ account: 'test', weight: 40 }],
  tags: ['tag'],
  description: 'description',
}));

// Convert the transaction into the Hive API-form JSON
const apiTx = tx.toApi();

// log apiTransaction
console.log(apiTx);

// Apply the transaction in the API form into transaction interface
const txFromApi = chain.createTransactionFromJson(apiTx);

await signer1.signTransaction(txFromApi);

// Log txSigned
console.log(txFromApi.toApi());

await signer2.signTransaction(txFromApi);

// log multi signed transaction
console.log(txFromApi.toApi());

/*
 * Call actual broadcast API to send transaction to the blockchain.
 * The code is commented out because examples does not have access to Hive mainnet keys.
 */
// await chain.broadcast(txFromApi);

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

// Initialize chain
const chain = await createHiveChain();

// Create/get a wallet
const { wallet, publicKey1 } = globalThis.snippetsBeekeeperData;

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

// Declare example operation
const operation = {
  vote_operation: {
    voter: "voter",
    author: "author",
    permlink: "test-permlink",
    weight: 2200
  }
};

// Push the operation into the transaction
tx.pushOperation(operation);

// Convert the transaction into the Hive API-legacy form JSON before signing
const legacyApiTx = tx.toLegacyApi();

console.log(legacyApiTx);

// Because we want to process transction signing externally,
// we need to calculate its digest first.
const digest = tx.legacy_sigDigest;

/*
Here you can make any external signing process specific to HIVE
transaction, by using another signing tool than beekeeper
*/

// Generate the signature based on the transction digest
const signature = wallet.signDigest(publicKey1, digest);

// Suplement the transaction by created signature
tx.addSignature(signature);

// This is JSON form ready for broadcasting or passing to third-party service.
const txApiForm = tx.toLegacyApi();

console.log(txApiForm);

import beekeeperFactory from '@hiveio/beekeeper';
import {
  createHiveChain,
  createWaxFoundation,
  ReplyOperation,
  BlogPostOperation,
  ECommentFormat,
  DefineRecurrentTransferOperation,
  UpdateProposalOperation,
  WitnessSetPropertiesOperation,
  FollowOperation,
  ResourceCreditsOperation,
  CommunityOperation,
  AccountAuthorityUpdateOperation
} from '@hiveio/wax';

// Initialize wax api
const waxApi = await createWaxFoundation();

// Initialize chain
const chain = await createHiveChain();

// Initialize beekeeper
const beekeeper = await beekeeperFactory();

// Create session
const session = beekeeper.createSession('salt');

// Create wallet
const { wallet } = await session.createWallet('w1');

// Declare example account name
const accountName = "your-account";
// Declare example password for generating private key
const masterPassword = "your-master-password";

// Generating a new posting private key from a password
const privatePostingKeyData = waxApi.getPrivateKeyFromPassword(
  accountName,
  'posting',
  masterPassword
);
// Import the posting key into the wallet
const publicPostingSigningKey = await wallet.importKey(
  privatePostingKeyData.wifPrivateKey
);

// Generating a new active private key from a password
const privateActiveKeyData = waxApi.getPrivateKeyFromPassword(
  accountName,
  'active',
  masterPassword
);
// Import the active key into the wallet
const publicActiveSigningKey = await wallet.importKey(
  privateActiveKeyData.wifPrivateKey
);

// Generating a new encryption private key from a password
const privateEncryptionKeyData = waxApi.getPrivateKeyFromPassword(
  accountName,
  'memo',
  masterPassword
);
// Import the encryption key into the wallet
const publicEncryptionSigningKey = await wallet.importKey(
  privateEncryptionKeyData.wifPrivateKey
);

'--------------------------------------------------------------'
////////////////////////////////////////////////////////////////
//                  Simple operation scenario                 //
////////////////////////////////////////////////////////////////

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

const voteOp = {
  vote_operation: {
    voter: "voter",
    author: "author",
    permlink: "test-permlink",
    weight: 2200
  }
};

// Push simple vote operation into previously initialized transaction
simpleOperationTx.pushOperation(voteOp);

// Sign and build the transaction
simpleOperationTx.sign(wallet, publicPostingSigningKey);

// Log the simple transaction into console in API form
console.log(simpleOperationTx.toApi());

/*
 * Call actual broadcast API to send transaction to the blockchain.
 * The code is commented out because examples does not have access to
 * Hive mainnet keys.
 */
// await chain.broadcast(simpleOperationTx);

'--------------------------------------------------------------'
////////////////////////////////////////////////////////////////
//             Simple operation legacy scenario               //
////////////////////////////////////////////////////////////////

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

// Declare example transfer operation
const transferOp = {
  transfer_operation: {
    from: accountName,
    to: "friend",
    amount: chain.hiveCoins(100),
    memo: "My transfer operation"
  }
};

// Push simple vote operation into previously initialized transaction
legacyTx.pushOperation(transferOp)

// Because we want to process transction signing externally,
// we need to calculate its digest first.
const digest = legacyTx.legacy_sigDigest;

/*
Here you can make any external signing process specific to HIVE transaction,
by using another signing tool than beekeeper
*/

// Generate the signature based on the transction digest
const signature = wallet.signDigest(publicPostingSigningKey, digest);

// Suplement the transaction by created signature
legacyTx.addSignature(signature);

// This is JSON form ready for broadcasting or passing to third-party service.
const txApiForm = legacyTx.toLegacyApi();

// Log the simple legacy transaction into console in API form
console.log(txApiForm);

/*
 * Call actual broadcast API to send transaction to the blockchain.
 * The code is commented out because examples does not have access to Hive mainnet keys.
 */
// await chain.broadcast(otherOperationsTx);

'--------------------------------------------------------------'
////////////////////////////////////////////////////////////////
//                    Encryption example                      //
////////////////////////////////////////////////////////////////

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

// Declare other example transfer operation
const transferEncryptionOp = {
  transfer_operation: {
    from: accountName,
    to: "friend",
    amount: chain.hiveCoins(100),
    memo: "This will be encrypted"
  }
};

encryptionTx
  // Start encryption process
  .startEncrypt(publicEncryptionSigningKey)
  // Push transfer operation into previously initialized transaction
  .pushOperation(transferEncryptionOp)
  // Stop encryption process
  .stopEncrypt()
  // Push another transfer operation into previously initialized transaction
  .pushOperation(transferOp);

// Sign and build the transaction
encryptionTx.sign(wallet, publicPostingSigningKey);

// Log the encryption transaction into console in API form
console.log(encryptionTx.toApi());

/*
 * Call actual broadcast API to send transaction to the blockchain.
 * The code is commented out because examples does not have access
 * to Hive mainnet keys.
 */
// await chain.broadcast(otherOperationsTx);

'--------------------------------------------------------------'
////////////////////////////////////////////////////////////////
//                Comment operation scenario                  //
////////////////////////////////////////////////////////////////

// This example will create multiple operations including
// comment_operation and comment_options_operation

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

/*
 * Use BlogPostOperation to create an article operation and set all fields.
*/
commentOperationTx.pushOperation(new BlogPostOperation({
  author: accountName,
  permlink: 'my-article-permlink',
  title: 'My article title',
  body: 'My article body',
  category: 'my-category',
  tags: ['my-article'],
  description: 'This is my article!',
  images: ['article.jpg'],
  links: ['https://example.com'],
  format: ECommentFormat.MARKDOWN,
  beneficiaries: [{ account: 'friend', weight: 40 }],
  maxAcceptedPayout: chain.hbdCoins(100),
  allowCurationRewards: true,
  allowVotes: true
}));

/*
 * Use ReplyOperation to create a reply operation and set all fields.
 * Note that the category is not set because it is only available in
 * the BlogPostOperation.
*/
commentOperationTx.pushOperation(new ReplyOperation({
  author: accountName,
  permlink: 'My-reply-permlink',
  parentAuthor: accountName,
  parentPermlink: 'my-article-permlink',
  body: 'My reply body',
  tags: ['my-reply'],
  description: 'This is my reply!',
  images: ['reply.jpg'],
  links: ['https://example.com'],
  format: ECommentFormat.MARKDOWN,
  beneficiaries: [{ account: 'friend', weight: 40 }],
  maxAcceptedPayout: chain.hbdCoins(100),
  allowCurationRewards: true,
  allowVotes: true
}));

/*
Note that all the logic is hidden under the specific operation
constructor that you are currently using
*/

// Sign and build the transaction
commentOperationTx.sign(wallet, publicPostingSigningKey);

// Log the article transaction into console in API form
console.log(commentOperationTx.toApi());

/*
 * Call actual broadcast API to send transaction to the blockchain.
 * The code is commented out because examples does not have access
 * to Hive mainnet keys.
 */
// await chain.broadcast(otherOperationsTx);

'--------------------------------------------------------------'
////////////////////////////////////////////////////////////////
//            Account authority update scenario               //
////////////////////////////////////////////////////////////////

// This example will create account_update2_operation

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

/*
 * Use AccountAuthorityUpdateOperation to create
 * new account_update2_operation with all the fields initialized
 */
const accountAuthorityUpdateOp = await AccountAuthorityUpdateOperation.createFor(
  chain,
  "gtg"
);

// role method squashes all authority categories and allows you to select
// specific ones to modify in a user-friendly interface
const hasGandalfAuth = accountAuthorityUpdateOp.role("active").has("gandalf");

console.log("Has Gandalf Auth:", hasGandalfAuth);

// Add frodo authority with weight 2
accountAuthorityUpdateOp.role("active").add("frodo", 2);

// Update the memo key
accountAuthorityUpdateOp.role("memo").set(
  "STM8GC13uCZbP44HzMLV6zPZGwVQ8Nt4Kji8PapsPiNq1BK153XTX"
);

// You can also iterate over different authority levels from given category
// To perform batch operations
console.log("Current account authority:")
for(const role of accountAuthorityUpdateOp.roles("hive"))
  console.log(role.level, ":", role.value);

accountUpdateTx.pushOperation(accountAuthorityUpdateOp);

// Sign and build the transaction
accountUpdateTx.sign(wallet, publicActiveSigningKey);

// Log the article transaction into console in API form
console.log(accountUpdateTx.toApi());

/*
 * Call actual broadcast API to send transaction to the blockchain.
 * The code is commented out because examples does not have access
 * to Hive mainnet keys.
 */
// await chain.broadcast(otherOperationsTx);

'--------------------------------------------------------------'
////////////////////////////////////////////////////////////////
//            Other operation factories scenario              //
////////////////////////////////////////////////////////////////

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

// Create a recurrent transfer operation that will be executed every day
// for 30 days with the ammount of 100.000 HIVE
operationFactoriesTx.pushOperation(new DefineRecurrentTransferOperation({
  from: accountName,
  to: 'friend',
  amount: chain.hiveCoins(100),
  memo: 'Daily pay',
  recurrence: 24,
  executions: 30
}));

// Create a proposal update operation of id equals 1 with the
// ammount of 100.000 HBD
operationFactoriesTx.pushOperation(new UpdateProposalOperation({
  proposalId: 1,
  creator: accountName,
  dailyPay: chain.hbdCoins(100),
  subject: 'Proposal Update',
  permlink: 'proposal-update',
  endDate:  '2023-03-14',
}));

// Create a witness set properties operation with hbd interest rate of 7.5%,
// maximum block size of 65536, account creation fee of 300.000 HIVE
// and url of "https://example.com"
operationFactoriesTx.pushOperation(new WitnessSetPropertiesOperation({
  owner: accountName,
  witnessSigningKey: publicActiveSigningKey,
  maximumBlockSize: 65536,
  hbdInterestRate: 750,
  accountCreationFee: chain.hiveCoins(300),
  url: "https://example.com"
}));

// Sign and build the transaction
operationFactoriesTx.sign(wallet, publicActiveSigningKey);

// Log the operation factories transaction into console in API form
console.log(operationFactoriesTx.toApi());

/*
 * Call actual broadcast API to send transaction to the blockchain.
 * The code is commented out because examples does not have access
 * to Hive mainnet keys.
 */
// await chain.broadcast(otherOperationsTx);

'--------------------------------------------------------------'
////////////////////////////////////////////////////////////////
//      Scenario taht includes all HiveAppsOperations         //
////////////////////////////////////////////////////////////////

// (custom_json based)

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

// Create follow operation new instance
const followOperation = new FollowOperation();

// Push operations of follow operation into the created transaction
otherOperationsTx.pushOperation(
  followOperation
    .followBlog(accountName, 'blog-to-follow')
    .muteBlog(accountName, 'blog-to-mute')
    .reblog(accountName, 'to-reblog', 'post-permlink')
    // The account that authorizes underlying custom json operation is
    // also reponsible for signing the transaction using its posting authority
    .authorize(accountName)
);

// Create resource credits operation new instance
const rcOperation = new ResourceCreditsOperation();

// Push operations of resource credits operation into the created transaction
otherOperationsTx.pushOperation(
  rcOperation
  // Delegate 1000 RC from your account to a friend's account.
  .delegate(accountName, 1000, 'friend')
  // The account that authorizes underlying custom json operation is also
  // reponsible for signing the transaction using its posting authority
  .authorize(accountName)
);

// Create community operation new instance
const communityOperation = new CommunityOperation();

// Declare example community name
const communityName = 'community-name';

// Push operations of community operation into the created transaction
otherOperationsTx.pushOperation(
  communityOperation
    // Subscribe the community
    .subscribe('communityName')
    // Flag the post of the author in the community with the permlink
    // Add notes regarding the violation (violation notes).
    .flagPost(communityName, 'author-account', 'post-permlink', 'violation notes')
    // The account that authorizes underlying custom json operation is also
    // reponsible for signing the transaction using its posting authority
    .authorize(accountName)
);

// Sign and build the transaction
otherOperationsTx.sign(wallet, publicPostingSigningKey);

// Log the other operations transaction into console in API form
console.log(otherOperationsTx.toApi());

/*
 * Call actual broadcast API to send transaction to the blockchain.
 * The code is commented out because examples does not have access
 * to Hive mainnet keys.
 */
// await chain.broadcast(otherOperationsTx);