Class: ContractInterface
Interface for interacting with Starknet smart contracts
Provides methods for calling contract functions, estimating fees, and managing contract state. Supports both read-only calls and state-changing invocations.
Remarks
The interface provides multiple ways to interact with contracts:
- Direct method calls for convenience
- Generic call/invoke methods for flexibility
- Fee estimation and transaction population
- Event parsing and contract validation
Implemented by
Indexable
▪ [key: string]: AsyncContractFunction | any
Dynamic method access - allows calling contract methods directly
Constructors
constructor
• new ContractInterface(): ContractInterface
Returns
Properties
abi
• Abstract abi: Abi
Contract ABI (Application Binary Interface)
Defined in
address
• Abstract address: string
Contract address on Starknet
Defined in
providerOrAccount
• Abstract providerOrAccount: ProviderOrAccount
Provider for read operations or Account for write operations
Defined in
classHash
• Optional Abstract classHash: string
Optional contract class hash for optimization
Defined in
functions
• Readonly functions: Object
Contract methods that return promises (async operations)
Index signature
▪ [name: string]: AsyncContractFunction
Defined in
callStatic
• Readonly callStatic: Object
Contract methods for read-only calls (state queries)
Index signature
▪ [name: string]: AsyncContractFunction
Defined in
populateTransaction
• Readonly populateTransaction: Object
Contract methods that return populated transactions for batching
Index signature
▪ [name: string]: ContractFunction
Defined in
estimateFee
• Readonly estimateFee: Object
Contract methods for fee estimation
Index signature
▪ [name: string]: ContractFunction
Defined in
Methods
attach
▸ attach(address, abi?): void
Attach the contract to a different address with optional new ABI
Parameters
| Name | Type | Description |
|---|---|---|
address | string | New contract address to interact with |
abi? | Abi | Optional new ABI to use (defaults to current ABI) |
Returns
void
Example
contract.attach('0x123...', newAbi);
// Now contract.address === '0x123...' and uses newAbi
Defined in
isDeployed
▸ isDeployed(): Promise<ContractInterface>
Verify that a contract is deployed at the current address
Returns
Promise<ContractInterface>
Promise resolving to this contract instance if deployed
Throws
If no contract is found at the address
Example
try {
await contract.isDeployed();
console.log('Contract is deployed');
} catch (error) {
console.log('Contract not found at address');
}
Defined in
call
▸ call(method, args?, options?): Promise<CallResult>
Call a read-only contract method (view function)
Parameters
| Name | Type | Description |
|---|---|---|
method | string | Name of the contract method to call |
args? | ArgsOrCalldata | Method arguments as array or calldata |
options? | CallOptions | Call options including block identifier and parsing settings |
Returns
Promise<CallResult>
Parsed result from the contract method
Example
const balance = await contract.call('balanceOf', [userAddress]);
const name = await contract.call('name', [], { blockIdentifier: 'latest' });
Defined in
invoke
▸ invoke(method, args?, options?): Promise<{ transaction_hash: string }>
Invoke a state-changing contract method (external function)
Parameters
| Name | Type | Description |
|---|---|---|
method | string | Name of the contract method to invoke |
args? | ArgsOrCalldata | Method arguments as array or calldata |
options? | ExecuteOptions | Execution options including transaction details |
Returns
Promise<{ transaction_hash: string }>
Transaction response with hash
Example
const tx = await contract.invoke('transfer', [recipient, amount]);
const receipt = await provider.waitForTransaction(tx.transaction_hash);
Defined in
estimate
▸ estimate(method, args?, options?): Promise<EstimateFeeResponseOverhead | PaymasterFeeEstimate>
Estimate fee for invoking a contract method
Parameters
| Name | Type | Description |
|---|---|---|
method | string | Name of the contract method to estimate |
args? | ArgsOrCalldata | Method arguments as array or calldata |
options? | Object | Estimation options including block identifier |
options.blockIdentifier? | BlockIdentifier | - |
Returns
Promise<EstimateFeeResponseOverhead | PaymasterFeeEstimate>
Fee estimation details
Example
const feeEstimate = await contract.estimate('transfer', [recipient, amount]);
console.log('Estimated fee:', feeEstimate.overall_fee);
Defined in
populate
▸ populate(method, args?): Invocation
Populate transaction data for a contract method call
Parameters
| Name | Type | Description |
|---|---|---|
method | string | Name of the contract method |
args? | ArgsOrCalldata | Method arguments as array or calldata |
Returns
Invocation object for batching or inspection
Example
const invocation = contract.populate('transfer', [recipient, amount]);
// Use in account.execute([invocation1, invocation2, ...])
Defined in
parseEvents
▸ parseEvents(receipt): ParsedEvents
Parse events from a transaction receipt using the contract's ABI
Parameters
| Name | Type | Description |
|---|---|---|
receipt | GetTransactionReceiptResponse | Transaction receipt from waitForTransaction |
Returns
Array of parsed events with decoded data
Example
const receipt = await provider.waitForTransaction(txHash);
const events = contract.parseEvents(receipt);
events.forEach((event) => {
console.log('Event:', event.name, event.data);
});
Defined in
isCairo1
▸ isCairo1(): boolean
Check if the contract is implemented in Cairo 1
Returns
boolean
True if the contract uses Cairo 1, false for Cairo 0 (legacy)
Example
if (contract.isCairo1()) {
console.log('Using Cairo 1 features');
}
Defined in
getVersion
▸ getVersion(): Promise<ContractVersion>
Get the Cairo and compiler version of the contract
Returns
Promise<ContractVersion>
Object containing cairo version and compiler version
Example
const version = await contract.getVersion();
console.log(`Cairo ${version.cairo}, Compiler ${version.compiler}`);
Defined in
typedv2
▸ typedv2<TAbi>(tAbi): TypedContractV2<TAbi>
Create a typed contract instance with full TypeScript support
Type parameters
| Name | Type |
|---|---|
TAbi | extends Abi |
Parameters
| Name | Type | Description |
|---|---|---|
tAbi | TAbi | The typed ABI interface for compile-time type checking |
Returns
TypedContractV2<TAbi>
Typed contract instance with IntelliSense support
Example
const typedContract = contract.typedv2(erc20Abi);
// Now typedContract.transfer() has full type safety
Defined in
withOptions
▸ withOptions(options): ContractInterface
Set execution options for subsequent contract interactions
Parameters
| Name | Type | Description |
|---|---|---|
options | WithOptions | Options to override for contract interactions |
Returns
This contract instance with the specified options applied
Example
contract.withOptions({
blockIdentifier: 'latest',
parseResponse: false,
});
// Now all subsequent calls use these options