[enhancement] enable placing constructor params in any part of function body

[A60AB5450353F40E]

Declare them in contract() statement, but decide their position later, so compiled bytecode can add them later to avoid unnecessary stack juggling

[rkalis]

This could be a nice optimisation. There's also some advantages to keeping them at the start with e.g. simulated state. I think it's also easier to use compiled CashScript contracts outside of the official SDK if the constructor args are at the start.

So it might not be worth the extra complexity / tradeoffs to add this functionality, and the optimisation is probably not super big, so it might be more fruitful to allow for larger contracts on BCH instead. I'll leave the issue open to consider in the future.

[mr-zwets]

Wishlisted Idea

The idea of improving stack ordering stems from at least 2019: "Advanced compiler optimisation" #34
so it's been long on the wishlist

Auto-inserted on first usage

I think the compiler could pretty easily insert the constructor variables automatically on the point of first usage.

There's also some advantages to keeping them at the start with e.g. simulated state. I think it's also easier to use compiled CashScript contracts outside of the official SDK if the constructor args are at the start.

I think simulated state is on it's way out and I think this could still be reasonably be worked around. I also don't think it would be prohibitive for possible future usage outside of the SDK.

Manual Insertion

A problem is that the compiler cannot perfectly optimize when hardcode the variable multiple times would be the best and when to stack-juggle them. This is because the compiler does not know the item length with types bytes, string , as can be very long or very small items. With the bigint upgrade also int could be a very large item. So only the boolean type remains...

Manual insertions only would have an ugly effect on CashScript code:

contract HodlVault(
    pubkey ownerPk,
    pubkey oraclePk,
    int minBlock,
    int priceTarget
) {
    function spend(sig ownerSig, datasig oracleSig, bytes oracleMessage) {
        // message: { blockHeight, price }
        insert oracleMessage;
        bytes4 blockHeightBin, bytes4 priceBin = oracleMessage.split(4);
        int blockHeight = int(blockHeightBin);
        int price = int(priceBin);

        // Check that blockHeight is after minBlock and not in the future
        insert minBlock;
        require(blockHeight >= minBlock);
        require(tx.time >= blockHeight);

        // Check that current price is at least priceTarget
        insert priceTarget;
        require(price >= priceTarget);

        // Handle necessary signature checks
        insert oraclePk;
        require(checkDataSig(oracleSig, oracleMessage, oraclePk));
        insert ownerPk;
        require(checkSig(ownerSig, ownerPk));
    }
}

[A60AB5450353F40E]

I'll use your HTLC contract example:

contract HTLC(
    pubkey sender,
    pubkey recipient,
    int expiration,
    bytes32 hash
) {
    // Require the preimage to match the stored hash and signature to match
    function complete(bytes preimage, sig s) {
        require(sha256(preimage) == hash);
        require(checkSig(s, recipient));
    }

    // Require time to be after expiration and signature to match
    function cancel(sig s) {
        require(tx.time >= expiration);
        require(checkSig(s, sender));
    }
}

Which compiles to:

<hash>
<expiration>
<recipient>
<sender>
OP_4 OP_PICK // functionIndex
OP_0 OP_NUMEQUAL
OP_IF
    OP_5 OP_ROLL // preimage
    OP_SHA256
    OP_4 OP_ROLL // hash
    OP_EQUALVERIFY
    OP_4 OP_ROLL // recipient
    OP_ROT OP_CHECKSIG
    OP_NIP OP_NIP OP_NIP
OP_ELSE
    OP_4 OP_ROLL // functionIndex
    OP_1 OP_NUMEQUALVERIFY
    OP_ROT // expiration
    OP_CHECKLOCKTIMEVERIFY OP_DROP
    OP_3 OP_ROLL // sender
    OP_SWAP OP_CHECKSIG
    OP_NIP OP_NIP
OP_ENDIF

How about a deferred keyword, which would defer insertion into bytecode until place of use - where it has to be declared again.
Multiple declarations of same name would mean another copy at place of declaration (another data push in compiled bytecode rather than stack juggling).

contract HTLC(
    deferred pubkey sender,
    deferred pubkey recipient,
    deferred int expiration,
    deferred bytes32 hash
) {
    // Require the preimage to match the stored hash and signature to match
    function complete(bytes preimage, sig s) {
        bytes32 hash;
        require(sha256(preimage) == hash);
        pubkey recipient;
        require(checkSig(s, recipient));
    }

    // Require time to be after expiration and signature to match
    function cancel(sig s) {
        int expiration;
        require(tx.time >= expiration);
        pubkey sender;
        require(checkSig(s, sender));
    }
}

and would then compile to

OP_4 OP_PICK // functionIndex
OP_0 OP_NUMEQUAL
OP_IF
    <preimage> // preimage
    OP_SHA256
    <hash> // hash
    OP_EQUALVERIFY
    <recipient> // recipient
    OP_ROT OP_CHECKSIG
OP_ELSE
    OP_4 OP_ROLL // functionIndex
    OP_1 OP_NUMEQUALVERIFY
    <expiration> // expiration
    OP_CHECKLOCKTIMEVERIFY OP_DROP
    <sender> // sender
    OP_SWAP OP_CHECKSIG
OP_ENDIF