The interface definition.
The network and wallet context to use. If not provided then uses getProvider.
A function that returns a custom account resolver for the given instruction. This is useful for resolving public keys of missing accounts when building instructions
The namespace provides handles to an AccountClient object for each account in the program.
program.account.<account-client>
To fetch a Counter account from the above example,
const counter = await program.account.counter.fetch(address);
For the full API, see the AccountClient reference.
The namespace provides functions to build TransactionInstruction objects for each method of a program.
program.instruction.<method>(...args, ctx);
args - The positional arguments for the program. The type and number
of these arguments depend on the program being used.ctx - Context non-argument parameters to pass to the method.
Always the last parameter in the method call.To create an instruction for the increment method above,
const tx = await program.instruction.increment({
accounts: {
counter,
},
});
The namespace provides a builder API for all APIs on the program. This is an alternative to using namespace the other namespaces..
Async methods to send signed transactions to non-state methods on the program, returning a TransactionSignature.
rpc.<method>(...args, ctx);
args - The positional arguments for the program. The type and number
of these arguments depend on the program being used.ctx - Context non-argument parameters to pass to the method.
Always the last parameter in the method call.To send a transaction invoking the increment method above,
const txSignature = await program.rpc.increment({
accounts: {
counter,
authority,
},
});
The namespace provides functions to simulate transactions for each method of a program, returning a list of deserialized events and raw program logs.
One can use this to read data calculated from a program on chain, by
emitting an event in the program and reading the emitted event client side
via the simulate namespace.
program.simulate.<method>(...args, ctx);
args - The positional arguments for the program. The type and number
of these arguments depend on the program being used.ctx - Context non-argument parameters to pass to the method.
Always the last parameter in the method call.To simulate the increment method above,
const events = await program.simulate.increment({
accounts: {
counter,
},
});
The namespace provides functions to build Transaction objects for each method of a program.
program.transaction.<method>(...args, ctx);
args - The positional arguments for the program. The type and number
of these arguments depend on the program being used.ctx - Context non-argument parameters to pass to the method.
Always the last parameter in the method call.To create an instruction for the increment method above,
const tx = await program.transaction.increment({
accounts: {
counter,
},
});
Coder for serializing requests.
IDL in camelCase format to work in TypeScript.
See rawIdl field if you need the original IDL.
Address of the program.
Wallet and network provider.
Invokes the given callback every time the given event is emitted.
The PascalCase name of the event, provided by the IDL.
The function to invoke whenever the event is emitted from program logs.
Unsubscribes from the given eventName.
Generates a Program client by fetching the IDL from the network.
In order to use this method, an IDL must have been previously initialized
via the anchor CLI's anchor idl init command.
Fetches an idl from the blockchain.
In order to use this method, an IDL must have been previously initialized
via the anchor CLI's anchor idl init command.
Generated using TypeDoc
Program
Program provides the IDL deserialized client representation of an Anchor program.
This API is the one stop shop for all things related to communicating with on-chain programs. Among other things, one can send transactions, fetch deserialized accounts, decode instruction data, subscribe to account changes, and listen to events.
In addition to field accessors and methods, the object provides a set of dynamically generated properties, also known as namespaces, that map one-to-one to program methods and accounts. These namespaces generally can be used as follows:
Usage
API specifics are namespace dependent. The examples used in the documentation below will refer to the two counter examples found here.