How to call fallback function of a contract?

[Arul-]

Does Contract API support calling a fallback function? (both payable and non-payable)

I don't find any documentation on this! I tried the following which fails

contractInstance[''].apply(contractInstance); //giving it a blank string as the function name

[ricmoo]

This is a good idea to add to the Interface object, for completion.

However, it is not strictly needed. Calling the default function can be achieved simply by sending a transaction to the contraxct:

var tx = {
    to: contractAddress,
    value: ethers.utils.parseEther("1.0")
};

wallet.sendTransaction(tx).then(function(tx) {
    console.log(tx);
});

You bring up an interesting thing I had not considered though... Can the default function returns? I will experiment with this and make sure. It should (according to EVM) not be anything special, so it should be supported, but I'm not sure if Solidity supports it. Regardless, I can make some samples assembly examples to test it.

[sachinsinghjagawat]

Sir, your solution is correct but I am encountering problems when I pass the gas limit to it. It is not accepting the gas limit as its parameter. It says Error: invalid hexlify value. This issue is there only for sendTransaction function and not in any other contract interaction. Please look into the matter.

[GregTheGreek]

Whats the status on this?

[ricmoo]

@GregTheGreek Still has not been added. I'm still mulling it over, especially insight of the new Solidity changes. There almost either needs to be zero functions to do this, or two separate options (of which, for any given situation, only one would be valid, I think?)...

Both seem correct, but zero seems cleaner. :p

I still need to catch up on the "received" Solidity feature.

[ricmoo]

For now, I think the best way to perform these operations is to rely on manually sending to the contract address. I may consider adding a function for receive() and () (for fallback), but for now I'm going to close this, since it is easy to manually do and once we move to a Proxy-based contract these become easier and safer.

But please re-open if you feel this is something that is important to be part of a Contract object.

Thanks! :)

[psytron]

So how can we get data returned from fallback() function of proxy contract?
sendTransaction(tx) doesn't seem to return the data?

[zemse]

Hey @psytron, if your fallback function returns a value and you directly calling the contract using sendTransaction(tx), then you can't get the return value trivial since it's a transaction (though it could be extracted from an execution trace somehow). If you instead wanted to do a simple read call (to a maybe view or pure function), you can do following:

const result = await provider.call({
    to: contractAddress,
    data: '0x1234..' // encoded data
})

If your proxy contract is a minimal proxy contract like EIP-1167, then you can simply pass the proxy address to the Contract.

const myContract = new ethers.Contract(proxyAddr, implementationAbi, provider);

[qzirak]

@psytron So we can not encode a custom function selector to be sent to a proxy contract as calldata (For viewing purposes only), and its fallback returns a value (after a delegate call to implementation contract which returns a value to Proxy)?

`const abi1 = ["function setOwner(address _address)"]; // Setter
const abi2 = ["function getOwner()"]; // Getter

        const interface1 = new ethers.utils.Interface(abi1);
        const interface2 = new ethers.utils.Interface(abi2);

        const callData1 = interface1.encodeFunctionData("setOwner", [signer1.address]);
        const callData2 = interface2.encodeFunctionData("getOwner");

        let tx1 = await deployer.sendTransaction({ // tx1 is transaction data
            to: dp.address, // Proxy which does a delegate call
            data: callData1 // Set the Owner
        })

        let tx2 = await ethers.provider.call({ // tx2 is also transaction data
            to: dp.address, // Proxy which does a delegate call
            data: callData2
        })

        // let owner = await dp.callStatic.getOwner(); // Can't encode custom selector here`

What is alternative for this as I was doing Diamond contracts. Cuz the data of facets are stored in the proxy, and view methods are in the facets.

[ricmoo]

If it is a normal proxy, you should be able to use the target’s ABI and just use the proxy’s address. You can’t just swap out the selector though, since the selector includes the parameter information.

I haven’t looked into Diamonds in quite some time, but I believe you should be able to just merge all the fragments and specify the root contract address. If the fallback uses the selector to dispatch, I don’t think it cares?

[qzirak]

Well, the fallback of diamond does use selector to dispatch delegate calls to facets (selector to facet mapping). However, the real problem is getting return value from non-view function. sendTransaction and provider.call both return a transaction data. callStatic solves this return problem, but it has a bad synergy with fallbacks (i.e. method must be known in advance and must exist in the proxy).

I solved it temporarily by adding a dummy parameter to view functions. But the resultant value is right padded 32bytes

[psytron]

Marvelous. Thank You @zemse

[zemse]

Welcome :)