pyth-network_pyth-crosschain/ethereum/scripts/createLocalnetGovernanceVaa.js

const abi = require("web3-eth-abi");
const utils = require("web3-utils");
const elliptic = require("elliptic");

const testSigner1PK = "cfb12303a19cde580bb4dd771639b0d26bc68353645571a8cff516ab2ee113a0";

const testGovernanceChain = "1"; // ethereum
const testGovernanceEmitter = "0x0000000000000000000000000000000000000000000000000000000000001234";

function zeroPadBytes(value, length) {
    while (value.length < 2 * length) {
        value = "0" + value;
    }
    return value;
}

const signAndEncodeVM = function (
    timestamp,
    nonce,
    emitterChainId,
    emitterAddress,
    sequence,
    data,
    signers,
    guardianSetIndex,
    consistencyLevel
) {
    const body = [
        abi
            .encodeParameter("uint32", timestamp)
            .substring(2 + (64 - 8)),
        abi.encodeParameter("uint32", nonce).substring(2 + (64 - 8)),
        abi
            .encodeParameter("uint16", emitterChainId)
            .substring(2 + (64 - 4)),
        abi.encodeParameter("bytes32", emitterAddress).substring(2),
        abi
            .encodeParameter("uint64", sequence)
            .substring(2 + (64 - 16)),
        abi
            .encodeParameter("uint8", consistencyLevel)
            .substring(2 + (64 - 2)),
        data.substr(2),
    ];

    const hash = utils.soliditySha3(
        utils.soliditySha3("0x" + body.join(""))
    );

    let signatures = "";

    for (let i in signers) {
        const ec = new elliptic.ec("secp256k1");
        const key = ec.keyFromPrivate(signers[i]);
        const signature = key.sign(hash.substr(2), { canonical: true });

        const packSig = [
            abi.encodeParameter("uint8", i).substring(2 + (64 - 2)),
            zeroPadBytes(signature.r.toString(16), 32),
            zeroPadBytes(signature.s.toString(16), 32),
            abi
                .encodeParameter("uint8", signature.recoveryParam)
                .substr(2 + (64 - 2)),
        ];

        signatures += packSig.join("");
    }

    const vm = [
        abi.encodeParameter("uint8", 1).substring(2 + (64 - 2)),
        abi
            .encodeParameter("uint32", guardianSetIndex)
            .substring(2 + (64 - 8)),
        abi
            .encodeParameter("uint8", signers.length)
            .substring(2 + (64 - 2)),

        signatures,
        body.join(""),
    ].join("");

    return vm;
};

function createVAAFromUint8Array(
    dataBuffer,
    emitterChainId,
    emitterAddress,
    sequence,
) {
    const dataHex = "0x" + dataBuffer.toString("hex");
    return "0x" + signAndEncodeVM(
        0,
        0,
        emitterChainId,
        emitterAddress,
        sequence,
        dataHex,
        [testSigner1PK],
        0,
        0
    );
}

module.exports = function createLocalnetGovernanceVAA(dataBuffer, sequence) {
    return createVAAFromUint8Array(
        dataBuffer,
        testGovernanceChain,
        testGovernanceEmitter,
        sequence
    );
}