@aeternity/aepp-sdk 12.1.3 → 13.0.0-alpha.1

package/src/AeSdkMethods.ts

@@ -0,0 +1,169 @@
+import * as chainMethods from './chain';
+import * as aensMethods from './aens';
+import * as spendMethods from './spend';
+import * as oracleMethods from './oracle';
+import Contract, { ContractMethodsBase } from './contract/Contract';
+import * as contractGaMethods from './contract/ga';
+import { _buildTx } from './tx';
+import { mapObject, UnionToIntersection } from './utils/other';
+import Node from './Node';
+import { AE_AMOUNT_FORMATS } from './utils/amount-formatter';
+import { Tag } from './tx/builder/constants';
+import AccountBase from './account/Base';
+import { Encoded } from './utils/encoder';
+import CompilerBase from './contract/compiler/Base';
+import { ArgumentError, NotImplementedError, TypeError } from './utils/errors';
+
+export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
+
+export function getValueOrErrorProxy<Value extends object>(valueCb: () => Value): Value {
+  return new Proxy({}, {
+    ...Object.fromEntries([
+      'apply', 'construct', 'defineProperty', 'deleteProperty', 'getOwnPropertyDescriptor',
+      'getPrototypeOf', 'isExtensible', 'ownKeys', 'preventExtensions', 'set', 'setPrototypeOf',
+    ].map((name) => [name, () => { throw new NotImplementedError(`${name} proxy request`); }])),
+    get(t: {}, property: string | symbol, receiver: any) {
+      const target = valueCb();
+      const value = Reflect.get(target, property, receiver);
+      return typeof value === 'function' ? value.bind(target) : value;
+    },
+    has(t: {}, property: string | symbol) {
+      return Reflect.has(valueCb(), property);
+    },
+  }) as Value;
+}
+
+const { InvalidTxError: _2, ...chainMethodsOther } = chainMethods;
+
+const methods = {
+  ...chainMethodsOther,
+  ...aensMethods,
+  ...spendMethods,
+  ...oracleMethods,
+  ...contractGaMethods,
+} as const;
+
+type Decrement<Number extends number> = [-1, 0, 1, 2, 3, 4, 5][Number];
+type GetMethodsOptions <Methods extends { [key: string]: Function }> =
+  {
+    [Name in keyof Methods]:
+    Methods[Name] extends (...args: infer Args) => any
+      ? Args[Decrement<Args['length']>] : never
+  };
+type MethodsOptions = GetMethodsOptions<typeof methods>;
+interface AeSdkMethodsOptions
+  extends Partial<UnionToIntersection<MethodsOptions[keyof MethodsOptions]>> {
+  nodes?: Array<{ name: string; instance: Node }>;
+}
+
+/**
+ * AeSdkMethods is the composition of:
+ * - chain methods
+ * - tx methods
+ * - aens methods
+ * - spend methods
+ * - oracle methods
+ * - contract methods
+ * - contract ga methods
+ *
+ * While these methods can be used separately, this class provides a handy way to store
+ * their context (current account, network, and compiler to use).
+ */
+class AeSdkMethods {
+  _options: AeSdkMethodsOptions = { denomination: AE_AMOUNT_FORMATS.AETTOS };
+
+  /**
+   * @param options - Options
+   */
+  constructor(options: AeSdkMethodsOptions = {}) {
+    Object.assign(this._options, options);
+  }
+
+  /**
+   * Resolves an account
+   * @param account - ak-address, instance of AccountBase, or keypair
+   */
+  // eslint-disable-next-line class-methods-use-this
+  _resolveAccount(account?: OnAccount): AccountBase {
+    if (typeof account === 'string') throw new NotImplementedError('Address in AccountResolver');
+    if (typeof account === 'object') return account;
+    throw new TypeError(
+      'Account should be an address (ak-prefixed string), '
+      + `or instance of AccountBase, got ${String(account)} instead`,
+    );
+  }
+
+  _getOptions(): AeSdkMethodsOptions & { onAccount: AccountBase } {
+    return {
+      ...this._options,
+      onAccount: getValueOrErrorProxy(() => this._resolveAccount()),
+    };
+  }
+
+  async buildTx<TxType extends Tag>(
+    txType: TxType,
+    options: Omit<Parameters<typeof _buildTx<TxType>>[1], 'onNode'> & { onNode?: Node },
+  ): Promise<Encoded.Transaction> {
+    // @ts-expect-error TODO: need to figure out what's wrong here
+    return _buildTx<TxType>(txType, {
+      ...this._getOptions(),
+      ...options,
+    });
+  }
+
+  async initializeContract<Methods extends ContractMethodsBase>(
+    options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & { onNode?: Node },
+  ): Promise<Contract<Methods>> {
+    const { onNode, onCompiler, ...otherOptions } = this._getOptions();
+    if (onCompiler == null || onNode == null) {
+      throw new ArgumentError('onCompiler, onNode', 'provided', null);
+    }
+    return Contract.initialize<Methods>({
+      ...otherOptions,
+      onNode,
+      onCompiler,
+      ...options,
+    });
+  }
+}
+
+type RequiredKeys<T> = {
+  [K in keyof T]-?: {} extends Pick<T, K> ? never : K
+}[keyof T];
+
+type OptionalIfNotRequired<T extends [any]> = RequiredKeys<T[0]> extends never ? T | [] : T;
+
+type MakeOptional<Options> = OptionalIfNotRequired<[
+  Omit<Options, 'onNode' | 'onCompiler' | 'onAccount'>
+  & { onNode?: Node; onCompiler?: CompilerBase; onAccount?: OnAccount },
+]>;
+
+type TransformMethods <Methods extends { [key: string]: Function }> =
+  {
+    [Name in keyof Methods]:
+    Methods[Name] extends (...args: [...infer Args, infer Options]) => infer Ret
+      ? (...args: [...Args, ...MakeOptional<Options>]) => Ret
+      : never
+  };
+
+interface AeSdkMethodsTransformed extends TransformMethods<typeof methods> {}
+
+Object.assign(AeSdkMethods.prototype, mapObject<Function, Function>(
+  methods,
+  ([name, handler]) => [
+    name,
+    function methodWrapper(...args: any[]) {
+      args.length = handler.length;
+      const options = args[args.length - 1];
+      args[args.length - 1] = {
+        ...this._getOptions(),
+        ...options,
+        ...options?.onAccount != null && { onAccount: this._resolveAccount(options.onAccount) },
+      };
+      return handler(...args);
+    },
+  ],
+));
+
+export default AeSdkMethods as new (options?: ConstructorParameters<typeof AeSdkMethods>[0]) =>
+AeSdkMethods & AeSdkMethodsTransformed;

package/src/AeSdkWallet.ts

@@ -1,6 +1,5 @@
 import { v4 as uuid } from '@aeternity/uuid';
 import AeSdk from './AeSdk';
-import { Account } from './AeSdkBase';
 import verifyTransaction from './tx/validator';
 import RpcClient from './aepp-wallet-communication/rpc/RpcClient';
 import {
@@ -32,10 +31,6 @@ type OnSubscription = (
   clientId: string, params: Parameters<WalletApi[METHODS.subscribeAddress]>[0], origin: string
 ) => void;
 
-type OnSign = (
-  clientId: string, params: Parameters<WalletApi[METHODS.sign]>[0], origin: string
-) => Promise<{ tx?: Encoded.Transaction; onAccount?: Account } | undefined> | Promise<void>;
-
 type OnDisconnect = (
   clientId: string, params: Parameters<WalletApi[METHODS.closeConnection]>[0]
 ) => void;
@@ -44,10 +39,6 @@ type OnAskAccounts = (
   clientId: string, params: undefined, origin: string
 ) => void;
 
-type OnMessageSign = (
-  clientId: string, params: Parameters<WalletApi[METHODS.signMessage]>[0], origin: string
-) => Promise<{ onAccount?: Account } | undefined> | Promise<void>;
-
 interface RpcClientsInfo {
   id: string;
   status: RPC_STATUS;
@@ -67,20 +58,16 @@ export default class AeSdkWallet extends AeSdk {
 
   name: string;
 
-  _clients: Map<string, RpcClientsInfo>;
+  _clients = new Map<string, RpcClientsInfo>();
 
   onConnection: OnConnection;
 
   onSubscription: OnSubscription;
 
-  onSign: OnSign;
-
   onDisconnect: OnDisconnect;
 
   onAskAccounts: OnAskAccounts;
 
-  onMessageSign: OnMessageSign;
-
   /**
    * @param options - Options
    * @param options.name - Wallet name
@@ -88,9 +75,7 @@ export default class AeSdkWallet extends AeSdk {
    * @param options.type - Wallet type
    * @param options.onConnection - Call-back function for incoming AEPP connection
    * @param options.onSubscription - Call-back function for incoming AEPP account subscription
-   * @param options.onSign - Call-back function for incoming AEPP sign request
    * @param options.onAskAccounts - Call-back function for incoming AEPP get address request
-   * @param options.onMessageSign - Call-back function for incoming AEPP sign message request
    * @param options.onDisconnect - Call-back function for disconnect event
    */
   constructor({
@@ -99,10 +84,8 @@ export default class AeSdkWallet extends AeSdk {
     type,
     onConnection,
     onSubscription,
-    onSign,
     onDisconnect,
     onAskAccounts,
-    onMessageSign,
     ...options
   }: {
     id: string;
@@ -110,52 +93,45 @@ export default class AeSdkWallet extends AeSdk {
     name: string;
     onConnection: OnConnection;
     onSubscription: OnSubscription;
-    onSign: OnSign;
     onDisconnect: OnDisconnect;
     onAskAccounts: OnAskAccounts;
-    onMessageSign: OnMessageSign;
   } & ConstructorParameters<typeof AeSdk>[0]) {
     super(options);
     this.onConnection = onConnection;
     this.onSubscription = onSubscription;
-    this.onSign = onSign;
     this.onDisconnect = onDisconnect;
     this.onAskAccounts = onAskAccounts;
-    this.onMessageSign = onMessageSign;
-    this._clients = new Map();
     this.name = name;
     this.id = id;
     this._type = type;
   }
 
   _pushAccountsToApps(): void {
+    if (this._clients == null) return;
     Array.from(this._clients.keys())
       .filter((clientId) => this._isRpcClientSubscribed(clientId))
       .map((clientId) => this._getClient(clientId).rpc)
       .forEach((client) => client.notify(METHODS.updateAddress, this.getAccounts()));
   }
 
-  selectAccount(address: Encoded.AccountAddress): void {
+  override selectAccount(address: Encoded.AccountAddress): void {
     super.selectAccount(address);
     this._pushAccountsToApps();
   }
 
-  async addAccount(
-    account: AccountBase,
-    options?: Parameters<AeSdk['addAccount']>[1],
-  ): Promise<void> {
-    await super.addAccount(account, options);
+  override addAccount(account: AccountBase, options?: Parameters<AeSdk['addAccount']>[1]): void {
+    super.addAccount(account, options);
     this._pushAccountsToApps();
   }
 
   _getNode(): { node: Network['node'] } {
     this.ensureNodeConnected();
-    return { node: { url: this.api.url, name: this.selectedNodeName } };
+    return { node: { url: this.api.$host, name: this.selectedNodeName } };
   }
 
-  async selectNode(name: string): Promise<void> {
+  override async selectNode(name: string): Promise<void> {
     super.selectNode(name);
-    const networkId = await this.getNetworkId();
+    const networkId = await this.api.getNetworkId();
     Array.from(this._clients.keys())
       .filter((clientId) => this._isRpcClientConnected(clientId))
       .map((clientId) => this._getClient(clientId))
@@ -266,22 +242,19 @@ export default class AeSdkWallet extends AeSdk {
             await this.onAskAccounts(id, params, origin);
             return this.addresses();
           },
-          [METHODS.sign]: async ({ tx, onAccount, returnSigned }, origin) => {
+          [METHODS.sign]: async ({ tx, onAccount = this.address, returnSigned }, origin) => {
             if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
-            onAccount ??= await this.address();
             if (!this.addresses().includes(onAccount)) {
               throw new RpcPermissionDenyError(onAccount);
             }
 
-            const overrides = await this.onSign(id, { tx, returnSigned, onAccount }, origin);
-            onAccount = overrides?.onAccount ?? onAccount;
-            tx = overrides?.tx ?? tx;
+            const parameters = { onAccount, aeppOrigin: origin, aeppRpcClientId: id };
             if (returnSigned) {
-              return { signedTransaction: await this.signTransaction(tx, { onAccount }) };
+              return { signedTransaction: await this.signTransaction(tx, parameters) };
             }
             try {
               return jsonBig.parse(jsonBig.stringify({
-                transactionHash: await this.send(tx, { onAccount, verify: false }),
+                transactionHash: await this.send(tx, { ...parameters, verify: false }),
               }));
             } catch (error) {
               const validation = await verifyTransaction(tx, this.api);
@@ -289,19 +262,15 @@ export default class AeSdkWallet extends AeSdk {
               throw new RpcBroadcastError(error.message);
             }
           },
-          [METHODS.signMessage]: async ({ message, onAccount }, origin) => {
+          [METHODS.signMessage]: async ({ message, onAccount = this.address }, origin) => {
             if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
-            onAccount ??= await this.address();
             if (!this.addresses().includes(onAccount)) {
               throw new RpcPermissionDenyError(onAccount);
             }
 
-            const overrides = await this.onMessageSign(id, { message, onAccount }, origin);
-            onAccount = overrides?.onAccount ?? onAccount;
+            const parameters = { onAccount, aeppOrigin: origin, aeppRpcClientId: id };
             return {
-              // TODO: fix signMessage return type
-              signature: await this.signMessage(message, { onAccount, returnHex: true }) as
-                unknown as string,
+              signature: Buffer.from(await this.signMessage(message, parameters)).toString('hex'),
             };
           },
         },
@@ -327,7 +296,7 @@ export default class AeSdkWallet extends AeSdk {
     return {
       id: this.id,
       name: this.name,
-      networkId: await this.getNetworkId(),
+      networkId: await this.api.getNetworkId(),
       origin: window.location.origin,
       type: this._type,
     };

package/src/Node.ts

@@ -8,16 +8,7 @@ import {
 import { Node as NodeApi, NodeOptionalParams, ErrorModel } from './apis/node';
 import { mapObject } from './utils/other';
 import { Encoded } from './utils/encoder';
-import { MissingParamError } from './utils/errors';
-
-/**
- * Obtain networkId from account or node
- */
-export async function getNetworkId({ networkId }: { networkId?: string } = {}): Promise<string> {
-  const res = networkId ?? this.networkId ?? (await this.api?.getStatus())?.networkId;
-  if (res != null) return res;
-  throw new MissingParamError('networkId is not provided');
-}
+import { ConsensusProtocolVersion } from './tx/builder/constants';
 
 const bigIntPropertyNames = [
   'balance', 'queryFee', 'fee', 'amount', 'nameFee', 'channelAmount',
@@ -27,14 +18,14 @@ const bigIntPropertyNames = [
 
 const numberPropertyNames = [
   'time', 'gas', 'gasUsed', 'nameSalt',
-  'nonce', 'nextNonce', 'height', 'blockHeight', 'top', 'topBlockHeight',
+  'nonce', 'nextNonce', 'height', 'blockHeight', 'topBlockHeight',
   'ttl', 'nameTtl', 'clientTtl',
   'inbound', 'outbound', 'peerCount', 'pendingTransactionsCount', 'effectiveAtHeight',
   'version', 'solutions', 'round',
 ] as const;
 
 class NodeTransformed extends NodeApi {
-  async sendOperationRequest(
+  override async sendOperationRequest(
     operationArguments: OperationArguments,
     operationSpec: OperationSpec,
   ): Promise<any> {
@@ -101,7 +92,9 @@ export type TransformNodeType<Type> =
                   ? PreserveOptional<number, Type[Property]>
                   : Property extends 'txHash'
                     ? PreserveOptional<Encoded.TxHash, Type[Property]>
-                    : TransformNodeType<Type[Property]>
+                    : Property extends 'bytecode'
+                      ? PreserveOptional<Encoded.ContractBytearray, Type[Property]>
+                      : TransformNodeType<Type[Property]>
             }
             : Type;
 type NodeTransformedApi = new (...args: ConstructorParameters<typeof NodeApi>) => {
@@ -114,11 +107,11 @@ export interface NodeInfo {
   url: string;
   nodeNetworkId: string;
   version: string;
-  consensusProtocolVersion: number;
+  consensusProtocolVersion: ConsensusProtocolVersion;
 }
 
 export default class Node extends (NodeTransformed as unknown as NodeTransformedApi) {
-  url: string;
+  #networkIdPromise?: Promise<string>;
 
   /**
    * @param url - Url for node API
@@ -139,9 +132,10 @@ export default class Node extends (NodeTransformed as unknown as NodeTransformed
       ],
       ...options,
     });
-    this.url = url;
     if (!ignoreVersion) {
-      const versionPromise = this.getStatus().then(({ nodeVersion }) => nodeVersion);
+      const statusPromise = this.getStatus();
+      const versionPromise = statusPromise.then(({ nodeVersion }) => nodeVersion);
+      this.#networkIdPromise = statusPromise.then(({ networkId }) => networkId);
       this.pipeline.addPolicy(
         genVersionCheckPolicy('node', '/v3/status', versionPromise, '6.2.0', '7.0.0'),
       );
@@ -149,6 +143,11 @@ export default class Node extends (NodeTransformed as unknown as NodeTransformed
     this.intAsString = true;
   }
 
+  async getNetworkId(): Promise<string> {
+    this.#networkIdPromise ??= this.getStatus().then(({ networkId }) => networkId);
+    return this.#networkIdPromise;
+  }
+
   async getNodeInfo(): Promise<NodeInfo> {
     const {
       nodeVersion: version,
@@ -164,7 +163,7 @@ export default class Node extends (NodeTransformed as unknown as NodeTransformed
       )
       .version;
     return {
-      url: this.url,
+      url: this.$host,
       nodeNetworkId,
       version,
       consensusProtocolVersion,

package/src/account/Base.ts

@@ -14,99 +14,54 @@
  *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  *  PERFORMANCE OF THIS SOFTWARE.
  */
-import { messageToHash, verifyMessage as verifyMessageCrypto, hash } from '../utils/crypto';
-import { buildTx } from '../tx/builder';
-import { decode, Encoded } from '../utils/encoder';
-import { Tag } from '../tx/builder/constants';
-import { getNetworkId } from '../Node';
-import { concatBuffers } from '../utils/other';
-import type { createMetaTx } from '../contract/ga';
-
-/**
- * Check is provided object looks like an instance of AccountBase
- * @param acc - Object to check
- */
-export const isAccountBase = (acc: AccountBase | any): boolean => (
-  !['sign', 'address', 'signTransaction', 'signMessage'].some((f) => typeof acc[f] !== 'function')
-);
+import { Encoded } from '../utils/encoder';
+import Node from '../Node';
+import CompilerBase from '../contract/compiler/Base';
 
 /**
  * Account is one of the three basic building blocks of an
  * {@link AeSdk} and provides access to a signing key pair.
  */
 export default abstract class AccountBase {
-  networkId?: string;
-
-  /**
-   * @param options - Options
-   * @param options.networkId - Using for signing transactions
-   */
-  constructor({ networkId }: { networkId?: string } = {}) {
-    this.networkId ??= networkId;
-  }
-
   /**
    * Sign encoded transaction
    * @param tx - Transaction to sign
-   * @param opt - Options
-   * @param opt.innerTx - Sign as inner transaction for PayingFor
+   * @param options - Options
+   * @param options.innerTx - Sign as inner transaction for PayingFor
+   * @param options.authData - Object with gaMeta params
    * @returns Signed transaction
    */
-  async signTransaction(
+  abstract signTransaction(
     tx: Encoded.Transaction,
-    { innerTx, networkId, ...options }: {
+    options: {
       innerTx?: boolean;
       networkId?: string;
-      authData?: Parameters<typeof createMetaTx>[1];
-      authFun?: Parameters<typeof createMetaTx>[2];
-    } & Omit<Partial<Parameters<typeof createMetaTx>[3]>, 'onAccount'> = {},
-  ): Promise<Encoded.Transaction> {
-    const prefixes = [await this.getNetworkId({ networkId })];
-    if (innerTx === true) prefixes.push('inner_tx');
-    const rlpBinaryTx = decode(tx);
-    const txWithNetworkId = concatBuffers([Buffer.from(prefixes.join('-')), hash(rlpBinaryTx)]);
-
-    const signatures = [await this.sign(txWithNetworkId, options)];
-    return buildTx({ encodedTx: rlpBinaryTx, signatures }, Tag.SignedTx).tx;
-  }
-
-  /**
-   * Get network Id
-   * @returns Network Id
-   */
-  readonly getNetworkId = getNetworkId;
+      authData?: {
+        gasLimit?: number;
+        callData?: Encoded.ContractBytearray;
+        sourceCode?: string;
+        args?: any[];
+      };
+      onNode?: Node;
+      onCompiler?: CompilerBase;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+  ): Promise<Encoded.Transaction>;
 
   /**
    * Sign message
    * @param message - Message to sign
-   * @param opt - Options
-   * @returns Signature as hex string of Uint8Array
-   */
-  async signMessage(
-    message: string,
-    { returnHex = false, ...options }: { returnHex?: boolean } = {},
-  ): Promise<string | Uint8Array> {
-    const sig = await this.sign(messageToHash(message), options);
-    return returnHex ? Buffer.from(sig).toString('hex') : sig;
-  }
-
-  /**
-   * Verify message
-   * @param message - Message to verify
-   * @param signature - Signature
    * @param options - Options
+   * @returns Signature as hex string of Uint8Array
    */
-  async verifyMessage(
+  abstract signMessage(
     message: string,
-    signature: string | Uint8Array,
-    options?: object,
-  ): Promise<boolean> {
-    return verifyMessageCrypto(
-      message,
-      typeof signature === 'string' ? Buffer.from(signature, 'hex') : signature,
-      decode(await this.address(options)),
-    );
-  }
+    options?: {
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+  ): Promise<Uint8Array>;
 
   /**
    * Sign data blob
@@ -117,8 +72,7 @@ export default abstract class AccountBase {
   abstract sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;
 
   /**
-   * Obtain account address
-   * @returns Public account address
+   * Account address
    */
-  abstract address(opt?: object): Promise<Encoded.AccountAddress>;
+  readonly address: Encoded.AccountAddress;
 }

package/src/account/Generalized.ts

@@ -0,0 +1,98 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+import AccountBase from './Base';
+import {
+  ArgumentError,
+  InternalError,
+  InvalidAuthDataError,
+  NotImplementedError,
+} from '../utils/errors';
+import { decode, Encoded } from '../utils/encoder';
+import { getAccount } from '../chain';
+import Contract from '../contract/Contract';
+import { _buildTx } from '../tx';
+import { Tag } from '../tx/builder/constants';
+import { buildTx } from '../tx/builder';
+
+/**
+ * Generalized account class
+ */
+export default class AccountGeneralized extends AccountBase {
+  override readonly address: Encoded.AccountAddress;
+
+  #authFun?: string;
+
+  /**
+   * @param address - Address of generalized account
+   */
+  constructor(address: Encoded.AccountAddress) {
+    super();
+    decode(address);
+    this.address = address;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async sign(): Promise<Uint8Array> {
+    throw new NotImplementedError('Can\'t sign using generalized account');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signMessage(): Promise<Uint8Array> {
+    throw new NotImplementedError('Can\'t sign using generalized account');
+  }
+
+  override async signTransaction(
+    tx: Encoded.Transaction,
+    { authData, onCompiler, onNode }: Parameters<AccountBase['signTransaction']>[1],
+  ): Promise<Encoded.Transaction> {
+    if (authData == null || onCompiler == null || onNode == null) {
+      throw new ArgumentError('authData, onCompiler, onNode', 'provided', null);
+    }
+    const {
+      callData, sourceCode, args, gasLimit,
+    } = authData;
+
+    const authCallData = callData ?? await (async () => {
+      if (this.#authFun == null) {
+        const account = await getAccount(this.address, { onNode });
+        if (account.kind !== 'generalized') {
+          throw new ArgumentError('account kind', 'generalized', account.kind);
+        }
+        this.#authFun = account.authFun;
+      }
+      if (this.#authFun == null) {
+        throw new InternalError('Account in generalised, but authFun not provided');
+      }
+
+      if (sourceCode == null || args == null) {
+        throw new InvalidAuthDataError('Auth data must contain source code and arguments.');
+      }
+      const contract = await Contract.initialize({ onCompiler, onNode, sourceCode });
+      return contract._calldata.encode(contract._name, this.#authFun, args);
+    })();
+
+    const gaMetaTx = await _buildTx(Tag.GaMetaTx, {
+      tx: decode(buildTx({ tag: Tag.SignedTx, encodedTx: decode(tx), signatures: [] })),
+      gaId: this.address,
+      authData: authCallData,
+      gasLimit,
+      nonce: 0,
+      onNode,
+    });
+    return buildTx({ tag: Tag.SignedTx, encodedTx: decode(gaMetaTx), signatures: [] });
+  }
+}