waves_logo Docs
  • Overview
    Overview
  • How-to Guides
    • Reading Blockchain Data
      Reading Blockchain Data
    • Creating & Broadcasting Transactions
      Creating & Broadcasting Transactions
    • Tokenization
      Tokenization
    • Airdrop
      Airdrop
    • Payments
      Payments
    • Exchange Tokens
      Exchange Tokens
    • Simple Voting
      Simple Voting
    • List as argument
      List as argument
    How-to Guides
  • Waves Smart Contracts
    Waves Smart Contracts
  • dApp
    • Creating & Launching dApp
      Creating & Launching dApp
    dApp
  • Smart Account
    • Creating smart account
      Creating smart account
    • Creating and deploying a script manually
      Creating and deploying a script manually
    • Video tutorials
      • Introduction to the Waves blockchain, Waves Smart Accounts and Waves Smart Assets
        Introduction to the Waves blockchain, Waves Smart Accounts and Waves Smart Assets
      • Waves Smart Account with multisignature
        Waves Smart Account with multisignature
      • Waves Smart Account with escrow service
        Waves Smart Account with escrow service
      • Creating multisignature account via Waves IDE tools
        Creating multisignature account via Waves IDE tools
      • Creating multisignature account via Waves Client
        Creating multisignature account via Waves Client
      • Waves console explained
        Waves console explained
      Video tutorials
    Smart Account
  • Smart Asset
    Smart Asset
  • Developer Tools
    • Waves IDE
      Waves IDE
    • Visual Studio Code Extension
      Visual Studio Code Extension
    • Surfboard
      Surfboard
    • Ride REPL
      Ride REPL
    Developer Tools
  • Signer ◆
    Signer ◆
  • Waves API
    • Data Service API
      Data Service API
    • Node REST API
      Node REST API
    • Node gRPC Server
      Node gRPC Server
    • Blockchain Updates
      Blockchain Updates
    Waves API
  • Client Libraries
    • Waves C#
      • Install SDK
        Install SDK
      • Run Code Sample
        • Send Transactions
          Send Transactions
        • Use Crypto Utilities
          Use Crypto Utilities
        • Interact With Node
          Interact With Node
        • Set Up Smart Contracts
          Set Up Smart Contracts
        Run Code Sample
      Waves C#
    • Gowaves
      • Install SDK
        Install SDK
      • Run Code Sample
        • Send Transactions
          Send Transactions
        • Use Crypto Utilities
          Use Crypto Utilities
        • Interact With Node
          Interact With Node
        • Set Up Smart Contracts
          Set Up Smart Contracts
        Run Code Sample
      Gowaves
    • WavesJ
      • Install SDK
        Install SDK
      WavesJ
    • Ts-lib-crypto
      • Install SDK
        Install SDK
      Ts-lib-crypto
    • Waves-PHP
      • Install SDK
        Install SDK
      Waves-PHP
    • PyWaves-CE
      • Install SDK
        Install SDK
      PyWaves-CE
    • Waves-rust
      • Install SDK
        Install SDK
      Waves-rust
    Client Libraries
      • English
      • Русский
      On this page
        • Prerequisites
        • Tutorial
      waves_logo Docs

          # Send Transactions

          Send transactions after meeting the prerequisites.

          # Prerequisites

          • Wallet: Set up a wallet via Keeper Wallet or WX Network .

            NOTE: Ensure saving your wallet's seed phrase to send transactions.

          • Tokens: Obtain WAVES tokens to cover each transaction's fee:
            • For the Mainnet network: Get 0.001 WAVES via Available Market Options .
            • For the Testnet network: Get 0.001 WAVES via Faucet .
            • For the Stagenet network: Get 0.001 WAVES via Faucet .

          # Tutorial

          Follow the instructions for the transaction type you want to send:

          • Issue.
          • Reissue.
          • Burn.
          • Transfer.
          • Mass Transfer.
          • Exchange.
          • Lease.
          • Lease Cancel.
          • Create Alias.
          • Data.
          • Set Script.
          • Set Asset Script.
          • Update Asset Info.
          • Invoke Script.
          • Sponsor Fee.

          # Issue

          About Issue Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Create the private key from your wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Create the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            /* 
            Define your asset script:
            - Set to `null` if the asset should not have a smart asset functionality.  
            - Provide your Ride script to enable smart asset functionality.  
            */
            var txScript = "PASTE YOUR ASSET SCRIPT HERE";
            
            // Build an Issue Transaction.
            var issueTx = IssueTransactionBuilder.Params(
            "Sampleasset1",             // Name.
            1000,                       // Quantity (in smallest unit, e.g., `1000` for 10 tokens).
            2,                          // Decimals.
            "description of the asset", // Description.
            false,                      // Flag indicating whether the asset is reissuable.
            txScript                    // Asset Base64 compiled script or `null`.
            ).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(issueTx).Id);
            
            // Get the transaction information from the node.
            var txInfo = node.GetTransactionInfo<IssueTransactionInfo>(issueTx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Reissue

          About Reissue Transaction.

          NOTE: You can reissue only those asset that were issued by you with the reissuable flag set to true.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Create the private key from your wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Create the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Define the ID of the asset created by you.
            var assetId = AssetId.As("PASTE YOUR ASSET ID");
            
            // Build a Reissue transaction.
            var reissueTx = ReissueTransactionBuilder.Params(
                assetId, 
                143,  // New quantity.
                false // New flag indicating whether the asset is reissuable.
                ).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(reissueTx).Id);
            
            // Get the transaction information from the node.
            var txInfo = node.GetTransactionInfo<ReissueTransactionInfo>(reissueTx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Burn

          About Burn Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Create the private key from your wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Create the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Define the ID of the asset created by you.
            var assetId = AssetId.As("PASTE YOUR ASSET ID");
            
            // Define the amount of the asset in the smallest unit. E.g., `1000` for 10 tokens.
            var amount = 1000;
            
            // Build a Burn Transaction.
            var burnTx = BurnTransactionBuilder.Params(assetId, amount).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(burnTx).Id);
            
            // Get the information about the transaction from the node.
            var txInfo = node.GetTransactionInfo<BurnTransactionInfo>(burnTx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Transfer

          About Transfer Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Create the private key from your wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Create the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Define the recipient’s address.
            Address recipient = new Address("PASTE THE RECIPIENT ADDRESS");
            
            // Define the transfer amount in the smallest unit. E.g., `1000` for 10 tokens.
            var amount = 1000;
            
            /* 
            Define the asset ID:
            - For WAVES, use `AssetId.Waves`.
            - For custom assets, enter the asset ID.
            */
            var assetId = AssetId.As("PASTE YOUR ASSET ID");
            
            /*
            Define your attachment message:
            - Use `null` if no message is required.
            - Enter the message as a string if required.
            */
            var attachment = "PASTE YOUR ATTACHMENT MESSAGE";
            
            // Build a Transfer transaction.
            var tx = TransferTransactionBuilder.Params(recipient, amount, assetId, attachment)
                .GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(tx).Id);
            
            // Get the information about the transaction from the node.
            var txInfo = node.GetTransactionInfo<TransferTransactionInfo>(tx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Mass Transfer

          About Mass Transfer Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Create the private key from your wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Create the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            /* 
            Define the asset ID:
            - For WAVES, use `AssetId.Waves`.
            - For custom assets, enter the asset ID.
            */
            var assetId = AssetId.As("PASTE YOUR ASSET ID");
            
            // Define the 1st recipient address.
            var recipientAddress = new Address("PASTE FIRST RECIPIENT'S ADDRESS");
            
            // Define the 1st transfer amount in the smallest unit. E.g., `1000` for 10 tokens.
            var amount = 1000;
            
            // Define the 2nd recipient address.
            var recipientAddressTwo = new Address("PASTE SECOND RECIPIENT'S ADDRESS");
            
            // Define the 2nd transfer amount in the smallest unit. E.g., `1000` for 10 tokens.
            var amountTwo = 1000;
            
            // Define the 3rd recipient address.
            var recipientAddressThree = new Address("PASTE THIRD RECIPIENT'S ADDRESS");
            
            // Define the 3rd transfer amount in the smallest unit. E.g., `1000` for 10 tokens.
            var amountThree = 1000;
            
            // Create a list of recipients and their respective transfer sums.
            var transfers = new List<Transfer> {
                Transfer.To(recipientAddress, amount),
                Transfer.To(recipientAddressTwo, amountTwo),
                Transfer.To(recipientAddressThree, amountThree)
            };
            
            // Build a Mass Transfer Transaction.
            var massTx = MassTransferTransactionBuilder.Params(transfers, assetId).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(massTx).Id);
            
            // Get the information about the transaction from the node.
            var txInfo = node.GetTransactionInfo<MassTransferTransactionInfo>(massTx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Exchange

          About Exchange Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Generate the private key using the wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Derive the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Define the recipient's public key.
            var recipientPublicKey = PublicKey.As("PASTE THE RECIPIENT'S PUBLIC KEY HERE");
            
            /* 
            Define the asset ID:
            - For WAVES, use `AssetId.Waves`.
            - For custom assets, enter the asset ID.
            */
            var assetId = AssetId.As("PASTE THE ASSET ID HERE");
            
            // Set the the transaction amount in the smallest unit. E.g., `1000` for 10 tokens.
            var amount = Amount.As(250);
            
            // Set the asset price.
            var price = Amount.As(100, assetId);
            
            // Define the matcher fee values.
            var buyMatcherFee = 300_000;  // Fee for the buy order.
            var sellMatcherFee = 350_000; // Fee for the sell order.
            
            var assetPair = new AssetPair { AmountAsset = assetId, PriceAsset = assetId };
            
            // Create the buy order (e.g., matcher is the sender).
            var buyOrder = new OrderBuilder(
                OrderType.Buy,   // Buy order type.
                amount,          // Amount to be bought.
                price,           // Asset price.
                senderPublicKey, // Sender's public key.
                assetPair        // Asset pair.
            ).GetSignedWith(recipientPrivateKey);
            
            // Create the sell order (e.g., sender is the seller).
            var sellOrder = new OrderBuilder(
                OrderType.Sell,  // Sell order type.
                amount,          // Amount to be sold.
                price,           // Asset price.
                senderPublicKey, // Sender's public key.
                assetPair        // Asset pair.
            ).GetSignedWith(senderPrivateKey);
            
            // Build the Exchange Transaction.
            var exchangeTx = ExchangeTransactionBuilder.Params(buyOrder, sellOrder, amount, price, buyMatcherFee, sellMatcherFee)
                .GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(exchangeTx).Id);
            
            // Retrieve the information about the transaction from the node.
            var txInfo = node.GetTransactionInfo<ExchangeTransactionInfo>(exchangeTx.Id);
            
            // Print the transaction ID to the console.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Lease

          About Lease Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Generate the private key using the wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Derive the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Define the recipient's public key.
            var recipientPublicKey = PublicKey.As("PASTE THE RECIPIENT'S PUBLIC KEY HERE");
            
            // Define the recipient’s address
            var recipientAddress = new Address("PASTE THE RECIPIENT'S ADDRESS HERE");
            
            // Build a Lease Transaction.
            var leaseTx = LeaseTransactionBuilder.Params(recipientAddress, amount).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(leaseTx).Id);
            
            // Get the information about the transaction from the node.
            var txInfo = node.GetTransactionInfo<LeaseTransactionInfo>(leaseTx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Lease Cancel

          About Lease Cancel Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Generate the private key using the wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Derive the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Define the Lease Transaction ID.
            var leaseTxId = new Base58s("PASTE THE LEASE TRANSACTION ID HERE");
            
            // Build a Lease Cancel Transaction.
            var leaseCancelTx = LeaseCancelTransactionBuilder.Params(leaseTxId).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(leaseCancelTx).Id);
            
            // Get the information about the transaction.
            var txInfo = node.GetTransactionInfo<LeaseCancelTransactionInfo>(leaseCancelTx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Create Alias

          About Create Alias Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Create the private key from your wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Create the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Create an alias using the current system time.
            var alias = Alias.As("alias" + DateTimeOffset.UtcNow.ToUnixTimeMilliseconds());
            
            // Build a Create Alias transaction
            var createAliasTx = CreateAliasTransactionBuilder
                .Params(alias) // Alias.
                .GetSignedWith(senderPrivateKey);
            
            // Send the transaction to the node.
            node.WaitForTransaction(node.Broadcast(createAliasTx).Id);
            
            // Get the transaction information from the node.
            var createAliasTxInfo = node.GetTransactionInfo<CreateAliasTransactionInfo>(createAliasTx.Id);
            
            // Print the created alias.
            Console.WriteLine(createAliasTxInfo.Transaction.Alias.ToFullString());
            
          2. Run the application:
            dotnet run
            

          # Data

          About Data Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Generate the private key using the wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Derive the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Build a Data transaction.
            var dataTx = DataTransactionBuilder.Params(
                // A list of `BinaryEntry`, `BooleanEntry`, `IntegerEntry`, `StringEntry`, or `null`.
                new List<EntryData> { 
                    // `data.type` string with `data.key` equal to `test key 1` and `data.value` equal to `test value`.
                    DataEntry.AsString("test key 1", "test value"),
                    // `data.type` boolean with `data.key` equal to `test key 2` and `data.value` equal to `true`.
                    DataEntry.AsBoolean("test key 2", true)
                }).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(dataTx).Id);
            
            // Get the information about the transaction from the node.
            var txInfo = node.GetTransactionInfo<DataTransactionInfo>(dataTx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Set Script

          About Set Script Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Generate the private key using the wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Derive the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Create a script.
            var txScript = "PASTE YOUR SCRIPT HERE".
            
            // Compile the script into the Base64 format.
            var compiledScript = node.CompileScript(txScript).Script;
            
            // Build a Set Script transaction.
            var tx = SetScriptTransactionBuilder.Params(compiledScript).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(tx).Id);
            
            // Get the information about the transaction.
            var txInfo = node.GetTransactionInfo<SetScriptTransactionInfo>(tx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Set Asset Script

          About Set Asset Script Transaction.

          NOTE: You can set an asset script only on those asset that were issued with a ride script attached.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Generate the private key using the wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Derive the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            /* 
            Define the asset ID:
            - For WAVES, use `AssetId.Waves`.
            - For custom assets, enter the asset ID.
            */
            var assetId = AssetId.As("PASTE THE ASSET ID HERE");
            
            // Transform your ride script into a Base64 string.
            var script = node.CompileScript("PASTE YOUR SCRIPT HERE").Script;
            
            // Build a Set Asset Script transaction.
            var tx = SetAssetScriptTransactionBuilder.Params(assetId, script).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(tx).Id);
            
            // Get the information about the transaction from the node.
            var txInfo = node.GetTransactionInfo<SetAssetScriptTransactionInfo>(tx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Update Asset Info

          About Update Asset Info Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Generate the private key using the wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Derive the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Define the asset ID.
            var assetId = AssetId.As("PASTE THE ASSET ID HERE");
            
            // Define the asset name.
            var name = "PASTE THE ASSET NAME HERE";
            
            // Define the asset description.
            var description = "PASTE THE ASSET DESCRIPTION HERE";
            
            // Build an Update Asset Info Transaction.
            var updateAssetInfoTx = UpdateAssetInfoTransactionBuilder.Params(assetId, name, description).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(updateAssetInfoTx).Id);
            
            // Get the information about the transaction from the node.
            var txInfo = node.GetTransactionInfo<UpdateAssetInfoTransactionInfo>(updateAssetInfoTx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Invoke Script

          About Invoke Script Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Generate the private key using the wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Derive the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            // Define the dApp address.
            var dAppAddress = Address.As("PASTE THE DAPP ADDRESS HERE");
            
            /* 
            Define the asset ID:
            - For WAVES, use `AssetId.Waves`.
            - For custom assets, enter the asset ID.
            */
            var assetId = AssetId.As("PASTE THE ASSET ID HERE");
            var assetIdTwo = AssetId.As("PASTE THE SECOND ASSET ID HERE");
            var assetIdThree = AssetId.As("PASTE THE THIRD ASSET ID HERE");
            
            // Create a list of payments.
            var payments = new List<Amount> {
                Amount.As(1005, assetId),
                Amount.As(1005, assetIdTwo),
                Amount.As(1005, assetIdThree)
            };
            
            var call = new Call {
                Function = "fname",
                Args = new List<CallArg> {
                    // The `call.args.type` binary with `call.args.value` equal to `senderAddress.bytes()`.
                    CallArg.AsBinary(senderAddress.Bytes),
                    // The `call.args.type` boolean with `call.args.value` equal to `true`.
                    CallArg.AsBoolean(true),
                    // The `call.args.type` integer with `call.args.value` equal to `100000`.
                    CallArg.AsInteger(100000),
                    // The `call.args.type` string with `call.args.value` equal to `string value`.
                    CallArg.AsString("string value"),
                    // The `call.args.type` list with `call.args.value` equal to `100000`.
                    CallArg.AsList(new [] {CallArg.AsInteger(100000) })
                }
            };
            
            // Build an Invoke Script Transaction.
            var invokeScriptTx = InvokeScriptTransactionBuilder.Params(dAppAddress, payments, call).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(invokeScriptTx).Id);
            
            // Get the information about the transaction from the node.
            var txInfo = node.GetTransactionInfo<InvokeScriptTransactionInfo>(invokeScriptTx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            

          # Sponsor Fee

          About Sponsor Fee Transaction.

          In your project directory:

          1. Replace the Program.cs file code with the following snippet:
            // Required imports.
            using WavesLabs.Node.Client;
            using WavesLabs.Node.Transactions.Common;
            using WavesLabs.Node.Transactions;
            using WavesLabs.Node.Client.Transactions;
            
            // Node instance creation in the given network: Testnet, Mainnet, or Stagenet.
            var node = new Node(Profile.MainNet);
            
            // Generate the private key using the wallet's seed phrase.
            var senderPrivateKey = PrivateKey.FromSeed("PASTE YOUR SEED PHRASE HERE");
            
            // Derive the public key from the private key.
            var senderPublicKey = senderPrivateKey.PublicKey;
            
            /* 
            Define the asset ID:
            - For WAVES, use `AssetId.Waves`.
            - For custom assets, enter the asset ID.
            */
            var assetId = AssetId.As("PASTE THE ASSET ID HERE");
            
            // Define the minimum sponsored asset fee in the smallest unit. E.g., `1000` for 10 tokens.
            var minSponsoredAssetFee = 100000;
            
            // Build a Sponsor Fee Transaction.
            var sponsorFeeTx = SponsorFeeTransactionBuilder.Params(assetId, minSponsoredAssetFee).GetSignedWith(senderPrivateKey);
            
            // Broadcast the transaction to the node.
            node.WaitForTransaction(node.Broadcast(sponsorFeeTx).Id);
            
            // Get the information about the transaction from the node.
            var txInfo = node.GetTransactionInfo<SponsorFeeTransactionInfo>(sponsorFeeTx.Id);
            
            // Print the transaction ID.
            Console.WriteLine(txInfo.Transaction.Id.ToString());
            
          2. Run the application:
            dotnet run
            
          Run Code Sample
          Use Crypto Utilities
          Run Code Sample
          Use Crypto Utilities