starknet 11.0.2 → 11.1.0

package/dist/index.d.ts

@@ -243,25 +243,43 @@ type LegacyEvent = {
     keys: CONTRACT.EVENT_FIELD[];
 };
 
-/** LEGACY CONTRACT */
+/** Cairo Assembly .casm */
+type CairoAssembly = {
+    prime: string;
+    compiler_version: string;
+    bytecode: ByteCode;
+    hints: any[];
+    pythonic_hints?: PythonicHints;
+    bytecode_segment_lengths?: number[];
+    entry_points_by_type: EntryPointsByType;
+};
+/** COMPILED CONTRACT */
 /**
- * format produced after compressing 'program' property
+ * format produced after starknet-compile .cairo to .json
+ *
+ * sierra_program is hex array
  */
-type LegacyContractClass = {
-    program: CompressedProgram;
-    entry_points_by_type: EntryPointsByType;
+type CompiledSierra = {
+    sierra_program: ByteCode;
+    sierra_program_debug_info?: SierraProgramDebugInfo;
+    contract_class_version: string;
+    entry_points_by_type: SierraEntryPointsByType;
     abi: Abi;
 };
 /**
- * format produced after compiling .cairo to .json
+ * format produced after compressing 'sierra_program', stringifies 'abi' property and omit sierra_program_debug_info
+ *
+ * CompressedCompiledSierra
  */
-type LegacyCompiledContract = Omit<LegacyContractClass, 'program'> & {
-    program: Program;
+type SierraContractClass = Omit<CompiledSierra, 'abi' | 'sierra_program' | 'sierra_program_debug_info'> & {
+    sierra_program: string;
+    abi: string;
 };
+type CompiledSierraCasm = CairoAssembly;
 /** SUBTYPES */
+type ByteCode = string[];
+type PythonicHints = [number, string[]][];
 type Builtins = string[];
-type CompressedProgram = string;
-type Hint = Record<string, unknown>;
 type EntryPointsByType = {
     CONSTRUCTOR: ContractEntryPointFields[];
     EXTERNAL: ContractEntryPointFields[];
@@ -272,6 +290,39 @@ type ContractEntryPointFields = {
     offset: string | number;
     builtins?: Builtins;
 };
+type SierraProgramDebugInfo = {
+    type_names: [number, string][];
+    libfunc_names: [number, string][];
+    user_func_names: [number, string][];
+};
+type SierraEntryPointsByType = {
+    CONSTRUCTOR: SierraContractEntryPointFields[];
+    EXTERNAL: SierraContractEntryPointFields[];
+    L1_HANDLER: SierraContractEntryPointFields[];
+};
+type SierraContractEntryPointFields = {
+    selector: string;
+    function_idx: number;
+};
+
+/** LEGACY CONTRACT */
+/**
+ * format produced after compressing 'program' property
+ */
+type LegacyContractClass = {
+    program: CompressedProgram;
+    entry_points_by_type: EntryPointsByType;
+    abi: Abi;
+};
+/**
+ * format produced after compiling .cairo to .json
+ */
+type LegacyCompiledContract = Omit<LegacyContractClass, 'program'> & {
+    program: Program;
+};
+/** SUBTYPES */
+type CompressedProgram = string;
+type Hint = Record<string, unknown>;
 interface Program {
     builtins: string[];
     data: string[];
@@ -363,57 +414,6 @@ interface Program {
     }>;
 }
 
-/** Cairo Assembly .casm */
-type CairoAssembly = {
-    prime: string;
-    compiler_version: string;
-    bytecode: ByteCode;
-    hints: any[];
-    pythonic_hints?: PythonicHints;
-    bytecode_segment_lengths?: number[];
-    entry_points_by_type: EntryPointsByType;
-};
-/** COMPILED CONTRACT */
-/**
- * format produced after starknet-compile .cairo to .json
- *
- * sierra_program is hex array
- */
-type CompiledSierra = {
-    sierra_program: ByteCode;
-    sierra_program_debug_info?: SierraProgramDebugInfo;
-    contract_class_version: string;
-    entry_points_by_type: SierraEntryPointsByType;
-    abi: Abi;
-};
-/**
- * format produced after compressing 'sierra_program', stringifies 'abi' property and omit sierra_program_debug_info
- *
- * CompressedCompiledSierra
- */
-type SierraContractClass = Omit<CompiledSierra, 'abi' | 'sierra_program' | 'sierra_program_debug_info'> & {
-    sierra_program: string;
-    abi: string;
-};
-type CompiledSierraCasm = CairoAssembly;
-/** SUBTYPES */
-type ByteCode = string[];
-type PythonicHints = [number, string[]][];
-type SierraProgramDebugInfo = {
-    type_names: [number, string][];
-    libfunc_names: [number, string][];
-    user_func_names: [number, string][];
-};
-type SierraEntryPointsByType = {
-    CONSTRUCTOR: SierraContractEntryPointFields[];
-    EXTERNAL: SierraContractEntryPointFields[];
-    L1_HANDLER: SierraContractEntryPointFields[];
-};
-type SierraContractEntryPointFields = {
-    selector: string;
-    function_idx: number;
-};
-
 /**
  * format produced after compressing compiled contract
  *
@@ -2697,7 +2697,6 @@ declare abstract class AccountInterface {
     /**
      * Declare a contract class on Starknet
      *
-     // eslint-disable-next-line prettier/prettier
      * @param contractPayload - Contract declaration payload
      * - .contract - Compiled Sierra contract
      * - .classHash - Pre-computed class hash (optional)
@@ -4148,10 +4147,6 @@ declare abstract class AbiParserInterface {
  * too — `1`, `0n`, `'1'`, `'0x0'` — because that is how a bool comes back from a node, as a felt
  * rather than as a JS value. Any other number is refused : a bool is not a felt narrowed to a
  * range, it is exactly two values.
- *
- * On the request side the library is stricter still : `CallData.compile` runs `validateFields`
- * first, which requires a real boolean. So a `1` reaching a `core::bool` argument is refused there
- * before this class ever sees it.
  * @example
  * ```typescript
  * // the same value, reached three ways
@@ -7174,10 +7169,10 @@ declare class AbiParser2 extends AbiParser1 {
 /**
  * The strategy the composite classes drive.
  *
- * It carries the leaf types only for now : a composite adds itself to `dynamicSelectors` as it is
- * written, because its abi type is a family rather than one string. Nothing in the library reads
- * this map yet — the parsers still run on {@link hdParsingStrategy}, and moving them over is the
- * next step, not this one.
+ * It carries the leaf types, and the composites whose abi type is a family rather than one
+ * string — tuple, array, Option, Result, NonZero, fixed array — each found through
+ * `dynamicSelectors`. A contract's own structs and enums are added by the parser. This is the
+ * default strategy of the Cairo 1 parsers, `AbiParser1` and `AbiParser2`.
  * @example
  * ```typescript
  * const felts = cairoTypeStrategy.constructors['core::integer::u8'](44, cairoTypeStrategy)
@@ -9744,25 +9739,75 @@ type WalletAccountV6Options = {
     paymaster?: PaymasterOptions | PaymasterInterface;
 };
 
+/**
+ * @deprecated Use {@link WalletAccountV6} (get-starknet v6) instead. This class is kept only for
+ * DAPPs that are still on get-starknet v4.
+ *
+ * @remarks
+ * Account that lets a wallet sign and send the transactions, using get-starknet v4.
+ * It represents the 'Selected Active' Account inside the Connected Wallet.
+ *
+ * The private key stays in the wallet. Reads go to the RPC node given at the instantiation,
+ * writes go to the wallet. It works only in a DAPP, not in a Node.js script.
+ *
+ * The wallet is selected with the `get-starknet` v4 library. Its `connect()` function opens a
+ * window with the list of wallets. It returns the `StarknetWindowObject` (SWO) of the wallet that
+ * the user selected. With `get-starknet-core` v4 you can also build your own UI and logic. See
+ * [this DAPP](https://github.com/PhilippeR26/Starknet-WalletAccount/blob/53514a5529c4aebe9e7c6331186e83b7a7310ce0/src/app/components/client/WalletHandle/SelectWallet.tsx)
+ * for an example where only the wallets compatible with the Starknet Wallet API can be selected.
+ *
+ * The address and the chain ID follow the wallet automatically. This can lead to reads and
+ * writes on different networks, so create a new instance each time the account or the network
+ * changes.
+ *
+ * The wallet emits 2 events: `accountsChanged` and `networkChanged`.
+ * A change of network emits both. A change of account emits only `accountsChanged`.
+ * You can subscribe with the SWO (`on`) or with the `onAccountChange` and `onNetworkChanged`
+ * methods of this class. To unsubscribe, call `off` on the SWO with the same function.
+ *
+ * Needs `@starknet-io/get-starknet` v4.0.3 min.
+ *
+ * @example
+ * ```typescript
+ * import { connect } from '@starknet-io/get-starknet';
+ * import { WalletAccount, wallet } from 'starknet';
+ * const selectedWalletSWO = await connect({ modalMode: 'alwaysAsk', modalTheme: 'light' });
+ * const myWalletAccount = await WalletAccount.connect(
+ *   { nodeUrl: 'https://api.zan.top/public/starknet-sepolia/rpc/v0_10' },
+ *   selectedWalletSWO
+ * );
+ * // The wallet writes on this network:
+ * const writeChainId = await wallet.requestChainId(myWalletAccount.walletProvider);
+ * // writeChainId = '0x534e5f5345504f4c4941' (SN_SEPOLIA, if the wallet is on Sepolia)
+ * // The provider reads on this network:
+ * const readChainId = await myWalletAccount.provider.getChainId();
+ * // readChainId = '0x534e5f5345504f4c4941'
+ * ```
+ * @example
+ * ```typescript
+ * // Subscribe with the wallet object (SWO). Unsubscribe with `.off` and the same function.
+ * const handleAccount: AccountChangeEventHandler = (accounts: string[] | undefined) => {
+ *   if (accounts?.length) console.log('new address =', accounts[0]);
+ * };
+ * const handleNetwork: NetworkChangeEventHandler = (chainId?: string) => {
+ *   if (chainId) console.log('new chain =', chainId);
+ * };
+ * selectedWalletSWO.on('accountsChanged', handleAccount);
+ * selectedWalletSWO.on('networkChanged', handleNetwork);
+ * selectedWalletSWO.off('accountsChanged', handleAccount);
+ * selectedWalletSWO.off('networkChanged', handleNetwork);
+ * ```
+ */
 declare class WalletAccount extends Account {
     walletProvider: StarknetWalletProvider;
     constructor(options: WalletAccountV4Options);
-    /**
-     * WALLET EVENTS
-     */
     onAccountChange(callback: AccountChangeEventHandler): void;
     onNetworkChanged(callback: NetworkChangeEventHandler): void;
-    /**
-     * WALLET SPECIFIC METHODS
-     */
     requestAccounts(silentMode?: boolean): Promise<string[]>;
     getPermissions(): Promise<"accounts"[]>;
     switchStarknetChain(chainId: _StarknetChainId): Promise<boolean>;
     watchAsset(asset: WatchAssetParameters): Promise<boolean>;
     addStarknetChain(chain: AddStarknetChainParameters): Promise<boolean>;
-    /**
-     * ACCOUNT METHODS
-     */
     execute(calls: AllowArray<Call>): Promise<RPCSPEC0104.AddInvokeTransactionResult>;
     declare(payload: DeclareContractPayload): Promise<RPCSPEC0104.AddDeclareTransactionResult>;
     deploy(payload: UniversalDeployerContractPayload | UniversalDeployerContractPayload[]): Promise<MultiDeployContractResponse>;
@@ -9772,8 +9817,25 @@ declare class WalletAccount extends Account {
 }
 
 /**
- * WalletAccountV5 class.
- * This class is used to create a wallet account that can be used to interact with a Starknet wallet browser extension, using get-starknet v5.
+ * Account that lets a browser wallet sign and send the transactions, using get-starknet v5.
+ *
+ * The private key stays in the wallet. Reads go to the RPC node of the provider, writes go to
+ * the wallet. It works only in a DAPP, not in a Node.js script.
+ * For a new DAPP, use {@link WalletAccountV6} (get-starknet v6) instead.
+ *
+ * Create it with {@link WalletAccountV5.connect}. The address and the chain ID follow the
+ * wallet automatically when the user changes them.
+ * @example
+ * ```typescript
+ * import { createStore } from '@starknet-io/get-starknet-discovery'; // v5.0.0 min
+ * const [selectedWallet] = createStore().getWallets(); // let the user choose in your own UI
+ * const myWalletAccount = await WalletAccountV5.connect(
+ *   { nodeUrl: 'https://api.zan.top/public/starknet-sepolia/rpc/v0_10' },
+ *   selectedWallet
+ * );
+ * const result = await myWalletAccount.execute(myCall);
+ * // result = { transaction_hash: '0x...' }
+ * ```
  */
 declare class WalletAccountV5 extends Account {
     walletProvider: WalletWithStarknetFeatures;
@@ -9787,37 +9849,203 @@ declare class WalletAccountV5 extends Account {
      * Released by {@link unsubscribeChange}.
      */
     private changeSubscriptions;
-    constructor(options: WalletAccountV5Options);
     /**
-     * WALLET EVENTS
+     * Prefer {@link WalletAccountV5.connect}: it also asks the wallet for the address.
+     * @param {WalletAccountV5Options} options - The provider, the wallet, the account address, and
+     * optionally the Cairo version and the paymaster.
+     * @example
+     * ```typescript
+     * const myWalletAccount = new WalletAccountV5({
+     *   provider: { nodeUrl: 'https://api.zan.top/public/starknet-sepolia/rpc/v0_10' },
+     *   walletProvider: selectedWallet,
+     *   address: '0x...', // an address that the user already allowed in the wallet
+     * });
+     * ```
      */
+    constructor(options: WalletAccountV5Options);
     /**
      * Subscribe a callback to wallet account/network changes.
      * @param {(change: StandardEventsChangeProperties) => void} callback called on each change.
      * @returns {() => void} a function to unsubscribe this specific callback.
+     * @example
+     * ```typescript
+     * const unsubscribe = myWalletAccount.onChange((change) => {
+     *   console.log('new address =', change.accounts?.[0]?.address);
+     * });
+     * // Later, to stop this callback only:
+     * unsubscribe();
+     * ```
      */
     onChange(callback: (change: StandardEventsChangeProperties) => void): () => void;
     /**
      * Unsubscribe from all wallet events, including the callbacks registered through {@link onChange}.
      * To call before the instance is deleted.
+     * @example
+     * ```typescript
+     * // In the cleanup of a React effect, or before you stop using the instance:
+     * myWalletAccount.unsubscribeChange();
+     * ```
      */
     unsubscribeChange(): void;
     /**
-     * WALLET SPECIFIC METHODS
+     * Ask the wallet for the addresses that the user allowed for this DAPP.
+     * @param {boolean} [silentMode=false] - false: the wallet can ask the user. true: no window;
+     * only the addresses already allowed are returned.
+     * @returns {Promise<Address[]>} The allowed addresses.
+     * @example
+     * ```typescript
+     * const addresses = await myWalletAccount.requestAccounts();
+     * // addresses = ['0x...']
+     * ```
      */
     requestAccounts(silentMode?: boolean): Promise<string[]>;
+    /**
+     * Ask the wallet if this DAPP is allowed.
+     * @returns {Promise<Permission[]>} `['accounts']` when the DAPP is allowed.
+     * @example
+     * ```typescript
+     * const permissions = await myWalletAccount.getPermissions();
+     * // permissions = ['accounts']
+     * ```
+     */
     getPermissions(): Promise<"accounts"[]>;
+    /**
+     * Ask the wallet to change its current network.
+     * @param {StarknetChainId} chainId - The network to use.
+     * @returns {Promise<boolean>} true if the wallet changed the network.
+     * @example
+     * ```typescript
+     * const changed = await myWalletAccount.switchStarknetChain(constants.StarknetChainId.SN_SEPOLIA);
+     * // changed = true
+     * ```
+     */
     switchStarknetChain(chainId: _StarknetChainId): Promise<boolean>;
+    /**
+     * Ask the wallet to display a token in its list.
+     * @param {WatchAssetParameters} asset - The token to display.
+     * @returns {Promise<boolean>} true if the token was added.
+     * @example
+     * ```typescript
+     * const added = await myWalletAccount.watchAsset({ type: 'ERC20', options: { address: tokenAddress } });
+     * // added = true
+     * ```
+     */
     watchAsset(asset: WatchAssetParameters$1): Promise<boolean>;
+    /**
+     * Ask the wallet to add a custom Starknet network.
+     * @param {AddStarknetChainParameters} chain - The network to add.
+     * @returns {Promise<boolean>} true if the network was added.
+     * @example
+     * ```typescript
+     * const added = await myWalletAccount.addStarknetChain({
+     *   id: 'my-devnet',
+     *   chain_id: '0x534e5f5345504f4c4941',
+     *   chain_name: 'My devnet',
+     *   rpc_urls: ['http://127.0.0.1:5050/rpc'],
+     * });
+     * // added = true
+     * ```
+     */
     addStarknetChain(chain: AddStarknetChainParameters$1): Promise<boolean>;
     /**
-     * ACCOUNT METHODS
+     * Ask the wallet to sign and send an invoke transaction. The wallet shows the calls to the
+     * user and chooses the fee itself.
+     * @param {AllowArray<Call>} calls - The call(s) to execute.
+     * @returns {Promise<AddInvokeTransactionResult>} The hash of the transaction.
+     * @example
+     * ```typescript
+     * const result = await myWalletAccount.execute(myContract.populate('increase', [10]));
+     * // result = { transaction_hash: '0x...' }
+     * ```
      */
     execute(calls: AllowArray<Call>): Promise<RPC$1.AddInvokeTransactionResult>;
+    /**
+     * Ask the wallet to sign and send a declare transaction (Cairo 1 contract).
+     * The compiled class hash is required: give `casm`, or `compiledClassHash`.
+     * @param {DeclareContractPayload} payload - The contract to declare.
+     * @returns {Promise<AddDeclareTransactionResult>} The hash of the transaction and the class hash.
+     * @example
+     * ```typescript
+     * const result = await myWalletAccount.declare({ contract: compiledSierra, casm: compiledCasm });
+     * // result = { transaction_hash: '0x...', class_hash: '0x...' }
+     * ```
+     */
     declare(payload: DeclareContractPayload): Promise<RPC$1.AddDeclareTransactionResult>;
+    /**
+     * Deploy contract(s) with the Universal Deployer Contract (UDC). The wallet signs and sends
+     * one invoke transaction.
+     * @param {UniversalDeployerContractPayload | UniversalDeployerContractPayload[]} payload - The
+     * contract(s) to deploy.
+     * @returns {Promise<MultiDeployContractResponse>} The hash of the transaction, and the addresses
+     * of the new contracts.
+     * @example
+     * ```typescript
+     * const result = await myWalletAccount.deploy({ classHash, constructorCalldata: [] });
+     * // result = { transaction_hash: '0x...', contract_address: ['0x...'] }
+     * ```
+     */
     deploy(payload: UniversalDeployerContractPayload | UniversalDeployerContractPayload[]): Promise<MultiDeployContractResponse>;
+    /**
+     * Ask the wallet to sign a SNIP-12 typed message.
+     * @param {TypedData} typedData - The message to sign.
+     * @returns {Promise<Signature>} The signature, as an array of strings.
+     * @example
+     * ```typescript
+     * const signature = await myWalletAccount.signMessage(myTypedData);
+     * // signature = ['0x...', '0x...']
+     * ```
+     */
     signMessage(typedData: TypedData): Promise<Signature$2>;
+    /**
+     * Connect to a wallet, and create the account of the address that the user selected in it.
+     *
+     * The wallet asks the user to allow this DAPP. If the user refuses, there is no error: the
+     * account is created with an `undefined` address.
+     * @param {ProviderOptions | ProviderInterface} provider - The provider used to read Starknet,
+     * or its options (e.g. `{ nodeUrl }`).
+     * @param {WalletWithStarknetFeatures} walletProvider - The wallet selected by the user
+     * (get-starknet v5).
+     * @param {CairoVersion} [cairoVersion] - Cairo version of the account. Optional: detected if
+     * not provided.
+     * @param {PaymasterOptions | PaymasterInterface} [paymaster] - The paymaster to use with this
+     * account.
+     * @param {boolean} [silentMode=false] - true: no window; it works only if the user already
+     * allowed this DAPP.
+     * @returns {Promise<WalletAccountV5>} The account.
+     * @example
+     * ```typescript
+     * const myWalletAccount = await WalletAccountV5.connect(
+     *   { nodeUrl: 'https://api.zan.top/public/starknet-sepolia/rpc/v0_10' },
+     *   selectedWallet
+     * );
+     * // With a paymaster. The parameters are positional, so cairoVersion must be given:
+     * const myPaymasterAccount = await WalletAccountV5.connect(
+     *   myProvider,
+     *   selectedWallet,
+     *   undefined, // cairoVersion: detected
+     *   myPaymasterRpc
+     * );
+     * ```
+     */
     static connect(provider: ProviderOptions | ProviderInterface, walletProvider: WalletWithStarknetFeatures, cairoVersion?: CairoVersion, paymaster?: PaymasterOptions | PaymasterInterface, silentMode?: boolean): Promise<WalletAccountV5>;
+    /**
+     * Same as {@link WalletAccountV5.connect} with `silentMode` true: no window is shown, so it
+     * works only if the user already allowed this DAPP (for example, to connect again after a
+     * page reload). Otherwise, the account is created with an `undefined` address.
+     * @param {ProviderOptions | ProviderInterface} provider - The provider used to read Starknet,
+     * or its options.
+     * @param {WalletWithStarknetFeatures} walletProvider - The wallet selected by the user.
+     * @param {CairoVersion} [cairoVersion] - Cairo version of the account. Optional: detected if
+     * not provided.
+     * @param {PaymasterOptions | PaymasterInterface} [paymaster] - The paymaster to use with this
+     * account.
+     * @returns {Promise<WalletAccountV5>} The account.
+     * @example
+     * ```typescript
+     * const myWalletAccount = await WalletAccountV5.connectSilent(myProvider, selectedWallet);
+     * // myWalletAccount.address is undefined if this DAPP is not allowed yet
+     * ```
+     */
     static connectSilent(provider: ProviderOptions | ProviderInterface, walletProvider: WalletWithStarknetFeatures, cairoVersion?: CairoVersion, paymaster?: PaymasterOptions | PaymasterInterface): Promise<WalletAccountV5>;
 }
 
@@ -9892,12 +10120,57 @@ type STRK20_CALL_AND_PROOF = Omit<STRK20_CALL_AND_PROOF$1, 'call'> & {
 };
 
 /**
- * WalletAccountV6 class.
- * Extends WalletAccountV5 with get-starknet v6 types and STRK20 privacy protocol methods.
+ * Account that lets a browser wallet sign and send the transactions, using get-starknet v6.
+ * This is the recommended class for a new DAPP.
+ *
+ * It extends {@link WalletAccountV5}: same methods, plus the STRK20 privacy protocol
+ * (`strk20Balances`, `strk20PrepareInvoke`, `strk20InvokeTransaction`,
+ * `strk20ShadowAccountCommitment` and `executeWithProof`).
+ * It needs `@starknet-io/get-starknet-discovery` and `@starknet-io/get-starknet-wallet-standard`
+ * v6.0.6 min.
+ *
+ * The `walletProvider` property keeps the type of get-starknet v5. To call a `walletV6`
+ * function, give it the wallet that you selected, not `walletProvider`.
+ * @example
+ * ```typescript
+ * import { createStore } from '@starknet-io/get-starknet-discovery'; // v6.0.6 min
+ * const [selectedWallet] = createStore().getWallets(); // let the user choose in your own UI
+ * const myWalletAccount = await WalletAccountV6.connect(
+ *   { nodeUrl: 'https://api.zan.top/public/starknet-sepolia/rpc/v0_10' },
+ *   selectedWallet
+ * );
+ * const chainId = await walletV6.requestChainId(selectedWallet);
+ * // chainId = '0x534e5f5345504f4c4941' (the wallet is on Sepolia)
+ * ```
  */
 declare class WalletAccountV6 extends WalletAccountV5 {
+    /**
+     * Prefer {@link WalletAccountV6.connect}: it also asks the wallet for the address.
+     * @param {WalletAccountV6Options} options - The provider, the wallet, the account address, and
+     * optionally the Cairo version and the paymaster.
+     * @example
+     * ```typescript
+     * const myWalletAccount = new WalletAccountV6({
+     *   provider: { nodeUrl: 'https://api.zan.top/public/starknet-sepolia/rpc/v0_10' },
+     *   walletProvider: selectedWallet,
+     *   address: '0x...', // an address that the user already allowed in the wallet
+     * });
+     * ```
+     */
     constructor(options: WalletAccountV6Options);
     private get v6Provider();
+    /**
+     * Ask the wallet to change its current network.
+     * @param {StarknetChainId} chainId - The network to use.
+     * @param {boolean} [silent_mode=false] - Sent to the wallet as `silent_mode`: true asks the
+     * wallet not to show its window.
+     * @returns {Promise<boolean>} true if the wallet changed the network.
+     * @example
+     * ```typescript
+     * const changed = await myWalletAccount.switchStarknetChain(constants.StarknetChainId.SN_SEPOLIA);
+     * // changed = true
+     * ```
+     */
     switchStarknetChain(chainId: _StarknetChainId, silent_mode?: boolean): Promise<boolean>;
     /**
      * Execute call(s) with an optional STRK20 privacy proof attached. Same signature as
@@ -9917,7 +10190,7 @@ declare class WalletAccountV6 extends WalletAccountV5 {
      * Get the private balances held by the user inside the STRK20 privacy pool.
      *
      * Reading a shielded balance requires the user approval, and this approval is time
-     * limited : `validUntil` requests when it expires. When it is omitted, the wallet applies
+     * limited: `validUntil` requests when it expires. When it is omitted, the wallet applies
      * its own default window.
      * @param {Address[]} tokens - The tokens to get the private balance of. An empty array returns every shielded token.
      * @param {number} [validUntil] - Requested expiry of the balance read authorization, as a Unix timestamp in seconds. Omit it to let the wallet apply its default window.
@@ -9927,7 +10200,7 @@ declare class WalletAccountV6 extends WalletAccountV5 {
      * const balances = await myWalletAccount.strk20Balances([strkAddress]);
      * // balances = [{ token: '0x4718...', balance: '0x2386f26fc10000' }]
      *
-     * // Asking for a 5 minutes authorization window :
+     * // Asking for a 5-minute authorization window:
      * const expiry = Math.floor(Date.now() / 1000) + 300;
      * const fresh = await myWalletAccount.strk20Balances([strkAddress], expiry);
      * // fresh = [{ token: '0x4718...', balance: '0x2386f26fc10000' }]
@@ -9936,11 +10209,11 @@ declare class WalletAccountV6 extends WalletAccountV5 {
     strk20Balances(tokens: Address[], validUntil?: number): Promise<STRK20_BALANCE_ENTRY[]>;
     /**
      * Build the Starknet call and the SNIP-36 zero-knowledge proof of a STRK20 transaction,
-     * without submitting it : the DAPP submits the returned call itself, and therefore pays
+     * without submitting it: the DAPP submits the returned call itself, and therefore pays
      * the fee (the wallet adds no fee action in this mode).
      *
      * With `simulate` set to true, the wallet skips the expensive proof generation and
-     * returns an empty proof : the call is then NOT submittable on-chain, and is only useful
+     * returns an empty proof: the call is then NOT submittable on-chain, and is only useful
      * for fee estimation or UI previews.
      * @param {STRK20_ACTION[]} actions - The STRK20 actions to perform atomically (min 1).
      * @param {boolean} [simulate] - True to skip the proof generation.
@@ -9973,15 +10246,15 @@ declare class WalletAccountV6 extends WalletAccountV5 {
     }>;
     /**
      * Compute the commitment of a DAPP STRK20 shadow account. The commitment is computed
-     * locally by the wallet from the user private state ; no transaction is sent.
+     * locally by the wallet from the user private state; no transaction is sent.
      *
      * When `nonce` is given, the full commitment of this single shadow account is returned.
      * When `nonce` is omitted, the partial (nonce independent) commitment is returned
-     * instead : it is shared by every shadow account the user derives for this DAPP, so it
+     * instead: it is shared by every shadow account the user derives for this DAPP, so it
      * can be published once to let a DAPP recognize all the shadow accounts of a user
      * without learning any individual nonce.
      * @param {STRK20_DAPP_NAME} dappName - The DAPP that scopes the shadow account(s).
-     * @param {FELT} [nonce] - The shadow account nonce ; each nonce selects a distinct shadow account for this user + DAPP. Omit it to get the partial commitment.
+     * @param {FELT} [nonce] - The shadow account nonce; each nonce selects a distinct shadow account for this user + DAPP. Omit it to get the partial commitment.
      * @returns {Promise<FELT>} The shadow account commitment.
      * @example
      * ```typescript
@@ -9990,7 +10263,56 @@ declare class WalletAccountV6 extends WalletAccountV5 {
      * ```
      */
     strk20ShadowAccountCommitment(dappName: STRK20_DAPP_NAME, nonce?: FELT$1): Promise<FELT$1>;
+    /**
+     * Connect to a wallet, and create the account of the address that the user selected in it.
+     *
+     * The wallet asks the user to allow this DAPP. If the user refuses, there is no error: the
+     * account is created with an `undefined` address.
+     * @param {ProviderOptions | ProviderInterface} provider - The provider used to read Starknet,
+     * or its options (e.g. `{ nodeUrl }`).
+     * @param {WalletWithStarknetFeaturesV6} walletProvider - The wallet selected by the user
+     * (get-starknet v6).
+     * @param {CairoVersion} [cairoVersion] - Cairo version of the account. Optional: detected if
+     * not provided.
+     * @param {PaymasterOptions | PaymasterInterface} [paymaster] - The paymaster to use with this
+     * account.
+     * @param {boolean} [silentMode=false] - true: no window; it works only if the user already
+     * allowed this DAPP.
+     * @returns {Promise<WalletAccountV6>} The account.
+     * @example
+     * ```typescript
+     * const myWalletAccount = await WalletAccountV6.connect(
+     *   { nodeUrl: 'https://api.zan.top/public/starknet-sepolia/rpc/v0_10' },
+     *   selectedWallet
+     * );
+     * // With a paymaster. The parameters are positional, so cairoVersion must be given:
+     * const myPaymasterAccount = await WalletAccountV6.connect(
+     *   myProvider,
+     *   selectedWallet,
+     *   undefined, // cairoVersion: detected
+     *   myPaymasterRpc
+     * );
+     * ```
+     */
     static connect(provider: ProviderOptions | ProviderInterface, walletProvider: WalletWithStarknetFeatures$1, cairoVersion?: CairoVersion, paymaster?: PaymasterOptions | PaymasterInterface, silentMode?: boolean): Promise<WalletAccountV6>;
+    /**
+     * Same as {@link WalletAccountV6.connect} with `silentMode` true: no window is shown, so it
+     * works only if the user already allowed this DAPP (for example, to connect again after a
+     * page reload). Otherwise, the account is created with an `undefined` address.
+     * @param {ProviderOptions | ProviderInterface} provider - The provider used to read Starknet,
+     * or its options.
+     * @param {WalletWithStarknetFeaturesV6} walletProvider - The wallet selected by the user.
+     * @param {CairoVersion} [cairoVersion] - Cairo version of the account. Optional: detected if
+     * not provided.
+     * @param {PaymasterOptions | PaymasterInterface} [paymaster] - The paymaster to use with this
+     * account.
+     * @returns {Promise<WalletAccountV6>} The account.
+     * @example
+     * ```typescript
+     * const myWalletAccount = await WalletAccountV6.connectSilent(myProvider, selectedWallet);
+     * // myWalletAccount.address is undefined if this DAPP is not allowed yet
+     * ```
+     */
     static connectSilent(provider: ProviderOptions | ProviderInterface, walletProvider: WalletWithStarknetFeatures$1, cairoVersion?: CairoVersion, paymaster?: PaymasterOptions | PaymasterInterface): Promise<WalletAccountV6>;
 }
 
@@ -11050,6 +11372,45 @@ type CalcV3DeployAccountTxHashArgs = {
 type CalcDeployAccountTxHashArgs = CalcV3DeployAccountTxHashArgs;
 declare function calculateDeployAccountTransactionHash$1(args: CalcDeployAccountTxHashArgs): string;
 
+/**
+ * Cairo 0 class hash computation, using the Pedersen hash
+ */
+
+/**
+ * JSON replacer function that skips null values and empty arrays for specific keys
+ * Used in legacy contract class serialization
+ * @example
+ * ```typescript
+ * const input = { a: null, attributes: [], debug_info: { x: 1 }, b: 2 };
+ * const result = JSON.stringify(input, hash.nullSkipReplacer);
+ * // result = '{"debug_info":null,"b":2}'
+ * ```
+ */
+declare function nullSkipReplacer(key: string, value: any): any;
+/**
+ * Compute hinted class hash for legacy compiled contract (Cairo 0)
+ * @param {LegacyCompiledContract} compiledContract
+ * @returns {string} hex-string
+ * @example
+ * ```typescript
+ * const compiledCairo0 = json.parse(fs.readFileSync("./cairo0contract.json").toString("ascii"));
+ * const result=hash.computeHintedClassHash(compiledCairo0);
+ * // result = "0x293eabb06955c0a1e55557014675aa4e7a1fd69896147382b29b2b6b166a2ac"
+ * ``` */
+declare function computeHintedClassHash(compiledContract: LegacyCompiledContract): string;
+/**
+ * Computes the class hash for legacy compiled contract (Cairo 0)
+ * @param {LegacyCompiledContract | string} contract legacy compiled contract content
+ * @returns {string} hex-string of class hash
+ * @example
+ * ```typescript
+ * const compiledCairo0 = json.parse(fs.readFileSync("./cairo0contract.json").toString("ascii"));
+ * const result=hash.computeLegacyContractClassHash(compiledCairo0);
+ * // result = "0x4a5cae61fa8312b0a3d0c44658b403d3e4197be80027fd5020ffcdf0c803331"
+ * ```
+ */
+declare function computeLegacyContractClassHash(contract: LegacyCompiledContract | string): string;
+
 /**
  * Pure Pedersen hash utilities — no calldata dependency
  */
@@ -11071,7 +11432,7 @@ declare function computeHashOnElements(data: BigNumberish[]): string;
 declare const computePedersenHashOnElements: typeof computeHashOnElements;
 
 /**
- * Cairo 0 Class Hash computation using Pedersen hash
+ * Contract address computation, and the Pedersen hash helpers
  */
 
 /**
@@ -11089,29 +11450,6 @@ declare const computePedersenHashOnElements: typeof computeHashOnElements;
  * ```
  */
 declare function calculateContractAddressFromHash(salt: BigNumberish, classHash: BigNumberish, constructorCalldata: RawArgs, deployerAddress: BigNumberish): string;
-/**
- * Compute hinted class hash for legacy compiled contract (Cairo 0)
- * @param {LegacyCompiledContract} compiledContract
- * @returns {string} hex-string
- * @example
- * ```typescript
- * const compiledCairo0 = json.parse(fs.readFileSync("./cairo0contract.json").toString("ascii"));
- * const result=hash.computeHintedClassHash(compiledCairo0);
- * // result = "0x293eabb06955c0a1e55557014675aa4e7a1fd69896147382b29b2b6b166a2ac"
- * ``` */
-declare function computeHintedClassHash(compiledContract: LegacyCompiledContract): string;
-/**
- * Computes the class hash for legacy compiled contract (Cairo 0)
- * @param {LegacyCompiledContract | string} contract legacy compiled contract content
- * @returns {string} hex-string of class hash
- * @example
- * ```typescript
- * const compiledCairo0 = json.parse(fs.readFileSync("./cairo0contract.json").toString("ascii"));
- * const result=hash.computeLegacyContractClassHash(compiledCairo0);
- * // result = "0x4a5cae61fa8312b0a3d0c44658b403d3e4197be80027fd5020ffcdf0c803331"
- * ```
- */
-declare function computeLegacyContractClassHash(contract: LegacyCompiledContract | string): string;
 
 /**
  * Cairo 1 Class Hash computation using Poseidon hash
@@ -11214,11 +11552,6 @@ declare const COMPILED_CLASS_VERSION = "COMPILED_CLASS_V1";
  * ```
  */
 declare function formatSpaces(json: string): string;
-/**
- * JSON replacer function that skips null values and empty arrays for specific keys
- * Used in legacy contract class serialization
- */
-declare function nullSkipReplacer(key: string, value: any): any;
 /**
  * Convert builtins array to encoded BigInt array
  * Common pattern used in both Poseidon and Blake2s hashing
@@ -11756,11 +12089,6 @@ declare namespace num {
   export { num_addPercent as addPercent, num_assertInRange as assertInRange, num_bigNumberishArrayToDecimalStringArray as bigNumberishArrayToDecimalStringArray, num_bigNumberishArrayToHexadecimalStringArray as bigNumberishArrayToHexadecimalStringArray, num_cleanHex as cleanHex, num_getDecimalString as getDecimalString, num_getHexString as getHexString, num_getHexStringArray as getHexStringArray, num_getNext as getNext, num_hexToBytes as hexToBytes, num_hexToDecimalString as hexToDecimalString, num_isBigNumberish as isBigNumberish, num_isEmptyHex as isEmptyHex, num_isHex as isHex, num_isHexString as isHexString, num_isStringWholeNumber as isStringWholeNumber, num_stringToSha256ToArrayBuff4 as stringToSha256ToArrayBuff4, num_toBigInt as toBigInt, num_toCairoBool as toCairoBool, num_toHex as toHex, num_toHex64 as toHex64, num_toHexString as toHexString, num_toStorageKey as toStorageKey, num_tryToBigInt as tryToBigInt };
 }
 
-/**
- * Extract compiled calldata from args or execute callback
- */
-declare function getCompiledCalldata(constructorArguments: RawArgs, callback: Function): Calldata;
-
 /**
  * Transforms a list of Calls, each with their own calldata, into
  * two arrays: one with the entry points, and one with the concatenated calldata
@@ -11822,6 +12150,12 @@ declare const transformCallsToMulticallArrays: (calls: Call[]) => {
  * ```
  */
 declare const fromCallsToExecuteCalldata: (calls: Call[]) => Calldata;
+
+/**
+ * Extract compiled calldata from args or execute callback
+ */
+declare function getCompiledCalldata(constructorArguments: RawArgs, callback: Function): Calldata;
+
 /**
  * Transforms a list of calls into the Cairo 1 `__execute__` calldata.
  * @param {Call[]} calls the list of calls to transform.
@@ -16470,7 +16804,13 @@ declare class CairoTypeOption {
      * Build an option, from a value a caller passed or from the felts of a response.
      *
      * A {@link CairoOption} says its own branch, so `variant` is not given with one — nor with the
-     * response iterator, which reads the branch off the wire. Anywhere else it is required.
+     * response iterator, which reads the branch off the wire, nor with a `CairoTypeOption`, which
+     * is copied as it is. Anywhere else it is required.
+     *
+     * For the same reason, a `CairoOption` that holds a `CairoTypeOption` is refused: once it is
+     * unwrapped, the variant comes with the `CairoTypeOption`. Accepted, it would lose one level:
+     * `Some(Some(1))` would be sent as `Some(None)`. Write a nested value with `CairoOption`
+     * only, or build one `CairoTypeOption` for the whole type.
      *
      * `subType` is what makes an option of options work. Handed a `CairoOption`, this constructor
      * unwraps it and calls itself with what was inside, which for a nested option is another
@@ -16481,11 +16821,11 @@ declare class CairoTypeOption {
      * @param {string} optionCairoType the abi type, `core::option::Option::<T>`
      * @param {AllowArray<CairoTypeStrategy>} parsingStrategy how to build the value
      * @param {CairoOptionVariant | number} [variant] which branch, when the content does not say.
-     * Must be omitted when `content` is the response iterator.
+     * Must be omitted when `content` is the response iterator or a `CairoTypeOption`.
      * @param {boolean} [subType=false] true when called from the unwrapping of a nested
      * `CairoOption`, which is the only caller that should set it
-     * @throws {Error} when the type is not an option, when the variant is missing, absurd, or
-     * contradicts the content
+     * @throws {Error} when the type is not an option, or when the variant is missing, absurd,
+     * contradicts the content, or is given with a `CairoTypeOption`
      * @example
      * ```typescript
      * const type = 'core::option::Option::<core::integer::u8>';
@@ -17653,7 +17993,7 @@ declare function subscribeWalletEvent(walletWSF: WalletWithStarknetFeatures$1, c
 /**
  * Get the private balances held by the user inside the STRK20 privacy pool.
  *
- * Reading a shielded balance requires the user approval, and this approval is time limited :
+ * Reading a shielded balance requires the user approval, and this approval is time limited:
  * `valid_until` requests when it expires. When it is omitted, the wallet applies its own
  * default window.
  * @param {WalletWithStarknetFeaturesV6} walletWSF - The get-starknet V6 wallet object to use.
@@ -17673,16 +18013,16 @@ declare function strk20InvokeTransaction(walletWSF: WalletWithStarknetFeatures$1
 }>;
 /**
  * Compute the commitment of a DAPP STRK20 shadow account. The commitment is computed
- * locally by the wallet from the user private state ; no transaction is sent.
+ * locally by the wallet from the user private state; no transaction is sent.
  *
  * When `nonce` is given, the full commitment of this single shadow account is returned.
- * When `nonce` is omitted, the partial (nonce independent) commitment is returned instead :
+ * When `nonce` is omitted, the partial (nonce independent) commitment is returned instead:
  * it is shared by every shadow account the user derives for this DAPP, so it can be
  * published once to let a DAPP recognize all the shadow accounts of a user without learning
  * any individual nonce.
  * @param {WalletWithStarknetFeaturesV6} walletWSF - The get-starknet V6 wallet object to use.
  * @param {STRK20_DAPP_NAME} dapp_name - The DAPP that scopes the shadow account(s).
- * @param {FELT} [nonce] - The shadow account nonce ; each nonce selects a distinct shadow account for this user + DAPP. Omit it to get the partial commitment.
+ * @param {FELT} [nonce] - The shadow account nonce; each nonce selects a distinct shadow account for this user + DAPP. Omit it to get the partial commitment.
  * @returns {Promise<FELT>} The shadow account commitment.
  * @example
  * ```typescript