diff --git a/motoko/evm_block_explorer/README.md b/motoko/evm_block_explorer/README.md
index 4bac2c9d4..f7c811d7c 100644
--- a/motoko/evm_block_explorer/README.md
+++ b/motoko/evm_block_explorer/README.md
@@ -6,6 +6,8 @@
 
 The EVM Block Explorer example demonstrates how an ICP canister can fetch block data directly from Ethereum and other EVM-compatible chains. Using HTTPS outcalls via the [EVM RPC canister](https://github.com/dfinity/evm-rpc-canister), canisters on ICP can read on-chain data without a bridge or oracle. The same pattern applies to any EVM-compatible chain supported by the EVM RPC canister.
 
+The backend reaches the EVM RPC canister through the typed import `import EvmRpc "canister:evm_rpc"` in `backend/EvmRpcApi.mo` — no RPC actor type is hand-written. The import is typed against the EVM RPC canister's committed Candid interface (`candid/evm_rpc.did`), and the `--actor-env-alias` flag in `mops.toml` binds it to the `PUBLIC_CANISTER_ID:evm_rpc` environment variable that icp-cli injects (the local `evm_rpc` canister when developing, the shared `7hfb6-caaaa-aaaar-qadga-cai` on mainnet). The principal is resolved at canister install/upgrade; no principal is compiled into the Wasm, so the same artifact runs in every environment.
+
 <!--
 ## Deploying from ICP Ninja
 
@@ -66,6 +68,23 @@ If you modify the backend's public API, regenerate the `.did` file:
 mops generate candid backend
 ```
 
+`candid/evm_rpc.did` is the **EVM RPC canister's own interface**, not the backend's — the `canister:evm_rpc` import is typed against it. The `candid/` directory holds the interfaces of external canisters this project calls (as opposed to `backend/backend.did`, which is this project's own interface). These are not produced by `mops generate candid` — each is the Candid interface of an external canister. To refresh one (e.g. after bumping the EVM RPC release), get it straight from the canister with either of:
+
+**From mainnet** — the live shared EVM RPC canister. One command, no files to handle:
+
+```bash
+icp canister metadata 7hfb6-caaaa-aaaar-qadga-cai candid:service -e ic > candid/evm_rpc.did
+```
+
+**From the pinned Wasm** — matches exactly what deploys locally. The Wasm is the pre-built artifact pinned in this project's `icp.yaml` (the `evm_rpc` canister's `build.steps[].url`); download and unpack it, then extract its interface:
+
+```bash
+curl -sSL https://github.com/dfinity/evm-rpc-canister/releases/download/evm_rpc-v2.8.0/evm_rpc.wasm.gz | gunzip > evm_rpc.wasm
+ic-wasm evm_rpc.wasm metadata candid:service > candid/evm_rpc.did
+```
+
+Both give the same interface as long as `icp.yaml` pins the release that is live on mainnet.
+
 ## RPC providers and API keys
 
 The example uses [PublicNode](https://ethereum-rpc.publicnode.com) by default — a free, no-registration provider that works out of the box locally and on mainnet. This is sufficient for getting started and automated testing.
diff --git a/motoko/evm_block_explorer/backend/EvmRpcApi.mo b/motoko/evm_block_explorer/backend/EvmRpcApi.mo
index 7962437fe..80948c0f6 100644
--- a/motoko/evm_block_explorer/backend/EvmRpcApi.mo
+++ b/motoko/evm_block_explorer/backend/EvmRpcApi.mo
@@ -1,179 +1,31 @@
-import Runtime "mo:core/Runtime";
+import EvmRpc "canister:evm_rpc";
 
 module {
-  // Inline actor type for the EVM RPC canister, exposing only eth_getBlockByNumber.
-  // Full Candid interface: https://github.com/dfinity/evm-rpc-canister/blob/main/candid/evm_rpc.did
+  // The EVM RPC canister is imported by name via `canister:evm_rpc`, typed
+  // against candid/evm_rpc.did — so the request/response types below are the
+  // canister's own (e.g. EvmRpc.Block, EvmRpc.RpcServices), not hand-written.
+  // icp-cli injects its principal as PUBLIC_CANISTER_ID:evm_rpc at deploy time;
+  // the mops.toml `--actor-env-alias` flag binds the import to that variable.
 
-  public type Block = {
-    miner : Text;
-    totalDifficulty : ?Nat;
-    receiptsRoot : Text;
-    stateRoot : Text;
-    hash : Text;
-    difficulty : ?Nat;
-    size : Nat;
-    uncles : [Text];
-    baseFeePerGas : ?Nat;
-    extraData : Text;
-    transactionsRoot : ?Text;
-    sha3Uncles : Text;
-    nonce : Nat;
-    number : Nat;
-    timestamp : Nat;
-    transactions : [Text];
-    gasLimit : Nat;
-    logsBloom : Text;
-    parentHash : Text;
-    gasUsed : Nat;
-    mixHash : Text;
-  };
-
-  type BlockTag = {
-    #Earliest;
-    #Safe;
-    #Finalized;
-    #Latest;
-    #Number : Nat;
-    #Pending;
-  };
-
-  type HttpHeader = { value : Text; name : Text };
-  type RpcApi = { url : Text; headers : ?[HttpHeader] };
-
-  type EthMainnetService = {
-    #Alchemy;
-    #Ankr;
-    #BlockPi;
-    #Cloudflare;
-    #PublicNode;
-    #Llama;
-  };
-
-  type EthSepoliaService = {
-    #Alchemy;
-    #Ankr;
-    #BlockPi;
-    #PublicNode;
-    #Sepolia;
-  };
-
-  type L2MainnetService = {
-    #Alchemy;
-    #Ankr;
-    #BlockPi;
-    #PublicNode;
-    #Llama;
-  };
-
-  type RpcServices = {
-    #Custom : { chainId : Nat64; services : [RpcApi] };
-    #EthSepolia : ?[EthSepoliaService];
-    #EthMainnet : ?[EthMainnetService];
-    #ArbitrumOne : ?[L2MainnetService];
-    #BaseMainnet : ?[L2MainnetService];
-    #OptimismMainnet : ?[L2MainnetService];
-  };
-
-  type RpcService = {
-    #Provider : Nat64;
-    #Custom : RpcApi;
-    #EthSepolia : EthSepoliaService;
-    #EthMainnet : EthMainnetService;
-    #ArbitrumOne : L2MainnetService;
-    #BaseMainnet : L2MainnetService;
-    #OptimismMainnet : L2MainnetService;
-  };
-
-  type RejectionCode = {
-    #NoError;
-    #CanisterError;
-    #SysTransient;
-    #DestinationInvalid;
-    #Unknown;
-    #SysFatal;
-    #CanisterReject;
-  };
-
-  type JsonRpcError = { code : Int64; message : Text };
-
-  type ProviderError = {
-    #TooFewCycles : { expected : Nat; received : Nat };
-    #MissingRequiredProvider;
-    #ProviderNotFound;
-    #NoPermission;
-    #InvalidRpcConfig : Text;
-  };
-
-  type HttpOutcallError = {
-    #IcError : { code : RejectionCode; message : Text };
-    #InvalidHttpJsonRpcResponse : { status : Nat16; body : Text; parsingError : ?Text };
-  };
-
-  type ValidationError = {
-    #Custom : Text;
-    #InvalidHex : Text;
-  };
-
-  type RpcError = {
-    #JsonRpcError : JsonRpcError;
-    #ProviderError : ProviderError;
-    #ValidationError : ValidationError;
-    #HttpOutcallError : HttpOutcallError;
-  };
-
-  type GetBlockByNumberResult = { #Ok : Block; #Err : RpcError };
-
-  type MultiGetBlockByNumberResult = {
-    #Consistent : GetBlockByNumberResult;
-    #Inconsistent : [(RpcService, GetBlockByNumberResult)];
-  };
-
-  // Controls how the EVM RPC canister aggregates responses from multiple providers.
-  // - responseSizeEstimate: hint for the expected response size in bytes (affects cycles cost).
-  //   Leave null to use the canister's built-in default.
-  // - responseConsensus: how providers must agree before a result is accepted.
-  //   #Equality requires all providers to return identical responses (default).
-  //   #Threshold { total; min } requires at least `min` out of `total` providers to agree.
-  //   Leave null to use #Equality.
-  // Pass null for the entire RpcConfig to use all defaults — this is the right choice for most callers.
-  type ConsensusStrategy = {
-    #Equality;
-    #Threshold : { total : ?Nat; min : Nat };
-  };
-  type RpcConfig = { responseSizeEstimate : ?Nat64; responseConsensus : ?ConsensusStrategy };
-
-  type EvmRpcActor = actor {
-    eth_getBlockByNumber : (RpcServices, ?RpcConfig, BlockTag) -> async MultiGetBlockByNumberResult;
-  };
-
-  // The result type exposed to the main actor — matches the Rust variant names for cross-language consistency.
-  public type EvmBlockResult = { #Ok : Block; #Err : Text };
-
-  // Returns the EVM RPC canister actor, resolved at runtime from the PUBLIC_CANISTER_ID:evm_rpc
-  // environment variable. icp-cli sets this automatically at deploy time:
-  //   - locally: the principal of the locally deployed evm_rpc canister
-  //   - on ICP mainnet (ic environment): 7hfb6-caaaa-aaaar-qadga-cai
-  func evmRpc<system>() : EvmRpcActor {
-    let ?id = Runtime.envVar<system>("PUBLIC_CANISTER_ID:evm_rpc") else
-      Runtime.trap("PUBLIC_CANISTER_ID:evm_rpc not set — run icp deploy");
-    actor(id) : EvmRpcActor;
-  };
+  // The result type exposed to the main actor — matches the Rust variant names
+  // for cross-language consistency, and carries the RPC canister's Block type.
+  public type EvmBlockResult = { #Ok : EvmRpc.Block; #Err : Text };
 
   // Fetches the Ethereum mainnet block at the given height.
   // Uses PublicNode by default — no API key required, works locally and on mainnet.
   // For production deployments requiring premium providers (Alchemy, Ankr, BlockPi),
   // configure API keys via the EVM RPC canister, then pass null to use all configured
   // providers for better consensus: #EthMainnet(null)
-  public func getBlock<system>(height : Nat) : async EvmBlockResult {
-    let services : RpcServices = #EthMainnet(?[#PublicNode]);
+  public func getBlock(height : Nat) : async EvmBlockResult {
+    let services : EvmRpc.RpcServices = #EthMainnet(?[#PublicNode]);
 
     // To query a different chain, use #Custom instead:
-    // let services : RpcServices = #Custom {
+    // let services : EvmRpc.RpcServices = #Custom {
     //   chainId = 8453; // Base Mainnet — see https://chainlist.org/ for chain IDs
     //   services = [{ url = "https://base-rpc.publicnode.com"; headers = null }];
     // };
 
-    let result = await (with cycles = 10_000_000_000) evmRpc<system>().eth_getBlockByNumber(services, null, #Number height);
+    let result = await (with cycles = 10_000_000_000) EvmRpc.eth_getBlockByNumber(services, null, #Number height);
 
     switch result {
       case (#Consistent(#Ok block)) { #Ok block };
diff --git a/motoko/evm_block_explorer/candid/evm_rpc.did b/motoko/evm_block_explorer/candid/evm_rpc.did
new file mode 100644
index 000000000..6ac5feb0e
--- /dev/null
+++ b/motoko/evm_block_explorer/candid/evm_rpc.did
@@ -0,0 +1,348 @@
+type Block = record {
+  miner : text;
+  totalDifficulty : opt nat;
+  receiptsRoot : text;
+  stateRoot : text;
+  hash : text;
+  difficulty : opt nat;
+  size : nat;
+  uncles : vec text;
+  baseFeePerGas : opt nat;
+  extraData : text;
+  transactionsRoot : opt text;
+  sha3Uncles : text;
+  nonce : nat;
+  number : nat;
+  timestamp : nat;
+  transactions : vec text;
+  gasLimit : nat;
+  logsBloom : text;
+  parentHash : text;
+  gasUsed : nat;
+  mixHash : text;
+};
+type BlockTag = variant {
+  Earliest;
+  Safe;
+  Finalized;
+  Latest;
+  Number : nat;
+  Pending;
+};
+type EthMainnetService = variant {
+  Alchemy;
+  Ankr;
+  BlockPi;
+  Cloudflare;
+  PublicNode;
+  Llama;
+};
+type EthSepoliaService = variant {
+  Alchemy;
+  Ankr;
+  BlockPi;
+  PublicNode;
+  Sepolia;
+};
+type L2MainnetService = variant {
+  Alchemy;
+  Ankr;
+  BlockPi;
+  PublicNode;
+  Llama;
+};
+type FeeHistory = record {
+  reward : vec vec nat;
+  gasUsedRatio : vec float64;
+  oldestBlock : nat;
+  baseFeePerGas : vec nat;
+};
+type FeeHistoryArgs = record {
+  blockCount : nat;
+  newestBlock : BlockTag;
+  rewardPercentiles : opt vec nat8;
+};
+type GetLogsArgs = record {
+  fromBlock : opt BlockTag;
+  toBlock : opt BlockTag;
+  addresses : vec text;
+  topics : opt vec Topic;
+};
+type GetTransactionCountArgs = record { address : text; block : BlockTag };
+type CallArgs = record {
+  transaction : TransactionRequest;
+  block : opt BlockTag;
+};
+type TransactionRequest = record {
+  "type" : opt text;
+  nonce : opt nat;
+  to : opt text;
+  from : opt text;
+  gas : opt nat;
+  value : opt nat;
+  input : opt text;
+  gasPrice : opt nat;
+  maxPriorityFeePerGas : opt nat;
+  maxFeePerGas : opt nat;
+  maxFeePerBlobGas : opt nat;
+  accessList: opt vec AccessListEntry;
+  blobVersionedHashes : opt vec text;
+  blobs : opt vec text;
+  chainId : opt nat;
+};
+type AccessListEntry = record {
+  address : text;
+  storageKeys : vec text;
+};
+type HttpHeader = record { value : text; name : text };
+type HttpOutcallError = variant {
+  IcError : record { code : RejectionCode; message : text };
+  InvalidHttpJsonRpcResponse : record {
+    status : nat16;
+    body : text;
+    parsingError : opt text;
+  };
+};
+type InstallArgs = record {
+  demo : opt bool;
+  manageApiKeys : opt vec principal;
+  logFilter : opt LogFilter;
+  overrideProvider : opt OverrideProvider;
+  nodesInSubnet : opt nat32;
+};
+type Regex = text;
+type LogFilter = variant {
+  ShowAll;
+  HideAll;
+  ShowPattern : Regex;
+  HidePattern : Regex;
+};
+type RegexSubstitution = record {
+  pattern : Regex;
+  replacement: text;
+};
+// Override resolved provider.
+// Useful for testing with a local Ethereum developer environment such as foundry.
+type OverrideProvider = record {
+  overrideUrl : opt RegexSubstitution
+};
+type JsonRpcError = record { code : int64; message : text };
+type LogEntry = record {
+  transactionHash : opt text;
+  blockNumber : opt nat;
+  data : text;
+  blockHash : opt text;
+  transactionIndex : opt nat;
+  topics : vec text;
+  address : text;
+  logIndex : opt nat;
+  removed : bool;
+};
+type MultiFeeHistoryResult = variant {
+  Consistent : FeeHistoryResult;
+  Inconsistent : vec record { RpcService; FeeHistoryResult };
+};
+type MultiGetBlockByNumberResult = variant {
+  Consistent : GetBlockByNumberResult;
+  Inconsistent : vec record { RpcService; GetBlockByNumberResult };
+};
+type MultiGetLogsResult = variant {
+  Consistent : GetLogsResult;
+  Inconsistent : vec record { RpcService; GetLogsResult };
+};
+type MultiGetTransactionCountResult = variant {
+  Consistent : GetTransactionCountResult;
+  Inconsistent : vec record { RpcService; GetTransactionCountResult };
+};
+type MultiGetTransactionReceiptResult = variant {
+  Consistent : GetTransactionReceiptResult;
+  Inconsistent : vec record { RpcService; GetTransactionReceiptResult };
+};
+type MultiSendRawTransactionResult = variant {
+  Consistent : SendRawTransactionResult;
+  Inconsistent : vec record { RpcService; SendRawTransactionResult };
+};
+type MultiCallResult = variant {
+  Consistent : CallResult;
+  Inconsistent : vec record { RpcService; CallResult };
+};
+type ProviderError = variant {
+  TooFewCycles : record { expected : nat; received : nat };
+  MissingRequiredProvider;
+  ProviderNotFound;
+  NoPermission;
+  InvalidRpcConfig : text ;
+};
+type ProviderId = nat64;
+type ChainId = nat64;
+type Provider = record {
+  providerId : ProviderId;
+  chainId : ChainId;
+  access : RpcAccess;
+  alias : opt RpcService;
+};
+type RpcAccess = variant {
+  Authenticated : record {
+    auth : RpcAuth;
+    publicUrl : opt text;
+  };
+  Unauthenticated : record {
+    publicUrl : text;
+  };
+};
+type RpcAuth = variant {
+  BearerToken : record { url : text };
+  UrlParameter : record { urlPattern : text };
+};
+type RejectionCode = variant {
+  NoError;
+  CanisterError;
+  SysTransient;
+  DestinationInvalid;
+  Unknown;
+  SysFatal;
+  CanisterReject;
+};
+type FeeHistoryResult = variant { Ok : FeeHistory; Err : RpcError };
+type GetBlockByNumberResult = variant { Ok : Block; Err : RpcError };
+type GetLogsResult = variant { Ok : vec LogEntry; Err : RpcError };
+type GetTransactionCountResult = variant { Ok : nat; Err : RpcError };
+type GetTransactionReceiptResult = variant {
+  Ok : opt TransactionReceipt;
+  Err : RpcError;
+};
+type SendRawTransactionResult = variant {
+  Ok : SendRawTransactionStatus;
+  Err : RpcError;
+};
+type CallResult = variant { Ok : text; Err : RpcError };
+type RequestResult = variant { Ok : text; Err : RpcError };
+type RequestCostResult = variant { Ok : nat; Err : RpcError };
+type RpcConfig = record { responseSizeEstimate : opt nat64; responseConsensus : opt ConsensusStrategy };
+type GetLogsRpcConfig = record { 
+    responseSizeEstimate : opt nat64;
+    responseConsensus : opt ConsensusStrategy;
+    // Most providers limit the block range that can be queried with `eth_getLogs`.
+    // By default, the chosen value should work for all supported JSON-RPC providers.
+    // This value could be changed if the providers are explicitly specified and they do support querying a larger block range.
+    // DEFAULT: 500
+    maxBlockRange : opt nat32;
+};
+type ConsensusStrategy = variant {
+  Equality;
+  Threshold : record {
+    // Total number of providers to be queried. Can be omitted, if that number can be inferred (e.g., providers are specified in the request).
+    total : opt nat8;
+    // Minimum number of providers that must return the same (non-error) result.
+    min : nat8;
+  };
+};
+type RpcError = variant {
+  JsonRpcError : JsonRpcError;
+  ProviderError : ProviderError;
+  ValidationError : ValidationError;
+  HttpOutcallError : HttpOutcallError;
+};
+type RpcApi = record { url : text; headers : opt vec HttpHeader };
+type RpcService = variant {
+  Provider : ProviderId;
+  Custom : RpcApi;
+  EthSepolia : EthSepoliaService;
+  EthMainnet : EthMainnetService;
+  ArbitrumOne : L2MainnetService;
+  BaseMainnet : L2MainnetService;
+  OptimismMainnet : L2MainnetService;
+};
+type RpcServices = variant {
+  Custom : record {
+    chainId : ChainId;
+    services : vec RpcApi;
+  };
+  EthSepolia : opt vec EthSepoliaService;
+  EthMainnet : opt vec EthMainnetService;
+  ArbitrumOne : opt vec L2MainnetService;
+  BaseMainnet : opt vec L2MainnetService;
+  OptimismMainnet : opt vec L2MainnetService;
+};
+type SendRawTransactionStatus = variant {
+  Ok : opt text;
+  NonceTooLow;
+  NonceTooHigh;
+  InsufficientFunds;
+};
+// Each topic is a `vec text` of topic data composed with the "or" operator.
+// See https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_getlogs
+type Topic = vec text;
+type TransactionReceipt = record {
+  to : opt text;
+  status : opt nat;
+  root : opt text;
+  transactionHash : text;
+  blockNumber : nat;
+  from : text;
+  logs : vec LogEntry;
+  blockHash : text;
+  "type" : text;
+  transactionIndex : nat;
+  effectiveGasPrice : nat;
+  logsBloom : text;
+  contractAddress : opt text;
+  gasUsed : nat;
+  cumulativeGasUsed : nat;
+};
+type ValidationError = variant {
+  Custom : text;
+  InvalidHex : text;
+};
+type JsonRequestResult = variant { Ok : text; Err : RpcError };
+type MultiJsonRequestResult = variant {
+  Consistent : JsonRequestResult;
+  Inconsistent : vec record { RpcService; JsonRequestResult };
+};
+service : (InstallArgs) -> {
+  // Call the `eth_feeHistory` RPC method and return the resulting fee history.
+  eth_feeHistory : (RpcServices, opt RpcConfig, FeeHistoryArgs) -> (MultiFeeHistoryResult);
+  eth_feeHistoryCyclesCost : (RpcServices, opt RpcConfig, FeeHistoryArgs) -> (RequestCostResult) query;
+
+  // Call the `eth_getBlockByNumber` RPC method and return the resulting block.
+  eth_getBlockByNumber : (RpcServices, opt RpcConfig, BlockTag) -> (MultiGetBlockByNumberResult);
+  eth_getBlockByNumberCyclesCost : (RpcServices, opt RpcConfig, BlockTag) -> (RequestCostResult) query;
+
+  // Call the `eth_getLogs` RPC method and return the resulting logs.
+  eth_getLogs : (RpcServices, opt GetLogsRpcConfig, GetLogsArgs) -> (MultiGetLogsResult);
+  eth_getLogsCyclesCost : (RpcServices, opt GetLogsRpcConfig, GetLogsArgs) -> (RequestCostResult) query;
+
+  // Call the `eth_getTransactionCount` RPC method and return the resulting transaction count.
+  eth_getTransactionCount : (RpcServices, opt RpcConfig, GetTransactionCountArgs) -> (MultiGetTransactionCountResult);
+  eth_getTransactionCountCyclesCost : (RpcServices, opt RpcConfig, GetTransactionCountArgs) -> (RequestCostResult) query;
+
+  // Call the `eth_getTransactionReceipt` RPC method and return the resulting transaction receipt.
+  eth_getTransactionReceipt : (RpcServices, opt RpcConfig, hash : text) -> (MultiGetTransactionReceiptResult);
+  eth_getTransactionReceiptCyclesCost : (RpcServices, opt RpcConfig, hash : text) -> (RequestCostResult) query;
+
+  // Call the `eth_sendRawTransaction` RPC method and return the resulting transaction hash.
+  eth_sendRawTransaction : (RpcServices, opt RpcConfig, rawSignedTransactionHex : text) -> (MultiSendRawTransactionResult);
+  eth_sendRawTransactionCyclesCost : (RpcServices, opt RpcConfig, rawSignedTransactionHex : text) -> (RequestCostResult) query;
+
+  // Call the `eth_call` RPC method and return the resulting output.
+  eth_call : (RpcServices, opt RpcConfig, CallArgs) -> (MultiCallResult);
+  eth_callCyclesCost : (RpcServices, opt RpcConfig, CallArgs) -> (RequestCostResult) query;
+
+  // Make a raw JSON-RPC request that sends the given JSON-RPC payload.
+  // This endpoint should be used instead of the `request` endpoint as it allows aggregating the responses from
+  // multiple providers. It also takes parameters consistent with `eth_*` endpoints, i.e. an `RpcServices` instead
+  // of an `RpcService`.
+  multi_request : (RpcServices, opt RpcConfig, json : text) -> (MultiJsonRequestResult);
+  multi_requestCyclesCost : (RpcServices, opt RpcConfig, json : text) -> (RequestCostResult) query;
+
+  // DEPRECATED: Use `multi_request` instead.
+  request : (RpcService, json : text, maxResponseBytes : nat64) -> (RequestResult);
+  // DEPRECATED: Use the specific `*RequestCost` endpoints instead (e.g. `eth_feeHistoryRequestCost`).
+  requestCost : (RpcService, json : text, maxResponseBytes : nat64) -> (RequestCostResult) query;
+
+  getNodesInSubnet : () -> (numberOfNodes : nat32) query;
+  getProviders : () -> (vec Provider) query;
+  getServiceProviderMap : () -> (vec record { RpcService; ProviderId }) query;
+  updateApiKeys : (vec record { ProviderId; opt text }) -> ();
+};
+
diff --git a/motoko/evm_block_explorer/mops.toml b/motoko/evm_block_explorer/mops.toml
index 12ae91caa..09583df88 100644
--- a/motoko/evm_block_explorer/mops.toml
+++ b/motoko/evm_block_explorer/mops.toml
@@ -13,3 +13,13 @@ args = ["--default-persistent-actors", "-W=M0236,M0237,M0223"]
 [canisters.backend]
 main = "backend/app.mo"
 candid = "backend/backend.did"
+# --actor-env-alias <alias> <envvar> <did-path>: resolve the `canister:evm_rpc`
+# import from the PUBLIC_CANISTER_ID:evm_rpc env var (injected by icp deploy),
+# typed against the EVM RPC canister's committed Candid interface — so no RPC
+# actor type is declared in the backend.
+# Per-canister args replace the global [moc].args, so repeat those flags here.
+args = [
+    "--default-persistent-actors",
+    "-W=M0236,M0237,M0223",
+    "--actor-env-alias", "evm_rpc", "PUBLIC_CANISTER_ID:evm_rpc", "candid/evm_rpc.did",
+]
diff --git a/motoko/ic-pos/README.md b/motoko/ic-pos/README.md
index 963f00632..d067eaef0 100644
--- a/motoko/ic-pos/README.md
+++ b/motoko/ic-pos/README.md
@@ -19,7 +19,7 @@ To let you try the full flow without spending real funds, this example uses the
 
 The backend is a single Motoko canister (`backend`). It stores per-merchant configuration (`getMerchant` / `updateMerchant`) and runs a [timer](https://internetcomputer.org/docs/motoko/timers) that monitors the ICRC-1 ledger for incoming transfers. When a payment is detected for a merchant that has notifications enabled, it emits a [canister log](https://internetcomputer.org/docs/building-apps/canister-management/logs) entry (observable with `icp canister logs backend`) noting where a notification would be sent.
 
-The ledger canister is resolved at runtime from the `PUBLIC_CANISTER_ID:icrc1_ledger` environment variable injected by icp-cli (the local ledger when developing, TICRC1 on mainnet).
+The backend reaches the ledger through the typed import `import Ledger "canister:icrc1_ledger"` — no ledger actor type is declared in the code. The import is typed against the ledger's committed Candid interface (`candid/icrc1_ledger.did`), and the `--actor-env-alias` flag in `mops.toml` binds it to the `PUBLIC_CANISTER_ID:icrc1_ledger` environment variable that icp-cli injects (the local ledger when developing, TICRC1 on mainnet). The principal is resolved at canister install/upgrade; no principal is compiled into the Wasm, so the same artifact runs in every environment.
 
 > **Notifications.** The original app sent email/SMS via an HTTPS outcall to a third-party service. This version instead logs where a notification would be sent. To implement real notifications, use [HTTPS outcalls](https://docs.internetcomputer.org/guides/backends/https-outcalls).
 >
@@ -104,6 +104,23 @@ The `backend/backend.did` file defines the backend's public interface; the front
 mops generate candid backend
 ```
 
+`candid/icrc1_ledger.did` is the **ledger's own interface**, not the backend's — the `canister:icrc1_ledger` import is typed against it. The `candid/` directory holds the interfaces of external canisters this project calls (as opposed to `backend/backend.did`, which is this project's own interface). These are not produced by `mops generate candid` — each is the Candid interface of an external canister. To refresh one (e.g. after bumping the ledger release), get it straight from the ledger with either of:
+
+**From mainnet** — the live shared ledger (TICRC1). One command, no files to handle:
+
+```bash
+icp canister metadata 3jkp5-oyaaa-aaaaj-azwqa-cai candid:service -e ic > candid/icrc1_ledger.did
+```
+
+**From the pinned Wasm** — matches exactly what deploys locally. The Wasm is the pre-built artifact pinned in this project's `icp.yaml` (the `icrc1_ledger` canister's `build.steps[].url`); download and unpack it, then extract its interface:
+
+```bash
+curl -sSL https://github.com/dfinity/ic/releases/download/ledger-suite-icrc-2026-03-09/ic-icrc1-ledger.wasm.gz | gunzip > ic-icrc1-ledger.wasm
+ic-wasm ic-icrc1-ledger.wasm metadata candid:service > candid/icrc1_ledger.did
+```
+
+Both give the same interface as long as `icp.yaml` pins the release that is live on mainnet.
+
 ## Possible improvements
 
 - A transaction detail page and pagination (currently only the latest transactions are shown).
diff --git a/motoko/ic-pos/backend/app.mo b/motoko/ic-pos/backend/app.mo
index df0b0660b..2f1b9db88 100644
--- a/motoko/ic-pos/backend/app.mo
+++ b/motoko/ic-pos/backend/app.mo
@@ -4,10 +4,10 @@ import Nat "mo:core/Nat";
 import Nat8 "mo:core/Nat8";
 import Nat64 "mo:core/Nat64";
 import Principal "mo:core/Principal";
-import Runtime "mo:core/Runtime";
 import Text "mo:core/Text";
 import Time "mo:core/Time";
 
+import Ledger "canister:icrc1_ledger";
 import Types "app.types";
 
 // This actor:
@@ -33,18 +33,10 @@ import Types "app.types";
 // (as this example's frontend already does).
 actor class Main(_startBlock : Nat) {
 
-  // Minimal subset of the ICRC-1 ledger interface this actor uses. Candid
-  // ignores wire fields not declared here, so only the read fields are listed.
-  type Account = { owner : Principal };
-  type Transfer = { to : Account; from : Account; amount : Nat };
-  type Transaction = { kind : Text; transfer : ?Transfer };
-  type GetTransactionsRequest = { start : Nat; length : Nat };
-  type GetTransactionsResponse = { transactions : [Transaction] };
-  type Ledger = actor {
-    get_transactions : GetTransactionsRequest -> async GetTransactionsResponse;
-    icrc1_symbol : () -> async Text;
-    icrc1_decimals : () -> async Nat8;
-  };
+  // The ledger is imported by name via `canister:icrc1_ledger`, typed against
+  // candid/icrc1_ledger.did — so no actor type is declared here. icp-cli
+  // injects its principal as PUBLIC_CANISTER_ID:icrc1_ledger at deploy time;
+  // the mops.toml `--actor-env-alias` flag binds the import to that variable.
 
   let merchantStore = Map.empty<Text, Types.Merchant>();
   // Next ledger block index to scan for incoming transfers.
@@ -83,20 +75,11 @@ actor class Main(_startBlock : Nat) {
     { status = 200; status_text = "OK"; data = ?merchant; error_text = null };
   };
 
-  // Resolve the ledger canister, injected as PUBLIC_CANISTER_ID:icrc1_ledger.
-  func ledger<system>() : Ledger {
-    switch (Runtime.envVar<system>("PUBLIC_CANISTER_ID:icrc1_ledger")) {
-      case (?id) actor (id) : Ledger;
-      case null Runtime.trap("PUBLIC_CANISTER_ID:icrc1_ledger not set — run icp deploy");
-    };
-  };
-
   // Fetch the token's symbol and decimals from the ledger once, then cache them.
-  func loadMetadataOnce<system>() : async () {
+  func loadMetadataOnce() : async () {
     if (metadataLoaded) return;
-    let l = ledger<system>();
-    tokenSymbol := await l.icrc1_symbol();
-    tokenDecimals := Nat8.toNat(await l.icrc1_decimals());
+    tokenSymbol := await Ledger.icrc1_symbol();
+    tokenDecimals := Nat8.toNat(await Ledger.icrc1_decimals());
     metadataLoaded := true;
   };
 
@@ -118,11 +101,11 @@ actor class Main(_startBlock : Nat) {
   system func timer(setGlobalTimer : Nat64 -> ()) : async () {
     let next = Nat64.fromIntWrap(Time.now()) + 20_000_000_000; // 20 seconds
     setGlobalTimer(next);
-    await notify<system>();
+    await notify();
   };
 
-  func notify<system>() : async () {
-    let response = await ledger<system>().get_transactions({ start = nextBlock; length = scanBatchSize });
+  func notify() : async () {
+    let response = await Ledger.get_transactions({ start = nextBlock; length = scanBatchSize });
     let txs = response.transactions;
     if (txs.size() == 0) return; // caught up; check again next tick
     nextBlock += txs.size();
@@ -142,7 +125,7 @@ actor class Main(_startBlock : Nat) {
               // use HTTPS outcalls —
               // https://docs.internetcomputer.org/guides/backends/https-outcalls
               if (merchant.email_notifications or merchant.phone_notifications) {
-                if (not metadataLoaded) await loadMetadataOnce<system>();
+                if (not metadataLoaded) await loadMetadataOnce();
                 Debug.print(
                   "Payment of " # formatAmount(transfer.amount) # " received by merchant '" # merchant.name #
                   "' from " # transfer.from.owner.toText() #
diff --git a/motoko/ic-pos/candid/icrc1_ledger.did b/motoko/ic-pos/candid/icrc1_ledger.did
new file mode 100644
index 000000000..39fe79e49
--- /dev/null
+++ b/motoko/ic-pos/candid/icrc1_ledger.did
@@ -0,0 +1,586 @@
+type BlockIndex = nat;
+type Subaccount = blob;
+// Number of nanoseconds since the UNIX epoch in UTC timezone.
+type Timestamp = nat64;
+// Number of nanoseconds between two [Timestamp]s.
+type Duration = nat64;
+type Tokens = nat;
+type TxIndex = nat;
+type Allowance = record { allowance : nat; expires_at : opt Timestamp };
+type AllowanceArgs = record { account : Account; spender : Account };
+type Approve = record {
+  fee : opt nat;
+  from : Account;
+  memo : opt blob;
+  created_at_time : opt Timestamp;
+  amount : nat;
+  expected_allowance : opt nat;
+  expires_at : opt Timestamp;
+  spender : Account
+};
+type ApproveArgs = record {
+  fee : opt nat;
+  memo : opt blob;
+  from_subaccount : opt blob;
+  created_at_time : opt Timestamp;
+  amount : nat;
+  expected_allowance : opt nat;
+  expires_at : opt Timestamp;
+  spender : Account
+};
+type ApproveError = variant {
+  GenericError : record { message : text; error_code : nat };
+  TemporarilyUnavailable;
+  Duplicate : record { duplicate_of : BlockIndex };
+  BadFee : record { expected_fee : nat };
+  AllowanceChanged : record { current_allowance : nat };
+  CreatedInFuture : record { ledger_time : Timestamp };
+  TooOld;
+  Expired : record { ledger_time : Timestamp };
+  InsufficientFunds : record { balance : nat }
+};
+type ApproveResult = variant { Ok : BlockIndex; Err : ApproveError };
+
+type HttpRequest = record {
+  url : text;
+  method : text;
+  body : blob;
+  headers : vec record { text; text }
+};
+type HttpResponse = record {
+  body : blob;
+  headers : vec record { text; text };
+  status_code : nat16
+};
+
+type Account = record {
+  owner : principal;
+  subaccount : opt Subaccount
+};
+
+type TransferArg = record {
+  from_subaccount : opt Subaccount;
+  to : Account;
+  amount : Tokens;
+  fee : opt Tokens;
+  memo : opt blob;
+  created_at_time : opt Timestamp
+};
+
+type TransferError = variant {
+  BadFee : record { expected_fee : Tokens };
+  BadBurn : record { min_burn_amount : Tokens };
+  InsufficientFunds : record { balance : Tokens };
+  TooOld;
+  CreatedInFuture : record { ledger_time : Timestamp };
+  TemporarilyUnavailable;
+  Duplicate : record { duplicate_of : BlockIndex };
+  GenericError : record { error_code : nat; message : text }
+};
+
+type TransferResult = variant {
+  Ok : BlockIndex;
+  Err : TransferError
+};
+
+// The value returned from the [icrc1_metadata] endpoint.
+type MetadataValue = variant {
+  Nat : nat;
+  Int : int;
+  Text : text;
+  Blob : blob
+};
+
+type FeatureFlags = record {
+  icrc2 : bool
+};
+
+// The initialization parameters of the Ledger
+type InitArgs = record {
+  minting_account : Account;
+  fee_collector_account : opt Account;
+  transfer_fee : nat;
+  decimals : opt nat8;
+  max_memo_length : opt nat16;
+  token_symbol : text;
+  token_name : text;
+  metadata : vec record { text; MetadataValue };
+  initial_balances : vec record { Account; nat };
+  feature_flags : opt FeatureFlags;
+  archive_options : record {
+    num_blocks_to_archive : nat64;
+    max_transactions_per_response : opt nat64;
+    trigger_threshold : nat64;
+    max_message_size_bytes : opt nat64;
+    cycles_for_archive_creation : opt nat64;
+    node_max_memory_size_bytes : opt nat64;
+    controller_id : principal;
+    more_controller_ids : opt vec principal
+  };
+  index_principal : opt principal
+};
+
+type ChangeFeeCollector = variant {
+  Unset;
+  SetTo : Account
+};
+
+type ChangeArchiveOptions = record {
+  num_blocks_to_archive : opt nat64;
+  max_transactions_per_response : opt nat64;
+  trigger_threshold : opt nat64;
+  max_message_size_bytes : opt nat64;
+  cycles_for_archive_creation : opt nat64;
+  node_max_memory_size_bytes : opt nat64;
+  controller_id : opt principal;
+  more_controller_ids : opt vec principal
+};
+
+type UpgradeArgs = record {
+  metadata : opt vec record { text; MetadataValue };
+  token_symbol : opt text;
+  token_name : opt text;
+  transfer_fee : opt nat;
+  change_fee_collector : opt ChangeFeeCollector;
+  max_memo_length : opt nat16;
+  feature_flags : opt FeatureFlags;
+  change_archive_options : opt ChangeArchiveOptions;
+  index_principal : opt principal
+};
+
+type LedgerArg = variant {
+  Init : InitArgs;
+  Upgrade : opt UpgradeArgs
+};
+
+type GetTransactionsRequest = record {
+  // The index of the first tx to fetch.
+  start : TxIndex;
+  // The number of transactions to fetch.
+  length : nat
+};
+
+type GetTransactionsResponse = record {
+  // The total number of transactions in the log.
+  log_length : nat;
+
+  // List of transaction that were available in the ledger when it processed the call.
+  //
+  // The transactions form a contiguous range, with the first transaction having index
+  // [first_index] (see below), and the last transaction having index
+  // [first_index] + len(transactions) - 1.
+  //
+  // The transaction range can be an arbitrary sub-range of the originally requested range.
+  transactions : vec Transaction;
+
+  // The index of the first transaction in [transactions].
+  // If the transaction vector is empty, the exact value of this field is not specified.
+  first_index : TxIndex;
+
+  // Encoding of instructions for fetching archived transactions whose indices fall into the
+  // requested range.
+  //
+  // For each entry `e` in [archived_transactions], `[e.from, e.from + len)` is a sub-range
+  // of the originally requested transaction range.
+  archived_transactions : vec record {
+    // The index of the first archived transaction you can fetch using the [callback].
+    start : TxIndex;
+
+    // The number of transactions you can fetch using the callback.
+    length : nat;
+
+    // The function you should call to fetch the archived transactions.
+    // The range of the transaction accessible using this function is given by [from]
+    // and [len] fields above.
+    callback : QueryArchiveFn
+  }
+};
+
+// A prefix of the transaction range specified in the [GetTransactionsRequest] request.
+type TransactionRange = record {
+  // A prefix of the requested transaction range.
+  // The index of the first transaction is equal to [GetTransactionsRequest.from].
+  //
+  // Note that the number of transactions might be less than the requested
+  // [GetTransactionsRequest.length] for various reasons, for example:
+  //
+  // 1. The query might have hit the replica with an outdated state
+  //    that doesn't have the whole range yet.
+  // 2. The requested range is too large to fit into a single reply.
+  //
+  // NOTE: the list of transactions can be empty if:
+  //
+  // 1. [GetTransactionsRequest.length] was zero.
+  // 2. [GetTransactionsRequest.from] was larger than the last transaction known to
+  //    the canister.
+  transactions : vec Transaction
+};
+
+// A function for fetching archived transaction.
+type QueryArchiveFn = func(GetTransactionsRequest) -> (TransactionRange) query;
+
+type Transaction = record {
+  burn : opt Burn;
+  kind : text;
+  mint : opt Mint;
+  approve : opt Approve;
+  fee_collector : opt FeeCollector;
+  timestamp : Timestamp;
+  transfer : opt Transfer
+};
+
+type FeeCollector = record {
+  caller : opt principal;
+  fee_collector : opt Account;
+  ts : opt nat64;
+  mthd : opt text
+};
+
+type Burn = record {
+  from : Account;
+  memo : opt blob;
+  created_at_time : opt Timestamp;
+  amount : nat;
+  spender : opt Account;
+  fee : opt nat
+};
+
+type Mint = record {
+  to : Account;
+  memo : opt blob;
+  created_at_time : opt Timestamp;
+  amount : nat;
+  fee : opt nat
+};
+
+type Transfer = record {
+  to : Account;
+  fee : opt nat;
+  from : Account;
+  memo : opt blob;
+  created_at_time : opt Timestamp;
+  amount : nat;
+  spender : opt Account
+};
+
+type Value = variant {
+  Blob : blob;
+  Text : text;
+  Nat : nat;
+  Nat64 : nat64;
+  Int : int;
+  Array : vec Value;
+  Map : Map
+};
+
+type Map = vec record { text; Value };
+
+type Block = Value;
+
+type GetBlocksArgs = record {
+  // The index of the first block to fetch.
+  start : BlockIndex;
+  // Max number of blocks to fetch.
+  length : nat
+};
+
+// A prefix of the block range specified in the [GetBlocksArgs] request.
+type BlockRange = record {
+  // A prefix of the requested block range.
+  // The index of the first block is equal to [GetBlocksArgs.start].
+  //
+  // Note that the number of blocks might be less than the requested
+  // [GetBlocksArgs.length] for various reasons, for example:
+  //
+  // 1. The query might have hit the replica with an outdated state
+  //    that doesn't have the whole range yet.
+  // 2. The requested range is too large to fit into a single reply.
+  //
+  // NOTE: the list of blocks can be empty if:
+  //
+  // 1. [GetBlocksArgs.length] was zero.
+  // 2. [GetBlocksArgs.start] was larger than the last block known to
+  //    the canister.
+  blocks : vec Block
+};
+
+// A function for fetching archived blocks.
+type QueryBlockArchiveFn = func(GetBlocksArgs) -> (BlockRange) query;
+
+// The result of a "get_blocks" call.
+type GetBlocksResponse = record {
+  // The index of the first block in "blocks".
+  // If the blocks vector is empty, the exact value of this field is not specified.
+  first_index : BlockIndex;
+
+  // The total number of blocks in the chain.
+  // If the chain length is positive, the index of the last block is `chain_len - 1`.
+  chain_length : nat64;
+
+  // System certificate for the hash of the latest block in the chain.
+  // Only present if `get_blocks` is called in a non-replicated query context.
+  certificate : opt blob;
+
+  // List of blocks that were available in the ledger when it processed the call.
+  //
+  // The blocks form a contiguous range, with the first block having index
+  // [first_block_index] (see below), and the last block having index
+  // [first_block_index] + len(blocks) - 1.
+  //
+  // The block range can be an arbitrary sub-range of the originally requested range.
+  blocks : vec Block;
+
+  // Encoding of instructions for fetching archived blocks.
+  archived_blocks : vec record {
+    // The index of the first archived block.
+    start : BlockIndex;
+
+    // The number of blocks that can be fetched.
+    length : nat;
+
+    // Callback to fetch the archived blocks.
+    callback : QueryBlockArchiveFn
+  }
+};
+
+// Certificate for the block at `block_index`.
+type DataCertificate = record {
+  certificate : opt blob;
+  hash_tree : blob
+};
+
+type StandardRecord = record { url : text; name : text };
+
+type TransferFromArgs = record {
+  spender_subaccount : opt Subaccount;
+  from : Account;
+  to : Account;
+  amount : Tokens;
+  fee : opt Tokens;
+  memo : opt blob;
+  created_at_time : opt Timestamp
+};
+
+type TransferFromResult = variant {
+  Ok : BlockIndex;
+  Err : TransferFromError
+};
+
+type TransferFromError = variant {
+  BadFee : record { expected_fee : Tokens };
+  BadBurn : record { min_burn_amount : Tokens };
+  InsufficientFunds : record { balance : Tokens };
+  InsufficientAllowance : record { allowance : Tokens };
+  TooOld;
+  CreatedInFuture : record { ledger_time : Timestamp };
+  Duplicate : record { duplicate_of : BlockIndex };
+  TemporarilyUnavailable;
+  GenericError : record { error_code : nat; message : text }
+};
+
+type ArchiveInfo = record {
+  canister_id : principal;
+  block_range_start : BlockIndex;
+  block_range_end : BlockIndex
+};
+
+type ICRC3Value = variant {
+  Blob : blob;
+  Text : text;
+  Nat : nat;
+  Int : int;
+  Array : vec ICRC3Value;
+  Map : vec record { text; ICRC3Value }
+};
+
+type GetArchivesArgs = record {
+  // The last archive seen by the client.
+  // The Ledger will return archives coming
+  // after this one if set, otherwise it
+  // will return the first archives.
+  from : opt principal
+};
+
+type GetArchivesResult = vec record {
+  // The id of the archive
+  canister_id : principal;
+
+  // The first block in the archive
+  start : nat;
+
+  // The last block in the archive
+  end : nat
+};
+
+type GetBlocksResult = record {
+  // Total number of blocks in the
+  // block log
+  log_length : nat;
+
+  blocks : vec record { id : nat; block : ICRC3Value };
+
+  archived_blocks : vec record {
+    args : vec GetBlocksArgs;
+    callback : func(vec GetBlocksArgs) -> (GetBlocksResult) query
+  }
+};
+
+type ICRC3DataCertificate = record {
+  // See https://internetcomputer.org/docs/current/references/ic-interface-spec#certification
+  certificate : blob;
+
+  // CBOR encoded hash_tree
+  hash_tree : blob
+};
+
+type icrc21_consent_message_metadata = record {
+  language : text;
+  utc_offset_minutes : opt int16
+};
+
+type icrc21_consent_message_spec = record {
+  metadata : icrc21_consent_message_metadata;
+  device_spec : opt variant {
+    GenericDisplay;
+    FieldsDisplay
+  }
+};
+
+type icrc21_consent_message_request = record {
+  method : text;
+  arg : blob;
+  user_preferences : icrc21_consent_message_spec
+};
+
+type Icrc21Value = variant {
+  TokenAmount : record {
+    decimals : nat8;
+    amount : nat64;
+    symbol : text
+  };
+  TimestampSeconds : record {
+    amount : nat64
+  };
+  DurationSeconds : record {
+    amount : nat64
+  };
+  Text : record {
+    content : text
+  }
+};
+
+type FieldsDisplay = record {
+  intent : text;
+  fields : vec record { text; Icrc21Value }
+};
+
+type icrc21_consent_message = variant {
+  GenericDisplayMessage : text;
+  FieldsDisplayMessage : FieldsDisplay
+};
+
+type icrc21_consent_info = record {
+  consent_message : icrc21_consent_message;
+  metadata : icrc21_consent_message_metadata
+};
+
+type icrc21_error_info = record {
+  description : text
+};
+
+type icrc21_error = variant {
+  UnsupportedCanisterCall : icrc21_error_info;
+  ConsentMessageUnavailable : icrc21_error_info;
+  InsufficientPayment : icrc21_error_info;
+
+  // Any error not covered by the above variants.
+  GenericError : record {
+    error_code : nat;
+    description : text
+  }
+};
+
+type icrc21_consent_message_response = variant {
+  Ok : icrc21_consent_info;
+  Err : icrc21_error
+};
+
+type GetAllowancesArgs = record {
+  from_account : opt Account;
+  prev_spender : opt Account;
+  take : opt nat
+};
+
+type Allowance103 = record {
+  from_account : Account;
+  to_spender : Account;
+  allowance : nat;
+  expires_at : opt nat64
+};
+
+type GetAllowancesError = variant {
+  AccessDenied : record {
+    reason : text
+  };
+  GenericError : record {
+    error_code : nat;
+    message : text
+  }
+};
+
+type icrc103_get_allowances_response = variant {
+  Ok : vec Allowance103;
+  Err : GetAllowancesError
+};
+
+type GetIndexPrincipalResult = variant {
+  Ok : principal;
+  Err : GetIndexPrincipalError
+};
+
+type GetIndexPrincipalError = variant {
+  IndexPrincipalNotSet;
+
+  // Any error not covered by the above variants.
+  GenericError : record {
+    error_code : nat;
+    description : text
+  }
+};
+
+service : (ledger_arg : LedgerArg) -> {
+  archives : () -> (vec ArchiveInfo) query;
+  get_transactions : (GetTransactionsRequest) -> (GetTransactionsResponse) query;
+  get_blocks : (GetBlocksArgs) -> (GetBlocksResponse) query;
+  get_data_certificate : () -> (DataCertificate) query;
+
+  icrc1_name : () -> (text) query;
+  icrc1_symbol : () -> (text) query;
+  icrc1_decimals : () -> (nat8) query;
+  icrc1_metadata : () -> (vec record { text; MetadataValue }) query;
+  icrc1_total_supply : () -> (Tokens) query;
+  icrc1_fee : () -> (Tokens) query;
+  icrc1_minting_account : () -> (opt Account) query;
+  icrc1_balance_of : (Account) -> (Tokens) query;
+  icrc1_transfer : (TransferArg) -> (TransferResult);
+  icrc1_supported_standards : () -> (vec StandardRecord) query;
+
+  icrc2_approve : (ApproveArgs) -> (ApproveResult);
+  icrc2_allowance : (AllowanceArgs) -> (Allowance) query;
+  icrc2_transfer_from : (TransferFromArgs) -> (TransferFromResult);
+
+  icrc3_get_archives : (GetArchivesArgs) -> (GetArchivesResult) query;
+  icrc3_get_tip_certificate : () -> (opt ICRC3DataCertificate) query;
+  icrc3_get_blocks : (vec GetBlocksArgs) -> (GetBlocksResult) query;
+  icrc3_supported_block_types : () -> (vec record { block_type : text; url : text }) query;
+
+  icrc21_canister_call_consent_message : (icrc21_consent_message_request) -> (icrc21_consent_message_response);
+  icrc10_supported_standards : () -> (vec record { name : text; url : text }) query;
+
+  icrc103_get_allowances : (GetAllowancesArgs) -> (icrc103_get_allowances_response) query;
+
+  icrc106_get_index_principal : () -> (GetIndexPrincipalResult) query;
+
+  is_ledger_ready : () -> (bool) query
+}
+
diff --git a/motoko/ic-pos/mops.toml b/motoko/ic-pos/mops.toml
index 0ebb52ffd..a77f8ba08 100644
--- a/motoko/ic-pos/mops.toml
+++ b/motoko/ic-pos/mops.toml
@@ -15,3 +15,13 @@ args = ["--default-persistent-actors", "-W=M0236,M0237,M0223"]
 [canisters.backend]
 main = "backend/app.mo"
 candid = "backend/backend.did"
+# --actor-env-alias <alias> <envvar> <did-path>: resolve the
+# `canister:icrc1_ledger` import from the PUBLIC_CANISTER_ID:icrc1_ledger env
+# var (injected by icp deploy), typed against the ledger's committed Candid
+# interface — so no ledger actor type is declared in the backend.
+# Per-canister args replace the global [moc].args, so repeat those flags here.
+args = [
+    "--default-persistent-actors",
+    "-W=M0236,M0237,M0223",
+    "--actor-env-alias", "icrc1_ledger", "PUBLIC_CANISTER_ID:icrc1_ledger", "candid/icrc1_ledger.did",
+]
diff --git a/motoko/llm_chatbot/README.md b/motoko/llm_chatbot/README.md
index 97b065e1c..3c90eff0c 100644
--- a/motoko/llm_chatbot/README.md
+++ b/motoko/llm_chatbot/README.md
@@ -4,7 +4,7 @@ This example demonstrates how an ICP canister can interact with a large language
 
 ## How it works
 
-The backend canister calls the [LLM canister](https://forum.dfinity.org/t/introducing-the-llm-canister-deploy-ai-agents-with-a-few-lines-of-code/41424)'s `v1_chat` endpoint directly (see `backend/app.mo`), without a helper library. It reads the LLM canister's principal from the `PUBLIC_CANISTER_ID:llm` environment variable. Locally, `icp deploy` deploys a copy of the LLM canister (backed by Ollama) and injects this variable automatically. On mainnet the shared LLM canister already exists, so `icp.yaml` sets the variable to its principal (`w36hm-eqaaa-aaaal-qr76a-cai`) for the `ic` environment.
+The backend canister calls the [LLM canister](https://forum.dfinity.org/t/introducing-the-llm-canister-deploy-ai-agents-with-a-few-lines-of-code/41424)'s `v1_chat` endpoint directly (see `backend/app.mo`), without a helper library. It reaches the canister through the typed import `import LLM "canister:llm"` — no LLM actor type is hand-written. The import is typed against the LLM canister's committed Candid interface (`candid/llm.did`), and the `--actor-env-alias` flag in `mops.toml` binds it to the `PUBLIC_CANISTER_ID:llm` environment variable. Locally, `icp deploy` deploys a copy of the LLM canister (backed by Ollama) and injects this variable automatically. On mainnet the shared LLM canister already exists, so `icp.yaml` sets the variable to its principal (`w36hm-eqaaa-aaaal-qr76a-cai`) for the `ic` environment. The principal is resolved at canister install/upgrade, so the same Wasm runs in both environments.
 
 ## Build and deploy from the command line
 
@@ -74,6 +74,23 @@ The `backend/backend.did` file defines the backend canister's public interface.
 mops generate candid backend
 ```
 
+`candid/llm.did` is the **LLM canister's own interface**, not the backend's — the `canister:llm` import is typed against it. The `candid/` directory holds the interfaces of external canisters this project calls (as opposed to `backend/backend.did`, which is this project's own interface). These are not produced by `mops generate candid` — each is the Candid interface of an external canister. To refresh one (e.g. after bumping the LLM release), get it straight from the canister with either of:
+
+**From mainnet** — the live shared LLM canister. One command, no files to handle:
+
+```bash
+icp canister metadata w36hm-eqaaa-aaaal-qr76a-cai candid:service -e ic > candid/llm.did
+```
+
+**From the pinned Wasm** — matches exactly what deploys locally. The Wasm is the pre-built artifact pinned in this project's `icp.yaml` (the `llm` canister's `build.steps[].url`); download it, then extract its interface (the LLM Wasm is not gzipped):
+
+```bash
+curl -sSL https://github.com/dfinity/llm/releases/download/v0.3.1/llm-canister.wasm -o llm-canister.wasm
+ic-wasm llm-canister.wasm metadata candid:service > candid/llm.did
+```
+
+Both give the same interface as long as `icp.yaml` pins the release that is live on mainnet.
+
 ## Security considerations and best practices
 
 If you base your application on this example, familiarize yourself with the [security best practices](https://docs.internetcomputer.org/guides/security/overview) for developing on ICP. This example may not implement all best practices.
diff --git a/motoko/llm_chatbot/backend/app.mo b/motoko/llm_chatbot/backend/app.mo
index ca99e833c..f525f3463 100644
--- a/motoko/llm_chatbot/backend/app.mo
+++ b/motoko/llm_chatbot/backend/app.mo
@@ -1,15 +1,17 @@
-import Runtime "mo:core/Runtime";
+import LLM "canister:llm";
 
-// The backend calls the LLM canister's `v1_chat` endpoint directly. The request
-// and response types below mirror that canister's Candid interface:
-// https://dashboard.internetcomputer.org/canister/w36hm-eqaaa-aaaal-qr76a-cai#interface
+// The backend calls the LLM canister's `v1_chat` endpoint through the typed
+// `canister:llm` import — no LLM actor type is declared here. The import is
+// typed against the LLM canister's committed Candid interface (candid/llm.did),
+// and the mops.toml `--actor-env-alias` flag binds it to the
+// PUBLIC_CANISTER_ID:llm env var that icp-cli injects.
 //
-// LLM canister interface:
-//   v1_chat : (chat_request_v1) -> (chat_response_v1)
+// The message types below are this backend's own public API (the frontend
+// generates its bindings from them); they are structurally identical to the LLM
+// canister's `chat_message_v1` / `assistant_message`, so values flow straight
+// into `LLM.v1_chat` without conversion.
 //
-// This example does not use tools, so the optional `tools` field is omitted from
-// the request — Candid decodes an absent optional record field as `null` on the
-// canister side, keeping the call wire-compatible.
+// This example does not use tools, so `tools` is passed as null.
 actor {
 
   // A message in a chat. Mirrors `chat_message_v1` in the LLM canister interface.
@@ -41,36 +43,17 @@ actor {
     value : Text;
   };
 
-  // Request/response for `v1_chat`. The request omits the optional `tools` field
-  // (see the note above).
-  type Request = {
-    model : Text;
-    messages : [ChatMessage];
-  };
-  type Response = { message : AssistantMessage };
-  type LlmActor = actor { v1_chat : (Request) -> async Response };
-
   // The model this example uses. The LLM canister identifies models by string;
   // other available models include "qwen3:32b" and "llama4-scout".
   let model = "llama3.1:8b";
 
-  // The LLM canister ID is injected as PUBLIC_CANISTER_ID:llm at deploy time:
-  //   local: auto-injected by icp-cli after deploying the pre-built llm canister
-  //   ic:    set explicitly in icp.yaml to the shared mainnet LLM canister
-  //
-  // See icp.yaml for the environment configuration.
-  func llmCanister<system>() : LlmActor {
-    let ?id = Runtime.envVar<system>("PUBLIC_CANISTER_ID:llm") else Runtime.trap("PUBLIC_CANISTER_ID:llm not set — run icp deploy");
-    actor (id) : LlmActor;
-  };
-
-  func sendChat<system>(messages : [ChatMessage]) : async AssistantMessage {
-    let response = await llmCanister<system>().v1_chat({ model; messages });
+  func sendChat(messages : [ChatMessage]) : async AssistantMessage {
+    let response = await LLM.v1_chat({ model; messages; tools = null });
     response.message;
   };
 
   public func prompt(prompt : Text) : async Text {
-    let message = await sendChat<system>([#user({ content = prompt })]);
+    let message = await sendChat([#user({ content = prompt })]);
     switch (message.content) {
       case (?text) text;
       case null "";
@@ -78,7 +61,7 @@ actor {
   };
 
   public func chat(messages : [ChatMessage]) : async Text {
-    let message = await sendChat<system>(messages);
+    let message = await sendChat(messages);
     switch (message.content) {
       case (?text) text;
       case null "";
diff --git a/motoko/llm_chatbot/candid/llm.did b/motoko/llm_chatbot/candid/llm.did
new file mode 100644
index 000000000..6a72a1da6
--- /dev/null
+++ b/motoko/llm_chatbot/candid/llm.did
@@ -0,0 +1,56 @@
+type assistant_message = record {
+  content : opt text;
+  tool_calls : vec record {
+    id : text;
+    function : record { name : text; arguments : vec tool_call_argument };
+  };
+};
+type backend_config = variant {
+  worker;
+  ollama;
+  openrouter : record { api_key : text };
+};
+type chat_message_v0 = record {
+  content : text;
+  role : variant { user; assistant; system };
+};
+type chat_message_v1 = variant {
+  tool : record { content : text; tool_call_id : text };
+  user : record { content : text };
+  assistant : assistant_message;
+  system : record { content : text };
+};
+type chat_request_v0 = record { model : text; messages : vec chat_message_v0 };
+type chat_request_v1 = record {
+  model : text;
+  tools : opt vec tool;
+  messages : vec chat_message_v1;
+};
+type chat_response_v1 = record { message : assistant_message };
+type config = record {
+  workers_whitelist : variant { all; some : vec principal };
+  api_disabled : bool;
+};
+type parameters = record {
+  "type" : text;
+  properties : opt vec property;
+  required : opt vec text;
+};
+type property = record {
+  enum : opt vec text;
+  name : text;
+  "type" : text;
+  description : opt text;
+};
+type tool = variant {
+  function : record {
+    name : text;
+    parameters : opt parameters;
+    description : opt text;
+  };
+};
+type tool_call_argument = record { value : text; name : text };
+service : {
+  v0_chat : (chat_request_v0) -> (text);
+  v1_chat : (chat_request_v1) -> (chat_response_v1);
+}
diff --git a/motoko/llm_chatbot/mops.toml b/motoko/llm_chatbot/mops.toml
index 0ebb52ffd..f9ab51825 100644
--- a/motoko/llm_chatbot/mops.toml
+++ b/motoko/llm_chatbot/mops.toml
@@ -15,3 +15,13 @@ args = ["--default-persistent-actors", "-W=M0236,M0237,M0223"]
 [canisters.backend]
 main = "backend/app.mo"
 candid = "backend/backend.did"
+# --actor-env-alias <alias> <envvar> <did-path>: resolve the `canister:llm`
+# import from the PUBLIC_CANISTER_ID:llm env var (injected by icp deploy), typed
+# against the LLM canister's committed Candid interface — so no LLM actor type
+# is declared in the backend.
+# Per-canister args replace the global [moc].args, so repeat those flags here.
+args = [
+    "--default-persistent-actors",
+    "-W=M0236,M0237,M0223",
+    "--actor-env-alias", "llm", "PUBLIC_CANISTER_ID:llm", "candid/llm.did",
+]