@aeternity/aepp-sdk 13.2.1 → 13.3.0

package/src/AeSdkMethods.ts

@@ -1,4 +1,5 @@
 import * as chainMethods from './chain';
+import { sendTransaction } from './send-transaction';
 import * as aensMethods from './aens';
 import * as spendMethods from './spend';
 import * as oracleMethods from './oracle';
@@ -7,6 +8,7 @@ import createDelegationSignature from './contract/delegation-signature';
 import * as contractGaMethods from './contract/ga';
 import { buildTxAsync } from './tx/builder';
 import { mapObject, UnionToIntersection } from './utils/other';
+import { wrapWithProxy } from './utils/wrap-proxy';
 import Node from './Node';
 import { TxParamsAsync } from './tx/builder/schema.generated';
 import AccountBase from './account/Base';
@@ -15,29 +17,9 @@ import CompilerBase from './contract/compiler/Base';
 
 export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
 
-export function getValueOrErrorProxy<Value extends object | undefined>(
-  valueCb: () => Value,
-): NonNullable<Value> {
-  return new Proxy(
-    {},
-    Object.fromEntries(([
-      'apply', 'construct', 'defineProperty', 'deleteProperty', 'getOwnPropertyDescriptor',
-      'getPrototypeOf', 'isExtensible', 'ownKeys', 'preventExtensions', 'set', 'setPrototypeOf',
-      'get', 'has',
-    ] as const).map((name) => [name, (t: {}, ...args: unknown[]) => {
-      const target = valueCb() as object; // to get a native exception in case it missed
-      const res = (Reflect[name] as any)(target, ...args);
-      return typeof res === 'function' && name === 'get'
-        ? res.bind(target) // otherwise it fails with attempted to get private field on non-instance
-        : res;
-    }])),
-  ) as NonNullable<Value>;
-}
-
-const { InvalidTxError: _2, ...chainMethodsOther } = chainMethods;
-
 const methods = {
-  ...chainMethodsOther,
+  ...chainMethods,
+  sendTransaction,
   ...aensMethods,
   ...spendMethods,
   ...oracleMethods,
@@ -57,6 +39,12 @@ export interface AeSdkMethodsOptions
   extends Partial<UnionToIntersection<MethodsOptions[keyof MethodsOptions]>> {
 }
 
+export interface WrappedOptions {
+  onAccount: AccountBase;
+  onCompiler: CompilerBase;
+  onNode: Node;
+}
+
 /**
  * AeSdkMethods is the composition of:
  * - chain methods
@@ -73,33 +61,43 @@ export interface AeSdkMethodsOptions
 class AeSdkMethods {
   _options: AeSdkMethodsOptions = {};
 
+  readonly #wrappedOptions: WrappedOptions;
+
   /**
    * @param options - Options
    */
   constructor(options: AeSdkMethodsOptions = {}) {
     Object.assign(this._options, options);
+    this.#wrappedOptions = {
+      onAccount: wrapWithProxy(() => this._options.onAccount),
+      onNode: wrapWithProxy(() => this._options.onNode),
+      onCompiler: wrapWithProxy(() => this._options.onCompiler),
+    };
   }
 
-  _getOptions(
-    callOptions: AeSdkMethodsOptions = {},
-  ): AeSdkMethodsOptions & { onAccount: AccountBase; onCompiler: CompilerBase; onNode: Node } {
+  /**
+   * Returns sdk instance options with references to current account, node, compiler.
+   * Used to create an instance (Contract, Oracle) bound to AeSdk state.
+   * @param mergeWith - Merge context with these extra options
+   * @returns Context object
+   */
+  getContext(mergeWith: AeSdkMethodsOptions = {}): AeSdkMethodsOptions & WrappedOptions {
     return {
       ...this._options,
-      onAccount: getValueOrErrorProxy(() => this._options.onAccount),
-      onNode: getValueOrErrorProxy(() => this._options.onNode),
-      onCompiler: getValueOrErrorProxy(() => this._options.onCompiler),
-      ...callOptions,
+      ...this.#wrappedOptions,
+      ...mergeWith,
     };
   }
 
+  // TODO: omit onNode from options, because it is already in context
   async buildTx(options: TxParamsAsync): Promise<Encoded.Transaction> {
-    return buildTxAsync({ ...this._getOptions(), ...options });
+    return buildTxAsync({ ...this.getContext(), ...options });
   }
 
   async initializeContract<Methods extends ContractMethodsBase>(
     options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & { onNode?: Node },
   ): Promise<Contract<Methods>> {
-    return Contract.initialize<Methods>(this._getOptions(options as AeSdkMethodsOptions));
+    return Contract.initialize<Methods>(this.getContext(options as AeSdkMethodsOptions));
   }
 }
 
@@ -110,7 +108,13 @@ type RequiredKeys<T> = {
 type OptionalIfNotRequired<T extends [any]> = RequiredKeys<T[0]> extends never ? T | [] : T;
 
 type ReplaceOnAccount<Options> = Options extends { onAccount: any }
-  ? Omit<Options, 'onAccount'> & { onAccount: OnAccount } : Options;
+  ? Omit<Options, 'onAccount'> & {
+    /**
+     * Make operation on specific account by providing address (to use account from sdk) or instance
+     * of AccountBase (like MemoryAccount)
+     */
+    onAccount: OnAccount;
+  } : Options;
 
 type MakeOptional<Options> = OptionalIfNotRequired<[
   Omit<Options, 'onNode' | 'onCompiler' | 'onAccount'> & Partial<ReplaceOnAccount<Options>>,
@@ -133,7 +137,7 @@ Object.assign(AeSdkMethods.prototype, mapObject<Function, Function>(
     function methodWrapper(this: AeSdkMethods, ...args: any[]) {
       args.length = handler.length;
       const options = args[args.length - 1];
-      args[args.length - 1] = this._getOptions(options);
+      args[args.length - 1] = this.getContext(options);
       return handler(...args);
     },
   ],

package/src/AeSdkWallet.ts

@@ -18,7 +18,9 @@ import {
   WalletApi,
   WalletInfo,
 } from './aepp-wallet-communication/rpc/types';
-import { Encoded } from './utils/encoder';
+import {
+  Encoded, Encoding, encode, decode,
+} from './utils/encoder';
 import jsonBig from './utils/json-big';
 
 type RpcClientWallet = RpcClient<AeppApi, WalletApi>;
@@ -302,23 +304,40 @@ export default class AeSdkWallet extends AeSdk {
             };
           },
           [METHODS.signDelegationToContract]: async ({
-            contractAddress, name, oracleQueryId, onAccount = this.address,
+            contractAddress, name, oracleQueryId, allNames, onAccount = this.address, isOracle,
           }, origin) => {
             if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
             if (!this.addresses().includes(onAccount)) {
               throw new RpcPermissionDenyError(onAccount);
             }
 
+            isOracle ??= false;
             const parameters = { onAccount, aeppOrigin: origin, aeppRpcClientId: id };
             const signature = await (
               (name == null ? null : this
                 .signNameDelegationToContract(contractAddress, name, parameters))
               ?? (oracleQueryId == null ? null : this
                 .signOracleQueryDelegationToContract(contractAddress, oracleQueryId, parameters))
-              ?? this.signDelegationToContract(contractAddress, parameters)
+              ?? (allNames !== true ? null : this
+                .signAllNamesDelegationToContract(contractAddress, parameters))
+              ?? this.signDelegationToContract(contractAddress, { ...parameters, isOracle })
             );
             return { signature };
           },
+          [METHODS.unsafeSign]: async ({ data, onAccount = this.address }, origin) => {
+            if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
+            if (!this.addresses().includes(onAccount)) throw new RpcPermissionDenyError(onAccount);
+            const parameters = { onAccount, aeppOrigin: origin, aeppRpcClientId: id };
+            const signature = encode(await this.sign(decode(data), parameters), Encoding.Signature);
+            return { signature };
+          },
+          [METHODS.signDelegation]: async ({ delegation, onAccount = this.address }, origin) => {
+            if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
+            if (!this.addresses().includes(onAccount)) throw new RpcPermissionDenyError(onAccount);
+            const parameters = { onAccount, aeppOrigin: origin, aeppRpcClientId: id };
+            const signature = await this.signDelegation(delegation, parameters);
+            return { signature };
+          },
         },
       ),
     };

package/src/Middleware.ts

@@ -1,6 +1,7 @@
 // eslint-disable-next-line max-classes-per-file
 import BigNumber from 'bignumber.js';
-import { OperationArguments, OperationSpec } from '@azure/core-client';
+import { OperationArguments, OperationOptions, OperationSpec } from '@azure/core-client';
+import { userAgentPolicyName, setClientRequestIdPolicyName } from '@azure/core-rest-pipeline';
 import {
   genRequestQueuesPolicy, genCombineGetRequestsPolicy, genErrorFormatterPolicy,
   genVersionCheckPolicy, genRetryOnFailurePolicy,
@@ -105,7 +106,7 @@ export default class Middleware
   /**
    * @param url - Url for middleware API
    * @param options - Options
-   * @param options.ignoreVersion - Don't check node version
+   * @param options.ignoreVersion - Don't ensure that the middleware is supported
    * @param options.retryCount - Amount of extra requests to do in case of failure
    * @param options.retryOverallDelay - Time in ms to wait between all retries
    */
@@ -119,10 +120,20 @@ export default class Middleware
       retryOverallDelay?: number;
     } = {},
   ) {
+    let version: string | undefined;
+    const getVersion = async (opts: OperationOptions): Promise<string> => {
+      if (version != null) return version;
+      version = (await this.getStatus(opts)).mdwVersion;
+      return version;
+    };
+
     // eslint-disable-next-line constructor-super
     super(url, {
       allowInsecureConnection: true,
       additionalPolicies: [
+        ...ignoreVersion ? [] : [
+          genVersionCheckPolicy('middleware', getVersion, '1.47.0', '2.0.0'),
+        ],
         genRequestQueuesPolicy(),
         genCombineGetRequestsPolicy(),
         genRetryOnFailurePolicy(retryCount, retryOverallDelay),
@@ -130,12 +141,9 @@ export default class Middleware
       ],
       ...options,
     });
-    if (!ignoreVersion) {
-      const statusPromise = this.getStatus();
-      const versionPromise = statusPromise.then(({ mdwVersion }) => mdwVersion, (error) => error);
-      this.pipeline.addPolicy(
-        genVersionCheckPolicy('middleware', '/v2/status', versionPromise, '1.47.0', '2.0.0'),
-      );
-    }
+    this.pipeline.removePolicy({ name: userAgentPolicyName });
+    this.pipeline.removePolicy({ name: setClientRequestIdPolicyName });
+    // TODO: use instead our retry policy
+    this.pipeline.removePolicy({ name: 'defaultRetryPolicy' });
   }
 }

package/src/MiddlewareSubscriber.ts

@@ -35,7 +35,7 @@ export default class MiddlewareSubscriber {
   readonly [target: string, s: Source, cb: (p?: Object, e?: Error) => void]
   > = [];
 
-  #requestQueue: Array<[isSubscribe: boolean, target: string]> = [];
+  readonly #requestQueue: Array<[isSubscribe: boolean, target: string]> = [];
 
   #webSocket?: WebSocket;
 

package/src/Node.ts

@@ -1,19 +1,21 @@
 // eslint-disable-next-line max-classes-per-file
 import BigNumber from 'bignumber.js';
-import { OperationArguments, OperationSpec } from '@azure/core-client';
+import { OperationArguments, OperationOptions, OperationSpec } from '@azure/core-client';
+import { userAgentPolicyName, setClientRequestIdPolicyName } from '@azure/core-rest-pipeline';
 import {
   genRequestQueuesPolicy, genCombineGetRequestsPolicy, genErrorFormatterPolicy,
   genVersionCheckPolicy, genRetryOnFailurePolicy,
 } from './utils/autorest';
 import { Node as NodeApi, NodeOptionalParams, ErrorModel } from './apis/node';
 import { mapObject } from './utils/other';
+import { UnsupportedVersionError } from './utils/errors';
 import { Encoded } from './utils/encoder';
 import { ConsensusProtocolVersion } from './tx/builder/constants';
 
 const bigIntPropertyNames = [
   'balance', 'queryFee', 'fee', 'amount', 'nameFee', 'channelAmount',
   'initiatorAmount', 'responderAmount', 'channelReserve', 'initiatorAmountFinal',
-  'responderAmountFinal', 'gasPrice', 'deposit',
+  'responderAmountFinal', 'gasPrice', 'minGasPrice', 'deposit',
 ] as const;
 
 const numberPropertyNames = [
@@ -21,7 +23,7 @@ const numberPropertyNames = [
   'nonce', 'nextNonce', 'height', 'blockHeight', 'topBlockHeight',
   'ttl', 'nameTtl', 'clientTtl',
   'inbound', 'outbound', 'peerCount', 'pendingTransactionsCount', 'effectiveAtHeight',
-  'version', 'solutions', 'round',
+  'version', 'solutions', 'round', 'minutes', 'utilization', 'difficulty', 'hashrate',
 ] as const;
 
 class NodeTransformed extends NodeApi {
@@ -111,12 +113,10 @@ interface NodeInfo {
 }
 
 export default class Node extends (NodeTransformed as unknown as NodeTransformedApi) {
-  #networkIdPromise?: Promise<string | Error>;
-
   /**
    * @param url - Url for node API
    * @param options - Options
-   * @param options.ignoreVersion - Don't check node version
+   * @param options.ignoreVersion - Don't ensure that the node is supported
    * @param options.retryCount - Amount of extra requests to do in case of failure
    * @param options.retryOverallDelay - Time in ms to wait between all retries
    */
@@ -130,42 +130,63 @@ export default class Node extends (NodeTransformed as unknown as NodeTransformed
       retryOverallDelay?: number;
     } = {},
   ) {
+    const getVersion = async (opts: OperationOptions): Promise<string> => (
+      (await this._getCachedStatus(opts)).nodeVersion
+    );
     // eslint-disable-next-line constructor-super
     super(url, {
       allowInsecureConnection: true,
       additionalPolicies: [
+        ...ignoreVersion ? [] : [genVersionCheckPolicy('node', getVersion, '6.2.0', '7.0.0')],
         genRequestQueuesPolicy(),
         genCombineGetRequestsPolicy(),
         genRetryOnFailurePolicy(retryCount, retryOverallDelay),
-        genErrorFormatterPolicy((body: ErrorModel) => ` ${body.reason}`),
+        genErrorFormatterPolicy((body: ErrorModel) => [
+          ' ', body.reason, body.errorCode == null ? '' : ` (${body.errorCode})`,
+        ].join('')),
       ],
       ...options,
     });
-    if (!ignoreVersion) {
-      const statusPromise = this.getStatus();
-      const versionPromise = statusPromise.then(({ nodeVersion }) => nodeVersion, (error) => error);
-      this.#networkIdPromise = statusPromise.then(({ networkId }) => networkId, (error) => error);
-      this.pipeline.addPolicy(
-        genVersionCheckPolicy('node', '/v3/status', versionPromise, '6.2.0', '7.0.0'),
-      );
-    }
+    this.pipeline.removePolicy({ name: userAgentPolicyName });
+    this.pipeline.removePolicy({ name: setClientRequestIdPolicyName });
+    // TODO: use instead our retry policy
+    this.pipeline.removePolicy({ name: 'defaultRetryPolicy' });
     this.intAsString = true;
   }
 
+  #cachedStatusPromise?: ReturnType<Node['getStatus']>;
+
+  async _getCachedStatus(options?: OperationOptions): ReturnType<Node['getStatus']> {
+    if (this.#cachedStatusPromise != null) return this.#cachedStatusPromise;
+    return this.getStatus(options);
+  }
+
+  // eslint-disable-next-line rulesdir/tsdoc-syntax
+  /** @ts-expect-error use code generation to create node class? */
+  override async getStatus(
+    ...args: Parameters<InstanceType<NodeTransformedApi>['getStatus']>
+  ): ReturnType<InstanceType<NodeTransformedApi>['getStatus']> {
+    const promise = super.getStatus(...args);
+    promise.then(() => { this.#cachedStatusPromise = promise; }, () => {});
+    return promise;
+  }
+
+  /**
+   * Returns network ID provided by node.
+   * This method won't do extra requests on subsequent calls.
+   */
   async getNetworkId(): Promise<string> {
-    this.#networkIdPromise ??= this.getStatus().then(({ networkId }) => networkId);
-    const networkId = await this.#networkIdPromise;
-    if (networkId instanceof Error) throw networkId;
-    return networkId;
+    return (await this._getCachedStatus()).networkId;
   }
 
   async getNodeInfo(): Promise<NodeInfo> {
     const {
-      nodeVersion: version,
+      nodeVersion,
       networkId: nodeNetworkId,
       protocols,
       topBlockHeight,
     } = await this.getStatus();
+
     const consensusProtocolVersion = protocols
       .filter(({ effectiveAtHeight }) => topBlockHeight >= effectiveAtHeight)
       .reduce(
@@ -173,10 +194,19 @@ export default class Node extends (NodeTransformed as unknown as NodeTransformed
         { effectiveAtHeight: -1, version: 0 },
       )
       .version;
+    if (ConsensusProtocolVersion[consensusProtocolVersion] == null) {
+      const version = consensusProtocolVersion.toString();
+      const versions = Object.values(ConsensusProtocolVersion)
+        .filter((el) => typeof el === 'number').map((el) => +el);
+      const geVersion = Math.min(...versions).toString();
+      const ltVersion = (Math.max(...versions) + 1).toString();
+      throw new UnsupportedVersionError('consensus protocol', version, geVersion, ltVersion);
+    }
+
     return {
       url: this.$host,
       nodeNetworkId,
-      version,
+      version: nodeVersion,
       consensusProtocolVersion,
     };
   }

package/src/account/Base.ts

@@ -1,7 +1,7 @@
 import { Encoded } from '../utils/encoder';
 import Node from '../Node';
 import CompilerBase from '../contract/compiler/Base';
-import { AensName, Int } from '../tx/builder/constants';
+import { AensName, ConsensusProtocolVersion, Int } from '../tx/builder/constants';
 import { AciValue, Domain } from '../utils/typed-data';
 import { NotImplementedError } from '../utils/errors';
 
@@ -56,8 +56,8 @@ export default abstract class AccountBase {
 
   /**
    * Sign typed data
-   * @param type - Type of data to sign
    * @param data - Encoded data to sign
+   * @param aci - Type of data to sign
    * @param options - Options
    * @returns Signature
    */
@@ -80,7 +80,10 @@ export default abstract class AccountBase {
    * Sign delegation of AENS, oracle operations to a contract
    * @param contractAddress - Address of a contract to delegate permissions to
    * @param options - Options
+   * @param options.isOracle - Use to generate an oracle delegation signature in Ceres, otherwise an
+   * AENS preclaim delegation signature would be generated
    * @returns Signature
+   * @deprecated use AccountBase:signDelegation in Ceres
    */
   // TODO: make abstract in the next major release
   // eslint-disable-next-line class-methods-use-this
@@ -89,6 +92,8 @@ export default abstract class AccountBase {
     contractAddress: Encoded.ContractAddress,
     options?: {
       networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
+      isOracle?: boolean;
       aeppOrigin?: string;
       aeppRpcClientId?: string;
     },
@@ -103,6 +108,7 @@ export default abstract class AccountBase {
    * @param name - AENS name to manage by a contract
    * @param options - Options
    * @returns Signature
+   * @deprecated use AccountBase:signDelegation in Ceres
    */
   // TODO: make abstract in the next major release
   // eslint-disable-next-line class-methods-use-this
@@ -112,6 +118,7 @@ export default abstract class AccountBase {
     name: AensName,
     options?: {
       networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
       aeppOrigin?: string;
       aeppRpcClientId?: string;
     },
@@ -120,6 +127,29 @@ export default abstract class AccountBase {
     throw new NotImplementedError('signNameDelegationToContract method');
   }
 
+  /**
+   * Sign delegation of all AENS names to a contract (not available in Iris)
+   * @param contractAddress - Address of a contract to delegate permissions to
+   * @param options - Options
+   * @returns Signature
+   * @deprecated use AccountBase:signDelegation in Ceres
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signAllNamesDelegationToContract(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    contractAddress: Encoded.ContractAddress,
+    options?: {
+      networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signAllNamesDelegationToContract method');
+  }
+
   /**
    * Sign delegation of oracle query to a contract
    *
@@ -133,6 +163,7 @@ export default abstract class AccountBase {
    * @param oracleQueryId - Oracle query ID to reply by a contract
    * @param options - Options
    * @returns Signature
+   * @deprecated use AccountBase:signDelegation in Ceres
    */
   // TODO: make abstract in the next major release
   // eslint-disable-next-line class-methods-use-this
@@ -142,6 +173,7 @@ export default abstract class AccountBase {
     oracleQueryId: Encoded.OracleQueryId,
     options?: {
       networkId?: string;
+      consensusProtocolVersion?: ConsensusProtocolVersion;
       aeppOrigin?: string;
       aeppRpcClientId?: string;
     },
@@ -156,10 +188,37 @@ export default abstract class AccountBase {
    * @param options - Options
    * @returns Signature
    */
-  abstract sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;
+  abstract sign(
+    data: string | Uint8Array,
+    options?: {
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+  ): Promise<Uint8Array>;
 
   /**
    * Account address
    */
   readonly address!: Encoded.AccountAddress;
+
+  /**
+   * Sign delegation, works only in Ceres
+   * @param delegation - Delegation to sign
+   * @param options - Options
+   * @returns Signature
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signDelegation(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    delegation: Encoded.Bytearray,
+    options?: {
+      networkId?: string;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signDelegation method');
+  }
 }

package/src/account/Generalized.ts

@@ -53,11 +53,21 @@ export default class AccountGeneralized extends AccountBase {
     throw new NotImplementedError('signing delegation to contract using generalized account');
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  override async signAllNamesDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using generalized account');
+  }
+
   // eslint-disable-next-line class-methods-use-this
   override async signOracleQueryDelegationToContract(): Promise<Encoded.Signature> {
     throw new NotImplementedError('signing delegation to contract using generalized account');
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  override async signDelegation(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation using generalized account');
+  }
+
   override async signTransaction(
     tx: Encoded.Transaction,
     { authData, onCompiler, onNode }: Parameters<AccountBase['signTransaction']>[1],

package/src/account/Ledger.ts

@@ -55,11 +55,21 @@ export default class AccountLedger extends AccountBase {
     throw new NotImplementedError('signing delegation to contract using Ledger HW');
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  override async signAllNamesDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using Ledger HW');
+  }
+
   // eslint-disable-next-line class-methods-use-this
   override async signOracleQueryDelegationToContract(): Promise<Encoded.Signature> {
     throw new NotImplementedError('signing delegation to contract using Ledger HW');
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  override async signDelegation(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation using Ledger HW');
+  }
+
   override async signTransaction(
     tx: Encoded.Transaction,
     { innerTx, networkId }: { innerTx?: boolean; networkId?: string } = {},