Read aggregation + optional args ... sample code

[joshlang]

https://github.com/joshlang/wagmi-chill

Here's a code extract from a live project, which handles both read aggregation and optional args

It's quite opinionated, so I didn't want to turn it into an npm project. But maybe it's useful, so here ya go

...

const { address } = useAccount()
const contractAddress = useChillReadValue(chain, abi, "lp_token", someAddress)
const balance = useChillReadValue(chain, abi, "balanceOf", contractAddress, [address])

^-- if contractAddress or address is undefined, no network call is made and balance = undefined. Makes it easy to chain calls one after another.

export type ERC20Properties = {
    address: Address
    name: string
    symbol: string
    decimals: number
}

export default function useERC20(erc20Address: Address | undefined): ERC20Properties | undefined;
export default function useERC20(erc20Addresses: (Address | undefined)[]): (ERC20Properties | undefined)[];
export default function useERC20(erc20Addresses: (Address | undefined)[] | undefined): (ERC20Properties | undefined)[] | undefined;
export default function useERC20(erc20Addresses: Address | (Address | undefined)[] | undefined): ERC20Properties | (ERC20Properties | undefined)[] | undefined {
    const addresses = erc20Addresses && typeof erc20Addresses === "string" ? [erc20Addresses] : (erc20Addresses || undefined)
    const names = useChillFunctionReadValues(chain, abi, "name", addresses, { static: true })
    const symbols = useChillFunctionReadValues(chain, abi, "symbol", addresses, { static: true })
    const decimals = useChillFunctionReadValues(chain, abi, "decimals", addresses, { static: true })
    const results = addresses?.map((x, i) => x && typeof names[i] === "string" && typeof symbols[i] === "string" && typeof decimals[i] === "number" ? {
        address: x,
        name: names[i]!,
        symbol: symbols[i]!,
        decimals: decimals[i]!
    } : undefined) ?? []
    return Array.isArray(erc20Addresses) ? results : results[0]
}

^-- Arrays of arguments, which may be undefined or contain undefined elements, can be provided. All those network calls all go out as a single multicall

const { address } = useAddress()
const [ name, symbol, decimals, balance ] = useChillContractReadValues(chain, [
   { abi, address, functionName: "name" },
   { abi, address, functionName: "symbol" },
   { abi, address, functionName: "decimals" }, 
   { abi, address, functionName: "balanceOf", args: [address] }
])

^-- same idea

const tx = useChillWrite(chain, abi, "someFunction", contractAddress, [someArg], true)

^-- similar to wagmi native useContractWrite, tx.write is missing if it can't be executed. But it also is missing if contractAddress or someArg is missing, or if false is provided

...Anyway, it's by no means fully featured (and it's somewhat hacky)... But I'd love to see these features make it into the wagmi project. I'm sure it won't look like this - it's just illustrating usefulness... I hope :)