Developers
  • SWT PROTOCOL
    • Introduction
    • Accounts
    • Transactions
    • Fees
    • Smart Contracts
  • GETTING STARTED
    • Network Node
      • Introduction
      • STEP 1:RENTING A LINUX VPS
      • STEP 2:INSTALLATION OF PUTTY
      • STEP 3:INSTALLATION OF FILEZILLA
      • STEP 4:VPS CONNECTION AND LINUX CONFIGURATION WITH PUTTY (SSH)
      • STEP 5:HOW TO SECURE YOUR VPS
      • STEP 6:USING TMUX THROUGH PUTTY
      • STEP 7:UPLOAD OF THE SWT SOFTWARE WITH FILEZILLA
      • STEP 8:EXTRACT THE SWT SOFTWARE FOLDER
      • STEP 9:RUNNING THE SWT NODE THROUGH TMUX
      • STEP 10:RUNNING THE MONITORING TOOLS
  • API REFERENCE
    • Apache Thrift API
      • Transactions
      • Blocks
      • Smart contract
      • Tokens
      • Wallets
      • Sync info
      • Data structures
    • REST API
      • GetBlocks()
      • GetNodeInfo()
      • GetBalance()
      • GetWalletInfo()
      • GetTokenBalance()
      • GetTransactionsByWallet()
      • GetTransactionInfo()
      • GetEstimatedFee()
      • GetContractByAddress()
      • GetContractFromTransaction()
      • GetContractMethods()
      • ContractValidation()
      • ContractCall()
      • TransactionPack()
      • TransactionExec()
  • SMART CONTRACTS
    • Creating "Hello-world" Smart Contract
    • Smart Contract Methods
    • Smart Contract Standarts
      • Token Smart Contract
      • Escrow Smart Contract
      • Stable coin Token
  • HOW TO REST API
    • Introduction
    • Retrieve a balance from the blockchain
    • Request a specific transaction from the blockchain
    • Sending Transactions to the SWT Blockchain
    • Validating and deploying a Smart Contract with REST API
Powered by GitBook
On this page
  • Summary
  • Description
  • Request
  • Response
  • Example Code
  1. API REFERENCE
  2. REST API

GetContractFromTransaction()

Summary

Route
Type
Example

/contract/getfromtransaction

POST

http://176.113.80.7:62000/api/contract/getfromtransaction

Description

Get smart contract source code from a transaction.

Request

Request Structure

// Parameters common for all requests

"transactionId": "Decimal_String", // Smart contract address in Base58
"compressed": "boolean value" // Indicator of data compression true or false

}

Request Parameters

transactionId: transactionId- transaction identifier in the form block_number.transaction_number

bool: Compressed - Request compressed data True or False

Response

JSON output depends on the request type and its success.

If there’s an error, request returns to the node basic Result:

  • Success: False

  • Message:

If successful, requested information is returned.

Response Structure

{
   "gZipped":"Bytes", // Source code of smart contract Compressed
   "sourceString":"String", // Source code of smart contract in String Value
   "success":"bool", // Shows if request was Succes or False Boolean Value 
   "message":"String" // Shows if a problem occurred with request in String Value
}

Example Code

Python

import requests
import json
def Getcontractbytransaction():
    url =  'http://176.113.80.7:62000/api/contract/getfromtransaction'
    headers = {
        'Content-type': 'application/json'
        , 'Accept': 'application/json'
        , 'Content-Encoding': 'utf-8'
        }
    data = {
        "NetworkAlias":"Mainnet"
        , "transactionId":"22863295.1"
        , "compressed": False
        }
    answer = requests.post(url, data=json.dumps(data), headers=headers)
    response = answer.json()
    print(response)
Getcontractbytransaction()

C++

#include <iostream>

#include <cpprest/http_client.h>
#include <cpprest/filestream.h>

using namespace utility;                    // Common utilities like string conversions
using namespace web;                        // Common features like URIs.
using namespace web::http;                  // Common HTTP functionality
using namespace web::http::client;          // HTTP client features
using namespace concurrency::streams;       // Asynchronous streams
using namespace web::json;

int main(int argc, char* argv[])
{
    web::json::value json_v;
    web::json::value json_return;
    json_v[L"authKey"] = web::json::value::string(L"");
    json_v[L"NetworkAlias"] = web::json::value::string(L"Mainnet");
    json_v[L"transactionId"] = web::json::value::string(L"22863295.1");
    json_v[L"compressed"] = web::json::value::boolean(false);
    http_client client(U("http://176.113.80.7:62000"));

    client.request(web::http::methods::POST, U("/api/contract/getfromtransaction"), json_v)
        .then([](const web::http::http_response& response) {
        return response.extract_json();
    })
        .then([&json_return](const pplx::task<web::json::value>& task) {
        try {
            json_return = task.get();
        }
        catch (const web::http::http_exception& e) {
            std::cout << "error " << e.what() << std::endl;
        }
    })
        .wait();

    std::wcout << json_return.serialize() << std::endl;

    return 0;
}

C#

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
namespace Program.Getinfo
{
    public class Getcontractbytransaction
    {
        static readonly HttpClient client = new HttpClient();
        public class body
        {
            public string authKey { get; set; }
            public string networkAlias { get; set; }
            public string transactionId { get; set; }
            public bool compressed { get; set; }
        }
        public static async Task Main()
        {
            try
            {
                var body = new body
                {
                    authKey = "",
                    networkAlias = "Mainnet",
                    transactionId = "22863295.1",
                    compressed = false
                };
                var httpContent = new StringContent(JsonConvert.SerializeObject(body),
                    Encoding.UTF8, "application/json");
                var response = await client.PostAsync("http://176.113.80.7:62000/api/contract/getfromtransaction",
                    httpContent);
                Console.WriteLine("RESPONSE=" +
                    await response.Content.ReadAsStringAsync());
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
    }
}
PreviousGetContractByAddress()NextGetContractMethods()

Last updated 1 year ago