@aeternity/aepp-sdk 10.0.0 → 12.0.0

package/src/AeSdkWallet.ts

@@ -0,0 +1,332 @@
+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 {
+  METHODS, RPC_STATUS, SUBSCRIPTION_TYPES, WALLET_TYPE,
+  RpcBroadcastError, RpcInvalidTransactionError,
+  RpcNotAuthorizeError, RpcPermissionDenyError, RpcUnsupportedProtocolError
+} from './aepp-wallet-communication/schema'
+import { UnknownRpcClientError } from './utils/errors'
+import AccountBase from './account/Base'
+import BrowserConnection from './aepp-wallet-communication/connection/Browser'
+import {
+  Accounts,
+  AeppApi,
+  Network,
+  RPC_VERSION,
+  WalletApi,
+  WalletInfo
+} from './aepp-wallet-communication/rpc/types'
+import { EncodedData } from './utils/encoder'
+import jsonBig from './utils/json-big'
+
+type RpcClientWallet = RpcClient<AeppApi, WalletApi>
+
+type OnConnection = (
+  clientId: string, params: Omit<Parameters<WalletApi[METHODS.connect]>[0], 'version'>, origin: string
+) => void
+
+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?: EncodedData<'tx'>, onAccount?: Account } | undefined> | Promise<void>
+
+type OnDisconnect = (
+  clientId: string, params: Parameters<WalletApi[METHODS.closeConnection]>[0]
+) => void
+
+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
+  connectNode: boolean
+  addressSubscription: Set<'connected' | 'current'>
+  rpc: RpcClientWallet
+}
+
+/**
+ * Contain functionality for aepp interaction and managing multiple aepps
+ */
+export default class AeSdkWallet extends AeSdk {
+  id: string
+  _type: WALLET_TYPE
+  name: string
+  _clients: Map<string, RpcClientsInfo>
+  onConnection: OnConnection
+  onSubscription: OnSubscription
+  onSign: OnSign
+  onDisconnect: OnDisconnect
+  onAskAccounts: OnAskAccounts
+  onMessageSign: OnMessageSign
+
+  /**
+   * @param options - Options
+   * @param options.name - Wallet name
+   * @param options.id - Wallet id
+   * @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 ({
+    name,
+    id,
+    type,
+    onConnection,
+    onSubscription,
+    onSign,
+    onDisconnect,
+    onAskAccounts,
+    onMessageSign,
+    ...options
+  }: {
+    id: string
+    type: WALLET_TYPE
+    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 {
+    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: EncodedData<'ak'>): void {
+    super.selectAccount(address)
+    this._pushAccountsToApps()
+  }
+
+  async addAccount (
+    account: AccountBase,
+    options?: Parameters<AeSdk['addAccount']>[1]
+  ): Promise<void> {
+    await super.addAccount(account, options)
+    this._pushAccountsToApps()
+  }
+
+  _getNode (): { node: Network['node'] } {
+    this.ensureNodeConnected()
+    return { node: { url: this.api.url, name: this.selectedNodeName } }
+  }
+
+  async selectNode (name: string): Promise<void> {
+    super.selectNode(name)
+    const networkId = await this.getNetworkId()
+    Array.from(this._clients.keys())
+      .filter(clientId => this._isRpcClientConnected(clientId))
+      .map(clientId => this._getClient(clientId))
+      .forEach(client => {
+        client.rpc.notify(METHODS.updateNetwork, {
+          networkId,
+          ...client.connectNode && this._getNode()
+        })
+      })
+  }
+
+  _getClient (clientId: string): RpcClientsInfo {
+    const client = this._clients.get(clientId)
+    if (client == null) throw new UnknownRpcClientError(clientId)
+    return client
+  }
+
+  _isRpcClientSubscribed (clientId: string): boolean {
+    return this._isRpcClientConnected(clientId) &&
+      this._getClient(clientId).addressSubscription.size !== 0
+  }
+
+  _isRpcClientConnected (clientId: string): boolean {
+    return RPC_STATUS.CONNECTED === this._getClient(clientId).status &&
+      this._getClient(clientId).rpc.connection.isConnected()
+  }
+
+  _disconnectRpcClient (clientId: string): void {
+    const client = this._getClient(clientId)
+    client.rpc.connection.disconnect()
+    client.status = RPC_STATUS.DISCONNECTED
+    client.addressSubscription = new Set()
+  }
+
+  /**
+   * Remove specific RpcClient by ID
+   * @param id - Client ID
+   */
+  removeRpcClient (id: string): void {
+    this._disconnectRpcClient(id)
+    this._clients.delete(id)
+  }
+
+  /**
+   * Add new client by AEPP connection
+   * @param clientConnection - AEPP connection object
+   * @returns Client ID
+   */
+  addRpcClient (clientConnection: BrowserConnection): string {
+    // @TODO  detect if aepp has some history based on origin????
+    // if yes use this instance for connection
+    const id = uuid()
+    let disconnectParams: any
+    const client: RpcClientsInfo = {
+      id,
+      status: RPC_STATUS.WAITING_FOR_CONNECTION_REQUEST,
+      addressSubscription: new Set(),
+      connectNode: false,
+      rpc: new RpcClient<AeppApi, WalletApi>(
+        clientConnection,
+        () => {
+          this._clients.delete(id)
+          this.onDisconnect(id, disconnectParams) // also related info
+        }, {
+          [METHODS.closeConnection]: (params) => {
+            disconnectParams = params
+            this._disconnectRpcClient(id)
+          },
+          // Store client info and prepare two fn for each client `connect` and `denyConnection`
+          // which automatically prepare and send response for that client
+          [METHODS.connect]: async ({ name, version, icons, connectNode }, origin) => {
+            if (version !== RPC_VERSION) throw new RpcUnsupportedProtocolError()
+
+            await this.onConnection(id, { name, icons, connectNode }, origin)
+            client.status = RPC_STATUS.CONNECTED
+            client.connectNode = connectNode
+            return {
+              ...await this.getWalletInfo(),
+              ...connectNode && this._getNode()
+            }
+          },
+          [METHODS.subscribeAddress]: async ({ type, value }, origin) => {
+            if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError()
+
+            await this.onSubscription(id, { type, value }, origin)
+
+            switch (type) {
+              case SUBSCRIPTION_TYPES.subscribe:
+                client.addressSubscription.add(value)
+                break
+              case SUBSCRIPTION_TYPES.unsubscribe:
+                client.addressSubscription.delete(value)
+                break
+            }
+
+            return {
+              subscription: Array.from(client.addressSubscription),
+              address: this.getAccounts()
+            }
+          },
+          [METHODS.address]: async (params, origin) => {
+            if (!this._isRpcClientSubscribed(id)) throw new RpcNotAuthorizeError()
+            await this.onAskAccounts(id, params, origin)
+            return this.addresses()
+          },
+          [METHODS.sign]: async ({ tx, onAccount, 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
+            if (returnSigned) {
+              return { signedTransaction: await this.signTransaction(tx, { onAccount }) }
+            }
+            try {
+              return jsonBig.parse(jsonBig.stringify({
+                transactionHash: await this.send(tx, { onAccount, verify: false })
+              }))
+            } catch (error) {
+              const validation = await verifyTransaction(tx, this.api)
+              if (validation.length > 0) throw new RpcInvalidTransactionError(validation)
+              throw new RpcBroadcastError(error.message)
+            }
+          },
+          [METHODS.signMessage]: async ({ message, onAccount }, 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
+            return {
+              // TODO: fix signMessage return type
+              signature: await this.signMessage(message, { onAccount, returnHex: true }) as
+                unknown as string
+            }
+          }
+        })
+    }
+    this._clients.set(id, client)
+    return id
+  }
+
+  /**
+   * Send shareWalletInfo message to notify AEPP about wallet
+   * @param clientId - ID of RPC client send message to
+   */
+  async shareWalletInfo (clientId: string): Promise<void> {
+    this._getClient(clientId).rpc.notify(METHODS.readyToConnect, await this.getWalletInfo())
+  }
+
+  /**
+   * Get Wallet info object
+   * @returns Object with wallet information
+   */
+  async getWalletInfo (): Promise<WalletInfo> {
+    return {
+      id: this.id,
+      name: this.name,
+      networkId: await this.getNetworkId(),
+      origin: window.location.origin,
+      type: this._type
+    }
+  }
+
+  /**
+   * Get Wallet accounts
+   * @returns Object with accounts information (\{ connected: Object, current: Object \})
+   */
+  getAccounts (): Accounts {
+    return {
+      current: this.selectedAddress != null ? { [this.selectedAddress]: {} } : {},
+      connected: this.addresses()
+        .filter((a) => a !== this.selectedAddress)
+        .reduce((acc, a) => ({ ...acc, [a]: {} }), {})
+    }
+  }
+}

package/src/Node.ts

@@ -0,0 +1,167 @@
+import BigNumber from 'bignumber.js'
+import { OperationArguments, OperationSpec } from '@azure/core-client'
+import {
+  genRequestQueuesPolicy, genCombineGetRequestsPolicy, genErrorFormatterPolicy,
+  genVersionCheckPolicy
+} from './utils/autorest'
+import { Node as NodeApi, NodeOptionalParams, ErrorModel } from './apis/node/'
+import { mapObject } from './utils/other'
+import { EncodedData } 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')
+}
+
+const bigIntPropertyNames = [
+  'balance', 'queryFee', 'fee', 'amount', 'nameFee', 'channelAmount',
+  'initiatorAmount', 'responderAmount', 'channelReserve', 'initiatorAmountFinal',
+  'responderAmountFinal', 'gasPrice', 'deposit'
+] as const
+
+const numberPropertyNames = [
+  'time', 'gas', 'gasUsed', 'nameSalt',
+  'nonce', 'nextNonce', 'height', 'blockHeight', 'top', 'topBlockHeight', 'ttl',
+  'inbound', 'outbound', 'peerCount', 'pendingTransactionsCount', 'effectiveAtHeight',
+  'version', 'solutions'
+] as const
+
+type BigIntPropertyNames = typeof bigIntPropertyNames[number]
+type NumberPropertyNames = typeof numberPropertyNames[number]
+type PreserveOptional<NewType, OrigType> =
+  OrigType extends undefined ? NewType | undefined : NewType
+export type TransformNodeType<Type> =
+  Type extends (...args: infer Args) => infer Ret
+    ? (...args: TransformNodeType<Args>) => TransformNodeType<Ret>
+    : Type extends [infer Item, ...infer Rest]
+      ? [TransformNodeType<Item>, ...TransformNodeType<Rest>]
+      : Type extends Array<infer Item>
+        ? Array<TransformNodeType<Item>>
+        : Type extends Promise<infer T>
+          ? Promise<TransformNodeType<T>>
+          : Type extends { [P in any]: any }
+            ? {
+                [Property in keyof Type]:
+                Property extends BigIntPropertyNames
+                  ? PreserveOptional<bigint, Type[Property]>
+                  : Property extends NumberPropertyNames
+                    ? PreserveOptional<number, Type[Property]>
+                    : Property extends 'txHash'
+                      ? PreserveOptional<EncodedData<'th'>, Type[Property]>
+                      : TransformNodeType<Type[Property]>
+              }
+            : Type
+type TransformedNode = new (...args: ConstructorParameters<typeof NodeApi>) => {
+  [Name in keyof InstanceType<typeof NodeApi>]: TransformNodeType<NodeApi[Name]>
+}
+
+export interface NodeInfo {
+  url: string
+  nodeNetworkId: string
+  version: string
+  consensusProtocolVersion: number
+}
+
+export default class Node extends (NodeApi as unknown as TransformedNode) {
+  url: string
+
+  /**
+   * @param url - Url for node API
+   * @param options - Options
+   * @param options.ignoreVersion - Don't check node version
+   */
+  constructor (
+    url: string,
+    { ignoreVersion = false, ...options }: NodeOptionalParams & { ignoreVersion?: boolean } = {}
+  ) {
+    // eslint-disable-next-line constructor-super
+    super(url, {
+      allowInsecureConnection: true,
+      additionalPolicies: [
+        genRequestQueuesPolicy(),
+        genCombineGetRequestsPolicy(),
+        genErrorFormatterPolicy((body: ErrorModel) => ` ${body.reason}`)
+      ],
+      ...options
+    })
+    this.url = url
+    if (!ignoreVersion) {
+      const versionPromise = this.getStatus().then(({ nodeVersion }) => nodeVersion)
+      this.pipeline.addPolicy(genVersionCheckPolicy('node', '/v3/status', versionPromise, '6.2.0', '7.0.0'))
+    }
+    this.intAsString = true
+  }
+
+  async getNodeInfo (): Promise<NodeInfo> {
+    const {
+      nodeVersion: version,
+      networkId: nodeNetworkId,
+      protocols,
+      topBlockHeight
+    } = await this.getStatus()
+    const consensusProtocolVersion = protocols
+      .filter(({ effectiveAtHeight }) => topBlockHeight >= effectiveAtHeight)
+      .reduce(
+        (acc, p) => p.effectiveAtHeight > acc.effectiveAtHeight ? p : acc,
+        { effectiveAtHeight: -1, version: 0 }
+      )
+      .version
+    return {
+      url: this.url,
+      nodeNetworkId,
+      version,
+      consensusProtocolVersion
+    }
+  }
+
+  // @ts-expect-error https://github.com/microsoft/TypeScript/issues/27689
+  async sendOperationRequest (
+    operationArguments: OperationArguments, operationSpec: OperationSpec
+  ): Promise<any> {
+    const args = mapObject(
+      operationArguments,
+      ([key, value]) => [key, this.#encodeArg(value)]
+    ) as OperationArguments
+    return this.#decodeRes(await super.sendOperationRequest(args, operationSpec))
+  }
+
+  #mapData (
+    data: any, transform: {
+      bigInt: (v: any) => any
+      number: (v: any) => any
+    }
+  ): unknown {
+    if (Array.isArray(data)) return data.map(d => this.#mapData(d, transform))
+    if (data != null && typeof data === 'object') {
+      return mapObject(data, ([key, value]) => {
+        if (value == null) return [key, value]
+        if (bigIntPropertyNames.some(k => k === key)) return [key, transform.bigInt(value)]
+        if (numberPropertyNames.some(k => k === key)) return [key, transform.number(value)]
+        return [key, this.#mapData(value, transform)]
+      })
+    }
+    return data
+  }
+
+  #encodeArg (data: any): any {
+    return this.#mapData(data, {
+      bigInt: value => {
+        if (value instanceof BigNumber) return value.toFixed()
+        return value.toString()
+      },
+      number: value => value.toString()
+    })
+  }
+
+  #decodeRes (data: any): any {
+    return this.#mapData(data, {
+      bigInt: value => BigInt(value),
+      number: value => +value
+    })
+  }
+}

package/src/account/Base.ts

@@ -0,0 +1,114 @@
+/*
+ * 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 { messageToHash, verifyMessage as verifyMessageCrypto, hash } from '../utils/crypto'
+import { buildTx } from '../tx/builder'
+import { decode, EncodedData } from '../utils/encoder'
+import { TX_TYPE } from '../tx/builder/schema'
+import { getNetworkId } from '../Node'
+import { concatBuffers } from '../utils/other'
+
+/**
+ * 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')
+
+/**
+ * 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
+   * @returns Signed transaction
+   */
+  async signTransaction (
+    tx: EncodedData<'tx'>,
+    { innerTx, networkId, ...options }: { innerTx?: boolean, networkId?: string } = {}
+  ): Promise<EncodedData<'tx'>> {
+    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 }, TX_TYPE.signed).tx
+  }
+
+  /**
+   * Get network Id
+   * @returns Network Id
+   */
+  readonly getNetworkId = getNetworkId
+
+  /**
+   * 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
+   */
+  async verifyMessage (
+    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))
+    )
+  }
+
+  /**
+   * Sign data blob
+   * @param data - Data blob to sign
+   * @param options - Options
+   * @returns Signed data blob
+   */
+  abstract sign (data: string | Uint8Array, options?: any): Promise<Uint8Array>
+
+  /**
+   * Obtain account address
+   * @returns Public account address
+   */
+  abstract address (opt?: object): Promise<EncodedData<'ak'>>
+}

package/src/account/Memory.ts

@@ -0,0 +1,83 @@
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2018 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 { sign, isValidKeypair } from '../utils/crypto'
+import { isHex } from '../utils/string'
+import { decode } from '../tx/builder/helpers'
+import { InvalidKeypairError, MissingParamError } from '../utils/errors'
+import { EncodedData } from '../utils/encoder'
+
+const secrets = new WeakMap()
+
+export interface Keypair {
+  publicKey: EncodedData<'ak'>
+  secretKey: string | Uint8Array
+}
+
+/**
+ * In-memory account class
+ */
+export default class AccountMemory extends AccountBase {
+  isGa: boolean
+
+  /**
+   * @param options - Options
+   * @param options.keypair - Key pair to use
+   * @param options.keypair.publicKey - Public key
+   * @param options.keypair.secretKey - Private key
+   * @param options.gaId - Address of generalized account
+   */
+  constructor (
+    { keypair, gaId, ...options }: { keypair?: Keypair, gaId?: EncodedData<'ak'> } & ConstructorParameters<typeof AccountBase>[0]
+  ) {
+    super(options)
+
+    this.isGa = gaId != null
+    if (this.isGa && gaId != null) {
+      decode(gaId)
+      secrets.set(this, { publicKey: gaId })
+      return
+    }
+
+    if (keypair == null) throw new MissingParamError('Either gaId or keypair is required')
+
+    if (
+      !Buffer.isBuffer(keypair.secretKey) &&
+      typeof keypair.secretKey === 'string' && !isHex(keypair.secretKey)
+    ) throw new InvalidKeypairError('Secret key must be hex string or Buffer')
+    const secretKey = typeof keypair.secretKey === 'string'
+      ? Buffer.from(keypair.secretKey, 'hex')
+      : keypair.secretKey
+    if (!isValidKeypair(secretKey, decode(keypair.publicKey))) {
+      throw new InvalidKeypairError('Invalid Key Pair')
+    }
+
+    secrets.set(this, {
+      secretKey,
+      publicKey: keypair.publicKey
+    })
+  }
+
+  async sign (data: string | Uint8Array): Promise<Uint8Array> {
+    if (this.isGa) throw new InvalidKeypairError('You are trying to sign data using generalized account without keypair')
+    return sign(data, secrets.get(this).secretKey)
+  }
+
+  async address (): Promise<EncodedData<'ak'>> {
+    return secrets.get(this).publicKey
+  }
+}