Class Demos

This class provides methods to interact with the DEMOS blockchain.

Constructors

constructor

new Demos(): Demos
Returns Demos
- Defined in src/websdk/demosclass.ts:80

Properties

algorithm

algorithm: SigningAlgorithm = "ed25519"

connected

connected: boolean = false

Connection status of the RPC URL

crypto

crypto: UnifiedCrypto = null

DemosTransactions

DemosTransactions: {
    broadcast: ((validationData: RPCResponseWithValidityData, demos: Demos) => Promise<any>);
    confirm: ((transaction: Transaction, demos: Demos) => Promise<RPCResponseWithValidityData>);
    empty: (() => Transaction);
    prepare: ((data?: any) => Promise<Transaction>);
    sign: ((raw_tx: Transaction, keypair: IKeyPair, options: {
        algorithm: SigningAlgorithm;
    }) => Promise<Transaction>);
    signWithAlgorithm: ((data: string, keypair: IKeyPair, options: {
        algorithm: SigningAlgorithm;
    }) => Promise<{
        data: string;
        type: SigningAlgorithm;
    }>);
    pay(to: string, amount: number, demos: Demos): Promise<Transaction>;
    transfer(to: string, amount: number, demos: Demos): Promise<Transaction>;
} = DemosTransactions

Type declaration

broadcast: ((validationData: RPCResponseWithValidityData, demos: Demos) => Promise<any>)
Broadcasts a transaction for execution.
- - (validationData, demos): Promise<any>
  - Parameters
    - validationData: RPCResponseWithValidityData
      The validity data of the transaction
    - demos: Demos
      The demos instance
    Returns Promise<any>
    The response from the node
confirm: ((transaction: Transaction, demos: Demos) => Promise<RPCResponseWithValidityData>)
Confirms a transaction.
- - (transaction, demos): Promise<RPCResponseWithValidityData>
  - Parameters
    - transaction: Transaction
      The transaction to confirm
    - demos: Demos
    Returns Promise<RPCResponseWithValidityData>
    The validity data of the transaction containing the gas information.
empty: (() => Transaction)
- - (): Transaction
  - Returns Transaction
prepare: ((data?: any) => Promise<Transaction>)
- - (data?): Promise<Transaction>
  - Parameters
    - data: any = null
    Returns Promise<Transaction>
sign: ((raw_tx: Transaction, keypair: IKeyPair, options: {
algorithm: SigningAlgorithm;
}) => Promise<Transaction>)
Signs a transaction after hashing its content.

Deprecated
Use demos.sign(tx) instead
- - (raw_tx, keypair, options): Promise<Transaction>
  - Parameters
    - raw_tx: Transaction
      The transaction to be signed.
    - keypair: IKeyPair
      The keypair to use for signing.
    - options: {
      algorithm: SigningAlgorithm;
      }
      algorithm: SigningAlgorithm
    Returns Promise<Transaction>
    A Promise that resolves to the signed transaction.
signWithAlgorithm: ((data: string, keypair: IKeyPair, options: {
    algorithm: SigningAlgorithm;
}) => Promise<{
    data: string;
    type: SigningAlgorithm;
}>)
Signs a message with a given algorithm.
- - (data, keypair, options): Promise<{
    data: string;
    type: SigningAlgorithm;
    }>
  - Parameters
    - data: string
      The message to sign.
    - keypair: IKeyPair
      The keypair to use for signing.
    - options: {
      algorithm: SigningAlgorithm;
      }
      algorithm: SigningAlgorithm
      The algorithm related to the keypair.
    Returns Promise<{
    data: string;
    type: SigningAlgorithm;
    }>
    A Promise that resolves to the signed message.
pay:function
- pay(to, amount, demos): Promise<Transaction>
- Create a signed DEMOS transaction to send native tokens to a given address.
  Parameters
  - to: string
    The reciever
  - amount: number
    The amount in DEM
  - demos: Demos
    The demos instance (for getting the address nonce)
  Returns Promise<Transaction>
  The signed transaction.
  - Defined in src/websdk/DemosTransactions.ts:41
transfer:function
- transfer(to, amount, demos): Promise<Transaction>
- Create a signed DEMOS transaction to send native tokens to a given address.
  Parameters
  - to: string
    The reciever
  - amount: number
    The amount in DEM
  - demos: Demos
    The demos instance (for getting the address nonce)
  Returns Promise<Transaction>
  The signed transaction.
  - Defined in src/websdk/DemosTransactions.ts:75

DemosWebAuth

DemosWebAuth: typeof DemosWebAuth = DemosWebAuth

dual_sign

dual_sign: boolean = false

skeletons

skeletons: skeletons = skeletons

transactions

transactions: {
    broadcast: ((validationData: RPCResponseWithValidityData, demos: Demos) => Promise<any>);
    confirm: ((transaction: Transaction, demos: Demos) => Promise<RPCResponseWithValidityData>);
    empty: (() => Transaction);
    prepare: ((data?: any) => Promise<Transaction>);
    sign: ((raw_tx: Transaction, keypair: IKeyPair, options: {
        algorithm: SigningAlgorithm;
    }) => Promise<Transaction>);
    signWithAlgorithm: ((data: string, keypair: IKeyPair, options: {
        algorithm: SigningAlgorithm;
    }) => Promise<{
        data: string;
        type: SigningAlgorithm;
    }>);
    pay(to: string, amount: number, demos: Demos): Promise<Transaction>;
    transfer(to: string, amount: number, demos: Demos): Promise<Transaction>;
} = DemosTransactions

Type declaration

broadcast: ((validationData: RPCResponseWithValidityData, demos: Demos) => Promise<any>)
Broadcasts a transaction for execution.
- - (validationData, demos): Promise<any>
  - Parameters
    - validationData: RPCResponseWithValidityData
      The validity data of the transaction
    - demos: Demos
      The demos instance
    Returns Promise<any>
    The response from the node
confirm: ((transaction: Transaction, demos: Demos) => Promise<RPCResponseWithValidityData>)
Confirms a transaction.
- - (transaction, demos): Promise<RPCResponseWithValidityData>
  - Parameters
    - transaction: Transaction
      The transaction to confirm
    - demos: Demos
    Returns Promise<RPCResponseWithValidityData>
    The validity data of the transaction containing the gas information.
empty: (() => Transaction)
- - (): Transaction
  - Returns Transaction
prepare: ((data?: any) => Promise<Transaction>)
- - (data?): Promise<Transaction>
  - Parameters
    - data: any = null
    Returns Promise<Transaction>
sign: ((raw_tx: Transaction, keypair: IKeyPair, options: {
algorithm: SigningAlgorithm;
}) => Promise<Transaction>)
Signs a transaction after hashing its content.

Deprecated
Use demos.sign(tx) instead
- - (raw_tx, keypair, options): Promise<Transaction>
  - Parameters
    - raw_tx: Transaction
      The transaction to be signed.
    - keypair: IKeyPair
      The keypair to use for signing.
    - options: {
      algorithm: SigningAlgorithm;
      }
      algorithm: SigningAlgorithm
    Returns Promise<Transaction>
    A Promise that resolves to the signed transaction.
signWithAlgorithm: ((data: string, keypair: IKeyPair, options: {
    algorithm: SigningAlgorithm;
}) => Promise<{
    data: string;
    type: SigningAlgorithm;
}>)
Signs a message with a given algorithm.
- - (data, keypair, options): Promise<{
    data: string;
    type: SigningAlgorithm;
    }>
  - Parameters
    - data: string
      The message to sign.
    - keypair: IKeyPair
      The keypair to use for signing.
    - options: {
      algorithm: SigningAlgorithm;
      }
      algorithm: SigningAlgorithm
      The algorithm related to the keypair.
    Returns Promise<{
    data: string;
    type: SigningAlgorithm;
    }>
    A Promise that resolves to the signed message.
pay:function
- pay(to, amount, demos): Promise<Transaction>
- Create a signed DEMOS transaction to send native tokens to a given address.
  Parameters
  - to: string
    The reciever
  - amount: number
    The amount in DEM
  - demos: Demos
    The demos instance (for getting the address nonce)
  Returns Promise<Transaction>
  The signed transaction.
  - Defined in src/websdk/DemosTransactions.ts:41
transfer:function
- transfer(to, amount, demos): Promise<Transaction>
- Create a signed DEMOS transaction to send native tokens to a given address.
  Parameters
  - to: string
    The reciever
  - amount: number
    The amount in DEM
  - demos: Demos
    The demos instance (for getting the address nonce)
  Returns Promise<Transaction>
  The signed transaction.
  - Defined in src/websdk/DemosTransactions.ts:75

tx

tx: {
    broadcast: ((validationData: RPCResponseWithValidityData, demos: Demos) => Promise<any>);
    confirm: ((transaction: Transaction, demos: Demos) => Promise<RPCResponseWithValidityData>);
    empty: (() => Transaction);
    prepare: ((data?: any) => Promise<Transaction>);
    sign: ((raw_tx: Transaction) => Promise<Transaction>);
    signWithAlgorithm: ((data: string, keypair: IKeyPair, options: {
        algorithm: SigningAlgorithm;
    }) => Promise<{
        data: string;
        type: SigningAlgorithm;
    }>);
    pay(to: string, amount: number, demos: Demos): Promise<Transaction>;
    transfer(to: string, amount: number, demos: Demos): Promise<Transaction>;
} = ...

Type declaration

broadcast: ((validationData: RPCResponseWithValidityData, demos: Demos) => Promise<any>)
Broadcasts a transaction for execution.
- - (validationData, demos): Promise<any>
  - Parameters
    - validationData: RPCResponseWithValidityData
      The validity data of the transaction
    - demos: Demos
      The demos instance
    Returns Promise<any>
    The response from the node
confirm: ((transaction: Transaction, demos: Demos) => Promise<RPCResponseWithValidityData>)
Confirms a transaction.
- - (transaction, demos): Promise<RPCResponseWithValidityData>
  - Parameters
    - transaction: Transaction
      The transaction to confirm
    - demos: Demos
    Returns Promise<RPCResponseWithValidityData>
    The validity data of the transaction containing the gas information.
empty: (() => Transaction)
- - (): Transaction
  - Returns Transaction
prepare: ((data?: any) => Promise<Transaction>)
- - (data?): Promise<Transaction>
  - Parameters
    - data: any = null
    Returns Promise<Transaction>
sign: ((raw_tx: Transaction) => Promise<Transaction>)
Same as demos.sign. Signs a transaction after hashing its content.
- - (raw_tx): Promise<Transaction>
  - Parameters
    - raw_tx: Transaction
      The transaction to be signed.
    Returns Promise<Transaction>
signWithAlgorithm: ((data: string, keypair: IKeyPair, options: {
    algorithm: SigningAlgorithm;
}) => Promise<{
    data: string;
    type: SigningAlgorithm;
}>)
Signs a message with a given algorithm.
- - (data, keypair, options): Promise<{
    data: string;
    type: SigningAlgorithm;
    }>
  - Parameters
    - data: string
      The message to sign.
    - keypair: IKeyPair
      The keypair to use for signing.
    - options: {
      algorithm: SigningAlgorithm;
      }
      algorithm: SigningAlgorithm
      The algorithm related to the keypair.
    Returns Promise<{
    data: string;
    type: SigningAlgorithm;
    }>
    A Promise that resolves to the signed message.
pay:function
- pay(to, amount, demos): Promise<Transaction>
- Create a signed DEMOS transaction to send native tokens to a given address.
  Parameters
  - to: string
    The reciever
  - amount: number
    The amount in DEM
  - demos: Demos
    The demos instance (for getting the address nonce)
  Returns Promise<Transaction>
  The signed transaction.
  - Defined in src/websdk/DemosTransactions.ts:41
transfer:function
- transfer(to, amount, demos): Promise<Transaction>
- Create a signed DEMOS transaction to send native tokens to a given address.
  Parameters
  - to: string
    The reciever
  - amount: number
    The amount in DEM
  - demos: Demos
    The demos instance (for getting the address nonce)
  Returns Promise<Transaction>
  The signed transaction.
  - Defined in src/websdk/DemosTransactions.ts:75

web2

web2: {
    createDahr: (() => Promise<Web2Proxy>);
    getTweet: ((tweetUrl: string) => Promise<{
        error?: string;
        success: boolean;
        tweet: Tweet;
    }>);
} = ...

xm

xm: {
createPayload: ((xm_payload: XMScript, keypair?: IKeyPair) => Promise<Transaction>);
} = ...

Accessors

keypair

get keypair(): {
privateKey: NativeBuffer;
publicKey: NativeBuffer;
}
The keypair of the connected wallet

Returns {
privateKey: NativeBuffer;
publicKey: NativeBuffer;
}
- privateKey: NativeBuffer
- publicKey: NativeBuffer
- Defined in src/websdk/demosclass.ts:63

walletConnected

get walletConnected(): boolean
Connection status of the wallet

Returns boolean
- Defined in src/websdk/demosclass.ts:57

`Static`instance

get instance(): Demos
Returns Demos
- Defined in src/websdk/demosclass.ts:84

Methods

broadcast

broadcast(validationData): Promise<any>
Broadcasts a transaction for execution.
Parameters
- validationData: RPCResponseWithValidityData
  The validity data of the transaction
Returns Promise<any>
The response from the node
- Defined in src/websdk/demosclass.ts:264

call

call(method, message, data?, extra?, sender?, receiver?): Promise<any>
Parameters
- method: any
- message: any
- data: any = {}
- extra: any = ""
- sender: any = null
- receiver: any = null
Returns Promise<any>
- Defined in src/websdk/demosclass.ts:472

confirm

confirm(transaction): Promise<RPCResponseWithValidityData>
Confirms a transaction.
Parameters
- transaction: Transaction
  The transaction to confirm
Returns Promise<RPCResponseWithValidityData>
The validity data of the transaction containing the gas information.
- Defined in src/websdk/demosclass.ts:254

connect

connect(rpc_url): Promise<boolean>
Connects to a RPC URL. Throws an error if the connection fails.
Parameters
- rpc_url: string
  The URL of the demos node
Returns Promise<boolean>
Whether the connection was successful
- Defined in src/websdk/demosclass.ts:108

connectWallet

connectWallet(masterSeed, options?): Promise<string>
Connects to a Demos wallet using the provided master seed.
Parameters
- masterSeed: string | Uint8Array<ArrayBufferLike>
  The master seed of the wallet
- Optionaloptions: {
  algorithm?: SigningAlgorithm;
  dual_sign?: boolean;
  }
  The options for the wallet connection
  - Optionalalgorithm?: SigningAlgorithm
    The algorithm to use for the wallet
  - Optionaldual_sign?: boolean
    Whether to include the ed25519 signature along with the PQC signature, when signing with unlinked PQC keypairs (i.e. PQC keypairs not linked to your ed25519 address on the network).
Returns Promise<string>
The public key of the wallet
- Defined in src/websdk/demosclass.ts:131

disconnect

disconnect(): void
Disconnects from the RPC URL and the wallet.

Returns void
- Defined in src/websdk/demosclass.ts:715

generateMuid

generateMuid(): string
Generates a random MUID.

Returns string
The MUID
- Defined in src/websdk/demosclass.ts:211

getAddress

getAddress(): string
Returns the public key of the connected wallet.

Returns string
The public key of the wallet
- Defined in src/websdk/demosclass.ts:190

getAddressInfo

getAddressInfo(address): Promise<AddressInfo>
Get information about an address.
Parameters
- address: string
  The address
Returns Promise<AddressInfo>
- Defined in src/websdk/demosclass.ts:676

getAddressNonce

getAddressNonce(address): Promise<number>
Get address nonce.
Parameters
- address: string
  The address
Returns Promise<number>
- Defined in src/websdk/demosclass.ts:700

getAllTxs

getAllTxs(): Promise<RawTransaction[]>
Returns Promise<RawTransaction[]>
Deprecated
Use demos.getTransactions() instead

Get all transactions.
- Defined in src/websdk/demosclass.ts:635

getBlockByHash

getBlockByHash(blockHash): Promise<Block>
Get block by hash.
Parameters
- blockHash: string
  The block hash
Returns Promise<Block>
- Defined in src/websdk/demosclass.ts:609

getBlockByNumber

getBlockByNumber(blockNumber): Promise<Block>
Get block by number.
Parameters
- blockNumber: number
  The block number
Returns Promise<Block>
- Defined in src/websdk/demosclass.ts:598

getBlocks

getBlocks(start?, limit?): Promise<Block[]>
Get list of blocks.
Parameters
- Optionalstart: number | "latest"
- Optionallimit: number
Returns Promise<Block[]>
- Defined in src/websdk/demosclass.ts:586

getEd25519Address

getEd25519Address(): Promise<string>
Returns the ed25519 address of the connected wallet.

Returns Promise<string>
- Defined in src/websdk/demosclass.ts:199

getLastBlockHash

getLastBlockHash(): Promise<string>
Get the last block hash.

Returns Promise<string>
- Defined in src/websdk/demosclass.ts:578

getLastBlockNumber

getLastBlockNumber(): Promise<number>
Get the last block number.

Returns Promise<number>
- Defined in src/websdk/demosclass.ts:571

getMempool

getMempool(): Promise<Transaction[]>
Get the mempool.

Returns Promise<Transaction[]>
- Defined in src/websdk/demosclass.ts:660

getPeerIdentity

getPeerIdentity(): Promise<string>
Get the identity of the connected RPC.

Returns Promise<string>
- Defined in src/websdk/demosclass.ts:667

getPeerlist

getPeerlist(): Promise<IPeer[]>
Get the peerlist.

Returns Promise<IPeer[]>
- Defined in src/websdk/demosclass.ts:652

getTransactions

getTransactions(start?, limit?): Promise<RawTransaction[]>
Get all transactions.
Parameters
- Optionalstart: number | "latest"
- Optionallimit: number
Returns Promise<RawTransaction[]>
- Defined in src/websdk/demosclass.ts:642

getTxByHash

getTxByHash(txHash?): Promise<Transaction>
Get transaction by hash.
Parameters
- txHash: string = "e25860ec6a7cccff0371091fed3a4c6839b1231ccec8cf2cb36eca3533af8f11"
  The transaction hash
Returns Promise<Transaction>
- Defined in src/websdk/demosclass.ts:620

newMnemonic

newMnemonic(strength?): string
Generates a new mnemonic.
Parameters
- strength: 128 | 256 = 128
  The strength of the mnemonic in bits. (128 bits = 12 words, 256 bits = 24 words). Default is 128 bits.
Returns string
The mnemonic
- Defined in src/websdk/demosclass.ts:98

nodeCall

nodeCall(message, args?): Promise<any>
Performs a nodeCall on the connected RPC.
Parameters
- message: any
  The message to send to the node
- args: {} = {}
  The arguments to send to the node
Returns Promise<any>
The nodeCall response
- Defined in src/websdk/demosclass.ts:562

pay

pay(to, amount): Promise<Transaction>
Create a signed DEMOS transaction to send native tokens to a given address.
Parameters
- to: string
  The reciever
- amount: number
  The amount in DEM
Returns Promise<Transaction>
The signed transaction.
- Defined in src/websdk/demosclass.ts:230

rpcCall

rpcCall(request, isAuthenticated?, retries?, sleepTime?, allowedErrorCodes?): Promise<RPCResponse>
Parameters
- request: RPCRequest
- isAuthenticated: boolean = false
- retries: number = 0
- sleepTime: number = 250
- allowedErrorCodes: number[] = []
Returns Promise<RPCResponse>
- Defined in src/websdk/demosclass.ts:409

sign

sign(raw_tx): Promise<Transaction>
Signs a transaction.
Parameters
- raw_tx: Transaction
  The transaction to sign
Returns Promise<Transaction>
The signed transaction
- Defined in src/websdk/demosclass.ts:275

signMessage

signMessage(message, options?): Promise<{
data: string;
type: SigningAlgorithm;
}>
Signs a message.
Parameters
- message: string | Buffer
  The message to sign
- Optionaloptions: {
  algorithm?: SigningAlgorithm;
  }
  The options for the message signing
  - Optionalalgorithm?: SigningAlgorithm
    The algorithm to use for the message signing. Defaults to the connected wallet's algorithm.
Returns Promise<{
data: string;
type: SigningAlgorithm;
}>
The signature of the message
- Defined in src/websdk/demosclass.ts:352

transfer

transfer(to, amount): Promise<Transaction>
Create a signed DEMOS transaction to send native tokens to a given address.
Parameters
- to: string
  The reciever
- amount: number
  The amount in DEM
Returns Promise<Transaction>
The signed transaction.
- Defined in src/websdk/demosclass.ts:243

verifyMessage

verifyMessage(message, signature, publicKey, options?): Promise<boolean>
Verifies a message.
Parameters
- message: string | Buffer
  The message to verify
- signature: string
  The signature of the message
- publicKey: string
  The public key of the message
- Optionaloptions: {
  algorithm?: SigningAlgorithm;
  }
  The options for the message verification
  - Optionalalgorithm?: SigningAlgorithm
    The algorithm to use for the message verification. Defaults to the connected wallet's algorithm or ed25519 if no wallet is connected.
Returns Promise<boolean>
Whether the message is verified
- Defined in src/websdk/demosclass.ts:387

Class Demos

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Returns Demos

Properties

algorithm

connected

crypto

DemosTransactions

Type declaration

broadcast: ((validationData: RPCResponseWithValidityData, demos: Demos) => Promise<any>)

Parameters

Returns Promise<any>

confirm: ((transaction: Transaction, demos: Demos) => Promise<RPCResponseWithValidityData>)

Parameters

Returns Promise<RPCResponseWithValidityData>

empty: (() => Transaction)

Returns Transaction

prepare: ((data?: any) => Promise<Transaction>)

Parameters

Returns Promise<Transaction>

sign: ((raw_tx: Transaction, keypair: IKeyPair, options: { algorithm: SigningAlgorithm; }) => Promise<Transaction>)

Deprecated

Parameters

algorithm: SigningAlgorithm

Returns Promise<Transaction>

signWithAlgorithm: ((data: string, keypair: IKeyPair, options: { algorithm: SigningAlgorithm; }) => Promise<{ data: string; type: SigningAlgorithm; }>)

Parameters

algorithm: SigningAlgorithm

Returns Promise<{ data: string; type: SigningAlgorithm; }>

pay:function

Parameters

Returns Promise<Transaction>

transfer:function

Parameters

Returns Promise<Transaction>

DemosWebAuth

dual_sign

skeletons

transactions

Type declaration

broadcast: ((validationData: RPCResponseWithValidityData, demos: Demos) => Promise<any>)

Parameters

Returns Promise<any>

confirm: ((transaction: Transaction, demos: Demos) => Promise<RPCResponseWithValidityData>)

Parameters

Returns Promise<RPCResponseWithValidityData>

empty: (() => Transaction)

Returns Transaction

prepare: ((data?: any) => Promise<Transaction>)

Parameters

Returns Promise<Transaction>

sign: ((raw_tx: Transaction, keypair: IKeyPair, options: { algorithm: SigningAlgorithm; }) => Promise<Transaction>)

Deprecated

Parameters

algorithm: SigningAlgorithm

Returns Promise<Transaction>

signWithAlgorithm: ((data: string, keypair: IKeyPair, options: { algorithm: SigningAlgorithm; }) => Promise<{ data: string; type: SigningAlgorithm; }>)

Parameters

algorithm: SigningAlgorithm

Returns Promise<{ data: string; type: SigningAlgorithm; }>

pay:function

Parameters

Returns Promise<Transaction>

transfer:function

Parameters

Returns Promise<Transaction>

tx

Type declaration

broadcast: ((validationData: RPCResponseWithValidityData, demos: Demos) => Promise<any>)

Parameters

Returns Promise<any>

confirm: ((transaction: Transaction, demos: Demos) => Promise<RPCResponseWithValidityData>)

Parameters

Returns Promise<RPCResponseWithValidityData>

sign: ((raw_tx: Transaction, keypair: IKeyPair, options: {
algorithm: SigningAlgorithm;
}) => Promise<Transaction>)

signWithAlgorithm: ((data: string, keypair: IKeyPair, options: {
algorithm: SigningAlgorithm;
}) => Promise<{
data: string;
type: SigningAlgorithm;
}>)

Returns Promise<{
data: string;
type: SigningAlgorithm;
}>

sign: ((raw_tx: Transaction, keypair: IKeyPair, options: {
algorithm: SigningAlgorithm;
}) => Promise<Transaction>)

signWithAlgorithm: ((data: string, keypair: IKeyPair, options: {
algorithm: SigningAlgorithm;
}) => Promise<{
data: string;
type: SigningAlgorithm;
}>)

Returns Promise<{
data: string;
type: SigningAlgorithm;
}>

signWithAlgorithm: ((data: string, keypair: IKeyPair, options: {
algorithm: SigningAlgorithm;
}) => Promise<{
data: string;
type: SigningAlgorithm;
}>)

Returns Promise<{
data: string;
type: SigningAlgorithm;
}>

Returns {
privateKey: NativeBuffer;
publicKey: NativeBuffer;
}

`Static`instance

`Optional`algorithm?: SigningAlgorithm

`Optional`dual_sign?: boolean