Skip to main content

Deploy Contract

Review the Javascript that defines deployContract.js

Deploy button Contract#

Using the deployContract.js file defined in zilliqa-js we have the ability to deploy a contract to a network. We provide a private key of the address which is deploying, the previous network configuration to establish a connection, in our case this is testnet, but could be mainnet or isolated environment.

We refactor the deployContract.js method to fit our usecase.

// Deploys a contract using a private key, returns the deployed_contract_base_16 of the contract deployedasync function DeployButtonContract() {    try {      // Get Balance      const balance = await zilliqa.blockchain.getBalance(address_from_pk);      // Get Minimum Gas Price from blockchain      const minGasPrice = await zilliqa.blockchain.getMinimumGasPrice();        // Account balance (See note 1)      console.log(`Your account balance is:`);      console.log(balance.result);      console.log(`Current Minimum Gas Price: ${minGasPrice.result}`);      const myGasPrice = units.toQa('2000', units.Units.Li); // Gas Price that will be used by all transactions      console.log(`My Gas Price ${myGasPrice.toString()}`);      const isGasSufficient = myGasPrice.gte(new BN(minGasPrice.result)); // Checks if your gas price is less than the minimum gas price      console.log(`Is the gas price sufficient? ${isGasSufficient}`);        // Deploy a contract      console.log(`Deploying a new contract....`);      const code = `        scilla_version 0        library MyFirstButton
        let uint128_zero = Uint128 0        let uint128_one  = Uint128 1        let empty_bystr = 0x1111111111111111111111111111111111111111
        (* Error exception *)        type Error =        | NotContractOwner        | NotUniqueClicker
        let make_error =        fun (result : Error) =>            let result_code =             match result with            | NotContractOwner             => Int32 -1            | NotUniqueClicker             => Int32 -2            end            in            { _exception : "Error"; code : result_code }                      (*        * Create a scilla contract which models a button that can be pressed by anyone.         * If you are the recent button presser you may not press the button again.        * When the button is pressed: Increment a counter and set the caller of the button press to be the most recent address.          * The owner of the button has the ability to reset the counter to zero         *)        contract MyFirstButton        (        contract_owner: ByStr20        )
        field current_clicker    : ByStr20 = empty_bystr        field total_count_clicks : Uint128 = uint128_zero
        (*         @Dev: Emit Errors         *)        procedure ThrowError(err : Error)        e = make_error err;        throw e        end
        (*        @Dev : Throws an error if '_sender' is not 'contract_owner'        *)        procedure IsContractOwner()        is_contract_owner = builtin eq contract_owner _sender;        match is_contract_owner with        | True =>             (* No Operation - Continue contract execution *)        | False =>            err = NotContractOwner;            ThrowError err        end        end
        (*          Dev: Increments 'current_clicker' by 'uint128_one'        *)        procedure IncrementCounter()        previous_click_count <- total_count_clicks;        new_click_count = builtin add previous_click_count uint128_one;        total_count_clicks := new_click_count;
        e = {_eventname : "IncrementCounterSuccess"; pcc:previous_click_count; ncc: new_click_count  };        event e        end 

        (*          Dev: Throws an error if the current '_sender' is the previous 'current_clicker'        *)        procedure IsPreviousClicker(new_clicker: ByStr20)        previous_clicker <- current_clicker;        is_previous_clicker = builtin eq previous_clicker _sender;        match is_previous_clicker with        | True =>             err = NotUniqueClicker;            ThrowError err        | False =>            (* No Operation - Continue contract execution *)        end        end
        (*          Dev: Sets 'new_clicker' as 'current_clicker'        *)        procedure SetNewClicker(new_clicker: ByStr20)        current_clicker := new_clicker;
        e = {_eventname : "NewClickerState"; nc:new_clicker};        event e        end
        (*          Dev: Resets 'current_clicker' to 'uint128_zero'        *)        procedure ContractOwnerResetButton()        total_count_clicks  := uint128_zero        end
        (*          Dev: Sets 'new_clicker' as current_clicker        *)        transition PressTheButton()        IsPreviousClicker _sender;        SetNewClicker _sender;        IncrementCounter;
        e = {_eventname : "PressTheButtonSuccess"; button_presser : _sender };        event e        end                const init = [            // this parameter is mandatory for all init arrays            {            vname: '_scilla_version',            type: 'Uint32',            value: '0',            },            {            vname: 'contract_owner',            type: 'ByStr20',            value: `${address_from_pk}`,            },        ];            const contract = zilliqa.contracts.new(code, init);            // Deploy the contract.        // Also notice here we have a default function parameter named toDs as mentioned above.        // A contract can be deployed at either the shard or at the DS. Always set this value to false.        const [deployTx, deployedContract] = await contract.deployWithoutConfirm(            {            version: VERSION,            gasPrice: myGasPrice,            gasLimit: Long.fromNumber(10000),            },            false,        );            // process confirm        console.log(`The transaction id is:`, deployTx.id);        console.log(`Waiting transaction be confirmed`);        const confirmedTxn = await deployTx.confirm(deployTx.id);            console.log(`The transaction status is:`);        console.log(confirmedTxn.receipt);        if (confirmedTxn.receipt.success === true) {            console.log(`Contract address is: 0x${deployedContract.address}`);            return "0x" + deployedContract.address;        }        } catch (err) {        console.log(err);        }    }

Setup Program Starting Point#

With our objectives defined we can begin to write how our program will achieve the functionality required. We have the first part complete, so let's write where our program will enter from and begin to test the deployment of DeployButtonContract contract to testnet.

// Application Definition// DEPLOY a contract// SEND a transaction// LISTEN to events emitted// MONITOR mutable stateasync function DeploySendListenMonitor(){    deployed_contract_base_16 = await DeployButtonContract();    bech_32_bystr = toBech32Address(deployed_contract_base_16);    console.log(`got ${bech_32_bystr} from ${deployed_contract_base_16}`)}
// StartDeploySendListenMonitor();

Using the command node index.js we can run the Javascript in the console and get the output.

our account balance is:{ balance: '1996734999999850', nonce: 299 }Current Minimum Gas Price: 2000000000My Gas Price 2000000000Is the gas price sufficient? trueDeploying a new contract....The transaction id is: 2e253603e77bfd104ffefa5015267f158f967a29f733803aec69d0f23ce290deWaiting transaction be confirmedThe transaction status is:{ cumulative_gas: 401, epoch_num: '3726609', success: true }Contract address is: 0x8074237359dddba429ff1d02633a5d01e637ed91got zil1sp6zxu6emhd6g20lr5pxxwjaq8nr0mv38w8msm from 0x8074237359dddba429ff1d02633a5d01e637ed91