Class AeSdkAepp

RPC handler for AEPP side Contain functionality for wallet interaction and connect it to sdk

Deprecated

use WalletConnectorFrame instead

Hierarchy (View Summary)

AeSdkBase
- AeSdkAepp

Index

Constructors

constructor

Accessors

address api compilerApi

Constructors

constructor

new AeSdkAepp(
    options: {
        name: string;
        onAddressChange?: (a: Accounts) => void;
        onDisconnect?: (p: any) => void;
        onNetworkChange?: (a: Network) => void;
    } & AeSdkMethodsOptions & { nodes?: { instance: Node; name: string }[] },
): AeSdkAepp
Parameters
- options: {
      name: string;
      onAddressChange?: (a: Accounts) => void;
      onDisconnect?: (p: any) => void;
      onNetworkChange?: (a: Network) => void;
  } & AeSdkMethodsOptions & { nodes?: { instance: Node; name: string }[] }
  Options
  - name: string
    Aepp name
  - OptionalonAddressChange?: (a: Accounts) => void
    Call-back function for update address event
  - OptionalonDisconnect?: (p: any) => void
    Call-back function for disconnect event
  - OptionalonNetworkChange?: (a: Network) => void
    Call-back function for update network event
  - Optionalnodes?: { instance: Node; name: string }[]
Returns AeSdkAepp
Overrides AeSdkBase.constructor
- Defined in AeSdkAepp.ts:54

Properties

`Optional`_accounts

_accounts?: Accounts

_getPollInterval

_getPollInterval: (
    ...args:
        | [type: "key-block" | "micro-block"]
        | [
            type: "key-block"
            | "micro-block",
            Omit<
                {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

_options

_options: AeSdkMethodsOptions = {}

awaitHeight

awaitHeight: (
    ...args:
        | [height: number]
        | [
            height: number,
            Omit<
                { interval?: number; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                { interval?: number; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

buildAuthTxHash

buildAuthTxHash: (
    ...args:
        | [transaction: `tx_${string}`]
        | [
            transaction: `tx_${string}`,
            Omit<
                { fee?: Int; gasPrice?: Int; onNode: Node },
                "onNode" | "onAccount" | "onCompiler",
            > & Partial<{ fee?: Int; gasPrice?: Int; onNode: Node }>,
        ],
) => Promise

buildAuthTxHashByGaMetaTx

buildAuthTxHashByGaMetaTx: (
    ...args:
        | [transaction: `tx_${string}`]
        | [
            transaction: `tx_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

createGeneralizedAccount

createGeneralizedAccount: (
    ...args:
        | [authFnName: string, args: any[]]
        | [
            authFnName: string,
            args: any[],
            Omit<
                CreateGeneralizedAccountOptions,
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                Omit<CreateGeneralizedAccountOptions, "onAccount"> & {
                    onAccount: OnAccount;
                },
            >,
        ],
) => Promise

getAccount

getAccount: (
    ...args:
        | [address: `ct_${string}` | `ak_${string}`]
        | [
            address: `ct_${string}`
            | `ak_${string}`,
            Omit<
                {
                    hash?: `kh_${string}`
                    | `mh_${string}`;
                    height?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                {
                    hash?: `kh_${string}`
                    | `mh_${string}`;
                    height?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

getBalance

getBalance: (
    ...args:
        | [address: `ct_${string}` | `ok_${string}` | `ak_${string}`]
        | [
            address: `ct_${string}`
            | `ok_${string}`
            | `ak_${string}`,
            Omit<
                { format?: AE_AMOUNT_FORMATS } & {
                    hash?: `kh_${string}` | `mh_${string}`;
                    height?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                { format?: AE_AMOUNT_FORMATS } & {
                    hash?: `kh_${string}` | `mh_${string}`;
                    height?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

getContract

getContract: (
    ...args:
        | [contractId: `ct_${string}`]
        | [
            contractId: `ct_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getContractByteCode

getContractByteCode: (
    ...args:
        | [contractId: `ct_${string}`]
        | [
            contractId: `ct_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getCurrentGeneration

getCurrentGeneration: (
    ...args:
        | []
        | [
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getGeneration

getGeneration: (
    ...args:
        | [hashOrHeight: number | `kh_${string}`]
        | [
            hashOrHeight: number
            | `kh_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getHeight

getHeight: (
    ...args:
        | []
        | [
            Omit<
                { cached?: boolean; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                { cached?: boolean; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

getKeyBlock

getKeyBlock: (
    ...args:
        | [hashOrHeight: number | `kh_${string}`]
        | [
            hashOrHeight: number
            | `kh_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getMicroBlockHeader

getMicroBlockHeader: (
    ...args:
        | [hash: `mh_${string}`]
        | [
            hash: `mh_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getMicroBlockTransactions

getMicroBlockTransactions: (
    ...args:
        | [hash: `mh_${string}`]
        | [
            hash: `mh_${string}`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

getName

getName: (
    ...args:
        | [name: `${string}.chain`]
        | [
            name: `${string}.chain`,
            Omit<{ onNode: Node }, "onNode" | "onAccount" | "onCompiler"> & Partial<
                { onNode: Node },
            >,
        ],
) => Promise

name

name: string

onAddressChange

onAddressChange: (a: Accounts) => void

onDisconnect

onDisconnect: (p: any) => void

onNetworkChange

onNetworkChange: (a: Network) => void

payForTransaction

payForTransaction: (
    ...args:
        | [transaction: `tx_${string}`]
        | [
            transaction: `tx_${string}`,
            Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & Partial<
                Omit<PayForTransactionOptions, "onAccount"> & {
                    onAccount: OnAccount;
                },
            >,
        ],
) => Promise

poll

poll: (
    ...args:
        | [th: `th_${string}`]
        | [
            th: `th_${string}`,
            Omit<
                { blocks?: number; interval?: number; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                { blocks?: number; interval?: number; onNode: Node } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

pool

pool: Map<string, Node> = ...

resolveName

resolveName: (
    ...args:
        | [
            nameOrId: `${string}.chain`
            | `ct_${string}`
            | `ak_${string}`,
            key: string,
        ]
        | [
            nameOrId: `${string}.chain`
            | `ct_${string}`
            | `ak_${string}`,
            key: string,
            Omit<
                { onNode: Node; resolveByNode?: boolean; verify?: boolean },
                "onNode" | "onAccount" | "onCompiler",
            > & Partial<{ onNode: Node; resolveByNode?: boolean; verify?: boolean }>,
        ],
) => Promise

`Optional`rpcClient

rpcClient?: default<WalletApi, AeppApi>

`Optional`selectedNodeName

selectedNodeName?: string

sendTransaction

sendTransaction: (
    ...args:
        | [txUnsigned: `tx_${string}`]
        | [
            txUnsigned: `tx_${string}`,
            Omit<SendTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & Partial<
                Omit<SendTransactionOptions, "onAccount"> & { onAccount: OnAccount },
            >,
        ],
) => Promise

spend

spend: (
    ...args:
        | [
            amount: string
            | number,
            recipientIdOrName: `${string}.chain` | `ct_${string}` | `ak_${string}`,
        ]
        | [
            amount: string
            | number,
            recipientIdOrName: `${string}.chain` | `ct_${string}` | `ak_${string}`,
            Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & Partial<
                Omit<SpendOptions, "onAccount"> & { onAccount: OnAccount },
            >,
        ],
) => Promise

transferFunds

transferFunds: (
    ...args:
        | [
            fraction: string
            | number,
            recipientIdOrName: `${string}.chain` | `ct_${string}` | `ak_${string}`,
        ]
        | [
            fraction: string
            | number,
            recipientIdOrName: `${string}.chain` | `ct_${string}` | `ak_${string}`,
            Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & Partial<
                Omit<TransferFundsOptions, "onAccount"> & { onAccount: OnAccount },
            >,
        ],
) => Promise

txDryRun

txDryRun: (
    ...args:
        | [tx: `tx_${string}`, accountAddress: `ak_${string}`]
        | [
            tx: `tx_${string}`,
            accountAddress: `ak_${string}`,
            Omit<
                {
                    combine?: boolean;
                    onNode: Node;
                    top?: number
                    | `kh_${string}`
                    | `mh_${string}`;
                    txEvents?: boolean;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                {
                    combine?: boolean;
                    onNode: Node;
                    top?: number
                    | `kh_${string}`
                    | `mh_${string}`;
                    txEvents?: boolean;
                },
            >,
        ],
) => Promise

waitForTxConfirm

waitForTxConfirm: (
    ...args:
        | [txHash: `th_${string}`]
        | [
            txHash: `th_${string}`,
            Omit<
                { confirm?: number; onNode: Node } & {
                    interval?: number;
                    onNode: Node;
                } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
                "onNode"
                | "onAccount"
                | "onCompiler",
            > & Partial<
                { confirm?: number; onNode: Node } & {
                    interval?: number;
                    onNode: Node;
                } & {
                    _expectedMineRate?: number;
                    _microBlockCycle?: number;
                    onNode: Node;
                },
            >,
        ],
) => Promise

Accessors

address

get address(): `ak_${string}`
Returns `ak_${string}`
Inherited from AeSdkBase.address
- Defined in AeSdkBase.ts:159

api

get api(): Node
Returns Node
Inherited from AeSdkBase.api
- Defined in AeSdkBase.ts:61

compilerApi

get compilerApi(): CompilerBase
Returns CompilerBase
Inherited from AeSdkBase.compilerApi
- Defined in AeSdkBase.ts:54

Methods

_ensureAccountAccess

_ensureAccountAccess(): asserts this is AeSdkAepp & {
rpcClient: default<WalletApi>;
}
Returns asserts this is AeSdkAepp & { rpcClient: default<WalletApi> }
- Defined in AeSdkAepp.ts:197

_ensureConnected

_ensureConnected(): asserts this is AeSdkAepp & {
rpcClient: default<WalletApi>;
}
Returns asserts this is AeSdkAepp & { rpcClient: default<WalletApi> }
- Defined in AeSdkAepp.ts:190

_resolveAccount

_resolveAccount(account?: OnAccount): AccountBase
Resolves an account
Parameters
- account: OnAccount = ...
  ak-address, instance of AccountBase, or keypair
Returns AccountBase
Overrides AeSdkBase._resolveAccount
- Defined in AeSdkAepp.ts:73

addNode

addNode(name: string, node: Node, select?: boolean): void
Add Node
Parameters
- name: string
  Node name
- node: Node
  Node instance
- select: boolean = false
  Select this node as current
Returns void
Example
```
// add and select new node with name 'testNode'
aeSdkBase.addNode('testNode', new Node({ url }), true)
```
Inherited from AeSdkBase.addNode
- Defined in AeSdkBase.ts:77

addresses

addresses(): `ak_${string}`[]
Returns `ak_${string}`[]
Overrides AeSdkBase.addresses
- Defined in AeSdkAepp.ts:85

askAddresses

askAddresses(): Promise<`ak_${string}`[]>
Ask addresses from wallet

Returns Promise<`ak_${string}`[]>
Addresses from wallet
- Defined in AeSdkAepp.ts:161

askToSelectNetwork

askToSelectNetwork(network: NetworkToSelect): Promise<void>
Ask wallet to select a network
Parameters
- network: NetworkToSelect
Returns Promise<void>
- Defined in AeSdkAepp.ts:185

buildTx

buildTx(options: TxParamsAsync): Promise<`tx_${string}`>
Parameters
- options: TxParamsAsync
Returns Promise<`tx_${string}`>
Inherited from AeSdkBase.buildTx
- Defined in AeSdkMethods.ts:84

connectToWallet

connectToWallet(
connection: default,
options?: { connectNode?: boolean; name?: string },
): Promise<WalletInfo & { node?: Node }>
Connect to wallet
Parameters
- connection: default
  Wallet connection object
- options: { connectNode?: boolean; name?: string } = {}
  Options
  - OptionalconnectNode?: boolean
    Request wallet to bind node
  - Optionalname?: string
    Node name
Returns Promise<WalletInfo & { node?: Node }>
- Defined in AeSdkAepp.ts:101

disconnectWallet

disconnectWallet(): void
Disconnect from wallet

Returns void
- Defined in AeSdkAepp.ts:151

`Protected`ensureNodeConnected

ensureNodeConnected(): asserts this is AeSdkBase & { selectedNodeName: string }
Returns asserts this is AeSdkBase & { selectedNodeName: string }
Inherited from AeSdkBase.ensureNodeConnected
- Defined in AeSdkBase.ts:106

getContext

getContext(
mergeWith?: AeSdkMethodsOptions,
): AeSdkMethodsOptions & WrappedOptions
The same as AeSdkMethods:getContext, but it would resolve ak_-prefixed address in mergeWith.onAccount to AccountBase.
Parameters
- mergeWith: AeSdkMethodsOptions = {}
Returns AeSdkMethodsOptions & WrappedOptions
Inherited from AeSdkBase.getContext
- Defined in AeSdkBase.ts:257

getNodeInfo

getNodeInfo(): Promise<NodeInfo>
Get information about node

Returns Promise<NodeInfo>
Example
```
nodePool.getNodeInfo() // { name, version, networkId, protocol, ... }
```
Inherited from AeSdkBase.getNodeInfo
- Defined in AeSdkBase.ts:119

getNodesInPool

getNodesInPool(): Promise<NodeInfo[]>
Get array of available nodes

Returns Promise<NodeInfo[]>
Example
```
nodePool.getNodesInPool()
```
Inherited from AeSdkBase.getNodesInPool
- Defined in AeSdkBase.ts:132

isNodeConnected

isNodeConnected(): this is AeSdkBase & { selectedNodeName: string }
Check if you have selected node

Returns this is AeSdkBase & { selectedNodeName: string }
Example
```
nodePool.isNodeConnected()
```
Inherited from AeSdkBase.isNodeConnected
- Defined in AeSdkBase.ts:102

selectNode

selectNode(name: string): void
Select Node
Parameters
- name: string
  Node name
Returns void
Example
```
nodePool.selectNode('testNode')
```
Inherited from AeSdkBase.selectNode
- Defined in AeSdkBase.ts:92

sign

sign(
data: string | Uint8Array,
options?: { onAccount?: OnAccount },
): Promise<Uint8Array>
Sign data blob
Parameters
- data: string | Uint8Array
  Data to sign
- options: { onAccount?: OnAccount } = {}
  Options
Returns Promise<Uint8Array>
Deprecated
Use unsafeSign method instead
Inherited from AeSdkBase.sign
- Defined in AeSdkBase.ts:169

signDelegation

signDelegation(
    delegation: `ba_${string}`,
    options?: { onAccount?: OnAccount } & {
        aeppOrigin?: string;
        aeppRpcClientId?: string;
        networkId?: string;
    },
): Promise<`sg_${string}`>
Sign delegation, works only in Ceres
Parameters
- delegation: `ba_${string}`
  Delegation to sign
- options: { onAccount?: OnAccount } & {
      aeppOrigin?: string;
      aeppRpcClientId?: string;
      networkId?: string;
  } = {}
  Options
Returns Promise<`sg_${string}`>
Inherited from AeSdkBase.signDelegation
- Defined in AeSdkBase.ts:241

signMessage

signMessage(
    message: string,
    options?: { onAccount?: OnAccount } & {
        aeppOrigin?: string;
        aeppRpcClientId?: string;
    },
): Promise<Uint8Array>
Sign message
Parameters
- message: string
  Message to sign
- options: { onAccount?: OnAccount } & { aeppOrigin?: string; aeppRpcClientId?: string } = {}
  Options
Returns Promise<Uint8Array>
Inherited from AeSdkBase.signMessage
- Defined in AeSdkBase.ts:209

signTransaction

signTransaction(
    tx: `tx_${string}`,
    options?: { onAccount?: OnAccount } & {
        aeppOrigin?: string;
        aeppRpcClientId?: string;
        authData?: AuthData | (tx: `tx_${string}`) => Promise<AuthData>;
        innerTx?: boolean;
        networkId?: string;
        onCompiler?: CompilerBase;
        onNode?: Node;
    },
): Promise<`tx_${string}`>
Sign encoded transaction
Parameters
- tx: `tx_${string}`
  Transaction to sign
- options: { onAccount?: OnAccount } & {
      aeppOrigin?: string;
      aeppRpcClientId?: string;
      authData?: AuthData | (tx: `tx_${string}`) => Promise<AuthData>;
      innerTx?: boolean;
      networkId?: string;
      onCompiler?: CompilerBase;
      onNode?: Node;
  } = {}
  Options
Returns Promise<`tx_${string}`>
Inherited from AeSdkBase.signTransaction
- Defined in AeSdkBase.ts:193

signTypedData

signTypedData(
    data: `cb_${string}`,
    aci: AciValue,
    options?: { onAccount?: OnAccount } & Domain & {
        aeppOrigin?: string;
        aeppRpcClientId?: string;
    },
): Promise<`sg_${string}`>
Sign typed data
Parameters
- data: `cb_${string}`
  Encoded data to sign
- aci: AciValue
  Type of data to sign
- options: { onAccount?: OnAccount } & Domain & {
  aeppOrigin?: string;
  aeppRpcClientId?: string;
  } = {}
  Options
Returns Promise<`sg_${string}`>
Inherited from AeSdkBase.signTypedData
- Defined in AeSdkBase.ts:225

subscribeAddress

subscribeAddress(
    type: SUBSCRIPTION_TYPES,
    value: "connected" | "current",
): Promise<
    Promise<
        { address: Accounts; subscription: ("connected" | "current")[] },
    >,
>
Subscribe for addresses from wallet
Parameters
- type: SUBSCRIPTION_TYPES
  Subscription type
- value: "connected" | "current"
  Should be one of 'current' (the selected account), 'connected' (all)
Returns Promise<
    Promise<
        { address: Accounts; subscription: ("connected" | "current")[] },
    >,
>
Accounts from wallet
- Defined in AeSdkAepp.ts:172

unsafeSign

unsafeSign(
data: string | Uint8Array,
options?: { onAccount?: OnAccount },
): Promise<Uint8Array>
Sign data blob
Parameters
- data: string | Uint8Array
  Data to sign
- options: { onAccount?: OnAccount } = {}
  Options
Returns Promise<Uint8Array>
Inherited from AeSdkBase.unsafeSign
- Defined in AeSdkBase.ts:181

Class AeSdkAepp

Deprecated

Hierarchy (View Summary)

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

name: string

OptionalonAddressChange?: (a: Accounts) => void

OptionalonDisconnect?: (p: any) => void

OptionalonNetworkChange?: (a: Network) => void

Optionalnodes?: { instance: Node; name: string }[]

Returns AeSdkAepp

Properties

Optional_accounts

_getPollInterval

_options

awaitHeight

buildAuthTxHash

buildAuthTxHashByGaMetaTx

createGeneralizedAccount

getAccount

getBalance

getContract

getContractByteCode

getCurrentGeneration

getGeneration

getHeight

getKeyBlock

getMicroBlockHeader

getMicroBlockTransactions

getName

name

onAddressChange

onDisconnect

onNetworkChange

payForTransaction

poll

pool

resolveName

OptionalrpcClient

OptionalselectedNodeName

sendTransaction

spend

transferFunds

txDryRun

waitForTxConfirm

Accessors

address

Returns `ak_${string}`

api

Returns Node

compilerApi

Returns CompilerBase

Methods

_ensureAccountAccess

Returns asserts this is AeSdkAepp & { rpcClient: default<WalletApi> }

_ensureConnected

Returns asserts this is AeSdkAepp & { rpcClient: default<WalletApi> }

_resolveAccount

Parameters

Returns AccountBase

addNode

Parameters

Returns void

Example

addresses

Returns `ak_${string}`[]

askAddresses

Returns Promise<`ak_${string}`[]>

askToSelectNetwork

Parameters

Returns Promise<void>

buildTx

Parameters

Returns Promise<`tx_${string}`>

`Optional`onAddressChange?: (a: Accounts) => void

`Optional`onDisconnect?: (p: any) => void

`Optional`onNetworkChange?: (a: Network) => void

`Optional`nodes?: { instance: Node; name: string }[]

`Optional`_accounts

`Optional`rpcClient

`Optional`selectedNodeName

`Optional`connectNode?: boolean

`Optional`name?: string

`Protected`ensureNodeConnected

Returns Promise<
Promise<
{ address: Accounts; subscription: ("connected" | "current")[] },
>,
>