Skip to content

Latest commit

 

History

History
397 lines (272 loc) · 5.87 KB

builtins.md

File metadata and controls

397 lines (272 loc) · 5.87 KB

Built-in Functions & Objects

Reference for all built-in functions and global objects.

Global Objects

msg

Transaction message context:

Property Type Description
msg.sender address Address of the caller
msg.value uint256 Amount of SOL sent (in lamports)
msg.data bytes Complete calldata 
function deposit() public payable {
    address caller = msg.sender;
    uint256 amount = msg.value;
}

block

Current block information:

Property Type Description
block.timestamp uint256 Current block timestamp (Unix seconds)
block.number uint256 Current slot number 
function checkExpiry(uint256 deadline) public view {
    require(block.timestamp < deadline, "Expired");
}

tx

Transaction context:

Property Type Description
tx.origin address Original transaction sender 
// Note: Avoid using tx.origin for authorization
function getOriginalSender() public view returns (address) {
    return tx.origin;
}

Type Functions

address

Function Returns Description
address(0) address Zero address
address(x) address Convert to address 
address zero = address(0);
require(recipient != address(0), "Invalid address");

uint/int Conversions

// Explicit conversions
uint8 small = uint8(256);    // Truncates to 0
uint256 large = uint256(100);
int256 signed = int256(unsignedValue);

String Functions

string.concat

Concatenate strings:

string memory greeting = string.concat("Hello, ", name, "!");

Array Functions

push

Append element to dynamic array:

uint256[] storage arr;
arr.push(42);

pop

Remove and return last element:

uint256 last = arr.pop();

length

Get array length:

uint256 len = arr.length;

Bytes Functions

bytes.concat

Concatenate byte arrays:

bytes memory result = bytes.concat(data1, data2);

keccak256

Compute Keccak-256 hash:

bytes32 hash = keccak256(abi.encodePacked("data"));
bytes32 hash2 = keccak256(abi.encode(value1, value2));

sha256

Compute SHA-256 hash:

bytes32 hash = sha256(abi.encodePacked("data"));

ABI Encoding

abi.encode

Standard ABI encoding with padding:

bytes memory encoded = abi.encode(
    uint256(100),
    address(0x123...),
    "hello"
);

abi.encodePacked

Packed encoding (no padding):

bytes memory packed = abi.encodePacked(
    uint8(1),
    uint16(2),
    uint32(3)
);

abi.encodeWithSelector

Encode with function selector:

bytes memory data = abi.encodeWithSelector(
    IERC20.transfer.selector,
    recipient,
    amount
);

abi.decode

Decode ABI-encoded data:

(uint256 value, address addr) = abi.decode(
    data,
    (uint256, address)
);

Control Flow

require

Revert if condition is false:

require(condition, "Error message");
require(amount > 0, "Amount must be positive");
require(msg.sender == owner);  // No message

revert

Explicitly revert execution:

// With message
revert("Something went wrong");

// With custom error
revert InsufficientBalance(available, required);

// Plain revert
revert();

assert

Check invariants (should never fail):

assert(totalBefore == totalAfter);

Math Functions

Operators

Operator Description
+ Addition
- Subtraction
* Multiplication
/ Integer division
% Modulo (remainder)
** Exponentiation 
uint256 sum = a + b;
uint256 power = base ** exponent;
uint256 remainder = dividend % divisor;

Comparison

Operator Description
< Less than
<= Less than or equal
> Greater than
>= Greater than or equal
== Equal
!= Not equal

Bitwise Operations

Operator Description
& Bitwise AND
| Bitwise OR
^ Bitwise XOR
~ Bitwise NOT
<< Left shift
>> Right shift 
uint256 flags = a & b;
uint256 combined = a | b;
uint256 shifted = value << 8;

Type Information

type(T).min / type(T).max

Get type bounds:

uint256 maxUint = type(uint256).max;
int256 minInt = type(int256).min;

Special Values

this

Reference to current contract:

address contractAddr = address(this);
uint256 balance = address(this).balance;

super

Reference to parent contract:

function foo() public override {
    super.foo();  // Call parent implementation
}

Events

emit

Emit an event:

event Transfer(address indexed from, address indexed to, uint256 amount);

function transfer(address to, uint256 amount) public {
    // ... transfer logic ...
    emit Transfer(msg.sender, to, amount);
}

Memory Allocation

new

Create new array in memory:

uint256[] memory arr = new uint256[](10);
bytes memory data = new bytes(32);

delete

Reset value to default:

delete balances[user];  // Reset to 0
delete myStruct;        // Reset all fields
delete myArray;         // Clear array

Solana-Specific

Program Context

// Access current program ID
address programId = program.id;

PDA Derivation

// Derive PDA
(address pda, uint8 bump) = findProgramAddress(
    seeds,
    programId
);

See Also