Class ArkadeContract<P>

constructor

• new ArkadeContract<P extends Program = Program>(
      client: Arkade,
      program: P,
      args?: Record<string, ArkadeParamValue>,
      keys?: ProgramKeys,
  ): ArkadeContract<P>

  Type Parameters

  • P extends Program = Program

  Parameters

  • client: Arkade
  • program: P
  • args: Record<string, ArkadeParamValue> = {}
  • Optionalkeys: ProgramKeys

  Returns ArkadeContract<P>

Readonlyargs

Readonlyclient

Readonlykeys

Readonlyprogram

ReadonlytapTree

ReadonlyvtxoScript

address

• get address(): string

  Arkade funding address.

  Returns string

functions

• get functions(): ContractFunctions<P>

  Callable spending paths: contract.functions.<name>(...args). Strongly typed from the program's literal type — each function's argument types are derived from its inputs descriptors (see ContractFunctions).

  Returns ContractFunctions<P>

pkScript

• get pkScript(): Uint8Array

  Taproot output script.

  Returns Uint8Array

getBalance

• getBalance(): Promise<bigint>

  Total spendable balance (requires an indexer).

  Returns Promise<bigint>

getUtxos

• getUtxos(): Promise<VirtualCoin[]>

  Spendable VTXOs locked by this contract.

  When a contractManager is configured and this contract is registered, reads the repository-backed state (offline-first, kept fresh by the contract watcher). Otherwise falls back to a direct indexer query.

  Returns Promise<VirtualCoin[]>

leafScript

• leafScript(index: number): TapLeafScript

  Resolve the TapLeafScript for a spending path by its index.

  Parameters

  • index: number

  Returns TapLeafScript

register

• register(
      options?: { label?: string; metadata?: Record<string, unknown> },
  ): Promise<Contract>

  Persist this contract through the wallet's IContractManager so it is tracked like any other contract type: stored in the contract repository, watched for VTXO events, counted in repository-backed balances, and re-derivable offline via the "arkade" contract handler. Idempotent — re-registering the same script is a no-op.

  Parameters

  • Optionaloptions: { label?: string; metadata?: Record<string, unknown> }

  Returns Promise<Contract>

toContractParams

• toContractParams(): {
      address: string;
      params: Record<string, string>;
      script: string;
      type: string;
  }

  The createContract payload for this contract — the serialized program, args and keys plus the derived script/address. Useful when registering through a manager the client does not hold.

  Returns {
      address: string;
      params: Record<string, string>;
      script: string;
      type: string;
  }

StaticfromContract

• fromContract(client: Arkade, contract: Contract): ArkadeContract

  Rebuild a callable contract from a persisted "arkade" contract row (see ArkadeContract.register). The stored keys are used for compilation — not the client's current ones — so the derived script and address stay identical to the registered contract even after a server signer rotation.

  Parameters

  • client: Arkade
  • contract: Contract

  Returns ArkadeContract