Function pack

ts/src/static_dependencies/ethers/coders/array.ts:15–74

(writer: Writer, coders: ReadonlyArray<Coder>, values: Array<any> | { [ name: string ]: any })

 *  @_ignore
 */
export function pack(writer: Writer, coders: ReadonlyArray<Coder>, values: Array<any> | { [ name: string ]: any }): number {
    let arrayValues: Array<any> = [ ];

    if (Array.isArray(values)) {
       arrayValues = values;

    } else if (values && typeof(values) === "object") {
        let unique: { [ name: string ]: boolean } = { };

        arrayValues = coders.map((coder) => {
            const name = coder.localName;
            assert(name, "cannot encode object for signature with missing names",
                "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });

            assert(!unique[name], "cannot encode object for signature with duplicate names",
                "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });

            unique[name] = true;

            return values[name];
        });

    } else {
        assertArgument(false, "invalid tuple value", "tuple", values);
    }

    assertArgument(coders.length === arrayValues.length, "types/value length mismatch", "tuple", values);

    let staticWriter = new Writer();
    let dynamicWriter = new Writer();

    let updateFuncs: Array<(baseOffset: number) => void> = [];
    coders.forEach((coder, index) => {
        let value = arrayValues[index];

        if (coder.dynamic) {
            // Get current dynamic offset (for the future pointer)
            let dynamicOffset = dynamicWriter.length;

            // Encode the dynamic value into the dynamicWriter
            coder.encode(dynamicWriter, value);

            // Prepare to populate the correct offset once we are done
            let updateFunc = staticWriter.writeUpdatableValue();
            updateFuncs.push((baseOffset: number) => {
                updateFunc(baseOffset + dynamicOffset);
            });

        } else {
            coder.encode(staticWriter, value);
        }
    });

    // Backfill all the dynamic offsets, now that we know the static length
    updateFuncs.forEach((func) => { func(staticWriter.length); });

    let length = writer.appendWriter(staticWriter);
    length += writer.appendWriter(dynamicWriter);