Which public parameter should be selected?

[cxmqq333]

There is a scenario similar to something like Tornado, where I need to calculate the original value of cm, with cm = hash(k, r). Here, the hash function uses the write() method from gnark/std/hash/sha2(code below), which only accepts the []uint8 type. What type of public parameters should k and r use? If they are of the frontend.Variable type, how can they be converted to []uint8?
func (d *digest) Write(data []uints.U8) {
d.in = append(d.in, data...)
}

[ivokub]

So, you have a frontend.Variable inside your circuit and you want to convert it to bytes? We don't have this method natively, we usually provide the byte array already as a witness. Then you could do something like this:

type Circuit struct {
    Input []uints.U8
}

func (c *Circuit) Define(api frontend.API) error {
    hasher, err := sha2.New(api)
    if err != nil { return err }
    hasher.Write(c.Inputs....)
    ....
    return nil
}

func main() {
    var byteInput []byte
    // read byteInput from file etc ....
    compiledCircuit := &Circuit{
        Inputs: make([]uints.U8, len(byteInput))
    }
    // compile circuit ....
    assignment := &Circuit{
        Inputs: uints.NewU8Array(byteInput)
    }
    // generate proof ...
}

Would your usecase be different?

[cxmqq333]

Yes, I am currently using []uints.U8. When the circuit is exported to a Solidity contract, each uints.U8 is converted to a uint256 (as shown in the generated circuit below, my circuit now has over 100 uint256 variables). These are then used for parameter calculations via the publicInputMSM method, leading to significant gas consumption. Is there a good way to reduce the associated gas costs?

[ivokub]

I see. I think we could provide a method which would split an input variable into bytes with range checking. I indeed see that for targeting Solidity verifier it would be useful. I'll come back to it in a few days, there are a few more things I'm currently working on.