CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-web3-eth-abi

Web3 module encode and decode EVM in/output.

—

Pending
Overview
Eval results
Files

parameter-processing.mddocs/

Parameter Processing

Low-level parameter encoding and decoding operations for individual values and parameter arrays. Supports all Solidity data types including complex structs, arrays, and custom types.

Capabilities

Encode Single Parameter

Encodes a parameter based on its type to its ABI representation.

/**
 * Encodes a parameter based on its type to its ABI representation
 * @param abi - The type of the parameter (Solidity type)
 * @param param - The actual parameter to encode
 * @returns The ABI encoded parameter
 */
function encodeParameter(abi: AbiInput, param: unknown): string;

Usage Examples:

import { encodeParameter } from "web3-eth-abi";

// Encode uint256
const encoded1 = encodeParameter("uint256", "2345675643");
console.log(encoded1);
// 0x000000000000000000000000000000000000000000000000000000008bd02b7b

// Encode bytes32
const encoded2 = encodeParameter("bytes32", "0xdf3234");
console.log(encoded2);
// 0xdf32340000000000000000000000000000000000000000000000000000000000

// Encode dynamic bytes
const encoded3 = encodeParameter("bytes", "0xdf3234");
console.log(encoded3);
// 0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000003df32340000000000000000000000000000000000000000000000000000000000

// Encode array
const encoded4 = encodeParameter("bytes32[]", ["0xdf3234", "0xfdfd"]);
console.log(encoded4);
// 0x00000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000002df32340000000000000000000000000000000000000000000000000000000000fdfd000000000000000000000000000000000000000000000000000000000000

// Encode struct
const encoded5 = encodeParameter(
  {
    ParentStruct: {
      propertyOne: "uint256",
      propertyTwo: "uint256",
      childStruct: {
        propertyOne: "uint256",
        propertyTwo: "uint256"
      }
    }
  },
  {
    propertyOne: 42,
    propertyTwo: 56,
    childStruct: {
      propertyOne: 45,
      propertyTwo: 78
    }
  }
);
console.log(encoded5);
// 0x000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e

Encode Multiple Parameters

Encodes multiple parameters based on their types to ABI representation.

/**
 * Encodes multiple parameters based on their types to ABI representation
 * @param abi - Array of parameter types
 * @param params - Array of parameter values to encode
 * @returns The ABI encoded parameters
 */
function encodeParameters(
  abi: AbiInput[] | ReadonlyArray<AbiInput>,
  params: unknown[]
): string;

Usage Examples:

import { encodeParameters } from "web3-eth-abi";

// Encode multiple basic types
const encoded1 = encodeParameters(
  ["uint256", "string"],
  ["2345675643", "Hello!%"]
);
console.log(encoded1);
// 0x000000000000000000000000000000000000000000000000000000008bd02b7b0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000748656c6c6f212500000000000000000000000000000000000000000000000000

// Encode with named parameters
const encoded2 = encodeParameters(
  [
    { type: "uint256", name: "myNumber" },
    { type: "string", name: "myString" }
  ],
  ["2345675643", "Hello!%"]
);
console.log(encoded2);
// Same output as above

Infer Types and Encode Parameters

Automatically infers parameter types and encodes them. Useful when working with JavaScript values without explicit type definitions.

/**
 * Infers parameter types from values and encodes them
 * @param params - Array of parameter values to infer types from and encode
 * @returns The ABI encoded parameters with inferred types
 */
function inferTypesAndEncodeParameters(params: unknown[]): string;

Decode Single Parameter

Decodes an ABI encoded parameter to its JavaScript type.

/**
 * Decodes an ABI encoded parameter to its JavaScript type
 * @param abi - The type of the parameter
 * @param bytes - The ABI byte code to decode
 * @returns The decoded parameter
 */
function decodeParameter(abi: AbiInput, bytes: HexString): unknown;

Usage Examples:

import { decodeParameter } from "web3-eth-abi";

// Decode uint256
const result1 = decodeParameter(
  "uint256",
  "0x0000000000000000000000000000000000000000000000000000000000000010"
);
console.log(result1); // 16n

// Decode string
const result2 = decodeParameter(
  "string",
  "0x0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000"
);
console.log(result2); // "Hello!%!"

// Decode struct
const result3 = decodeParameter(
  {
    ParentStruct: {
      propertyOne: "uint256",
      propertyTwo: "uint256",
      childStruct: {
        propertyOne: "uint256",
        propertyTwo: "uint256"
      }
    }
  },
  "0x000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e"
);
console.log(result3);
// {
//   '0': 42n,
//   '1': 56n,
//   '2': {
//     '0': 45n,
//     '1': 78n,
//     __length__: 2,
//     propertyOne: 45n,
//     propertyTwo: 78n
//   },
//   __length__: 3,
//   propertyOne: 42n,
//   propertyTwo: 56n,
//   childStruct: {
//     '0': 45n,
//     '1': 78n,
//     __length__: 2,
//     propertyOne: 45n,
//     propertyTwo: 78n
//   }
// }

Decode Multiple Parameters

Decodes ABI encoded parameters to their JavaScript types.

/**
 * Decodes ABI encoded parameters to their JavaScript types  
 * @param abi - Array of parameter types
 * @param bytes - The ABI byte code to decode
 * @returns Object containing decoded parameters with numeric and named keys
 */
function decodeParameters(
  abi: AbiInput[] | ReadonlyArray<AbiInput>,
  bytes: HexString
): { [key: string]: unknown; __length__: number };

Usage Examples:

import { decodeParameters } from "web3-eth-abi";

// Decode multiple basic types
const result1 = decodeParameters(
  ["string", "uint256"],
  "0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000ea000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000"
);
console.log(result1);
// { '0': 'Hello!%!', '1': 234n, __length__: 2 }

// Decode with named parameters
const result2 = decodeParameters(
  [
    { type: "string", name: "myString" },
    { type: "uint256", name: "myNumber" }
  ],
  "0x000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000ea000000000000000000000000000000000000000000000000000000000000000848656c6c6f212521000000000000000000000000000000000000000000000000"
);
console.log(result2);
// {
//   '0': 'Hello!%!',
//   '1': 234n,
//   __length__: 2,
//   myString: 'Hello!%!',
//   myNumber: 234n
// }

// Decode complex structure with array and struct
const result3 = decodeParameters(
  [
    "uint8[]",
    {
      ParentStruct: {
        propertyOne: "uint256",
        propertyTwo: "uint256",
        childStruct: {
          propertyOne: "uint256",
          propertyTwo: "uint256"
        }
      }
    }
  ],
  "0x00000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000038000000000000000000000000000000000000000000000000000000000000002d000000000000000000000000000000000000000000000000000000000000004e0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000002a0000000000000000000000000000000000000000000000000000000000000018"
);
console.log(result3);
// Complex nested structure with array and struct

Decode Parameters with Loose Mode

Decodes parameters with optional loose mode for more permissive decoding.

/**
 * Decodes parameters with loose mode option
 * @param abis - Array of parameter types  
 * @param bytes - The ABI byte code to decode
 * @param loose - Enable loose mode for permissive decoding
 * @returns Object containing decoded parameters
 */
function decodeParametersWith(
  abis: AbiInput[] | ReadonlyArray<AbiInput>,
  bytes: HexString,
  loose: boolean
): { [key: string]: unknown; __length__: number };

Types

interface AbiInput {
  name?: string;
  type: string;
  indexed?: boolean;
  components?: AbiInput[];
}

type HexString = string;

Install with Tessl CLI

npx tessl i tessl/npm-web3-eth-abi

docs

eip-712.md

error-handling.md

event-processing.md

function-operations.md

index.md

parameter-processing.md

tile.json