Class Sotez

Main Sotez Library

Example

import { Sotez } from 'sotez';
const tezos = new Sotez('https://127.0.0.1:8732', { defaultFee: 1500, useMutez: false, useLimitEstimator: true });
await tezos.importKey('edskRv6ZnkLQMVustbYHFPNsABu1Js6pEEWyMUFJQTqEZjVCU2WHh8ckcc7YA4uBzPiJjZCsv3pC1NDdV99AnyLzPjSip4uC3y');
const result = await tezos.transfer({
  to: 'tz1RvhdZ5pcjD19vCCK9PgZpnmErTba3dsBs',
  amount: 10,
});

Hierarchy

AbstractTezModule
- Sotez

Constructors

constructor

new Sotez(provider?: string, options?: ModuleOptions): Sotez
Parameters
- provider: string = 'http://127.0.0.1:8732'
- options: ModuleOptions = {}
Returns Sotez

Overrides AbstractTezModule.constructor

Properties

_chain

_chain: string

_debugMode

_debugMode: boolean

_defaultFee

_defaultFee: number

_localForge

_localForge: boolean

_provider

_provider: string

_useLimitEstimator

_useLimitEstimator: boolean

_useMutez

_useMutez: boolean

_validateLocalForge

_validateLocalForge: boolean

key

key: Key

Accessors

chain

get chain(): string
Returns string

Inherited from AbstractTezModule.chain
set chain(value: string): void
Parameters
- value: string
Returns void

Inherited from AbstractTezModule.chain

debugMode

get debugMode(): boolean
Returns boolean

Overrides AbstractTezModule.debugMode
set debugMode(t: boolean): void
Parameters
- t: boolean
Returns void

Overrides AbstractTezModule.debugMode

defaultFee

get defaultFee(): number
Returns number
set defaultFee(fee: number): void
Parameters
- fee: number
Returns void

localForge

get localForge(): boolean
Returns boolean
set localForge(value: boolean): void
Parameters
- value: boolean
Returns void

provider

get provider(): string
Returns string

Inherited from AbstractTezModule.provider
set provider(provider: string): void
Parameters
- provider: string
Returns void

Inherited from AbstractTezModule.provider

useLimitEstimator

get useLimitEstimator(): boolean
Returns boolean
set useLimitEstimator(t: boolean): void
Parameters
- t: boolean
Returns void

useMutez

get useMutez(): boolean
Returns boolean
set useMutez(t: boolean): void
Parameters
- t: boolean
Returns void

validateLocalForge

get validateLocalForge(): boolean
Returns boolean
set validateLocalForge(value: boolean): void
Parameters
- value: boolean
Returns void

Methods

activate

activate(pkh: string, secret: string): Promise<any>
Description
Activate an account

Returns
Object containing the injected operation hash

Example
```
tezos.activate(pkh, secret)
  .then((activateOperation) => console.log(activateOperation));
```
Parameters
- pkh: string
  
  The public key hash of the account
- secret: string
  
  The secret to activate the account
Returns Promise<any>

awaitOperation

awaitOperation(hash: string, interval??: number, timeout??: number): Promise<string>
Description
Check for the inclusion of an operation in new blocks

Returns
The hash of the block in which the operation was included

Example
```
tezos.awaitOperation('ooYf5iK6EdTx3XfBusgDqS6znACTq5469D1zQSDFNrs5KdTuUGi')
 .then((hash) => console.log(hash));
```
Parameters
- hash: string
  
  The operation hash to check
- Optional interval: number = 5
  
  The interval to check new blocks (in seconds)
- Optional timeout: number = 180
  
  The time before the operation times out (in seconds)
Returns Promise<string>

estimateLimits

estimateLimits(operation: <internal>.Operation<string | number> | <internal>.Operation<string | number>[], source?: string): Promise<<internal>.Operation<string | number>[]>
Description
Given operation objects, return the operations with their estimated limits

Returns
The operations with populated limits
Parameters
- operation: <internal>.Operation<string | number> | <internal>.Operation<string | number>[]
  
  The operation object or list of objects
- Optional source: string
  
  The source of the operation
Returns Promise<<internal>.Operation<string | number>[]>

getBaker

getBaker(address: string, block??: string | number): Promise<Baker>

Description

Get the baker information for an address

Returns

The information of the delegate address

Example

tezos.getBaker('tz1fXdNLZ4jrkjtgJWMcfeNpFDK9mbCBsaV4')
  .then(({
    balance,
    frozen_balance,
    frozen_balance_by_cycle,
    staking_balance,
    delegated_contracts,
    delegated_balance,
    deactivated,
    grace_period,
  }) => console.log(
    balance,
    frozen_balance,
    frozen_balance_by_cycle,
    staking_balance,
    delegated_contracts,
    delegated_balance,
    deactivated,
    grace_period,
  ));

Parameters

address: string

The contract for which to retrieve the baker information
Optional block: string | number = 'head'

The block to query against

Returns Promise<Baker>

getBalance

getBalance(address: string, block??: string | number): Promise<string>
Description
Get the balance for a contract

Returns
The balance of the contract

Example
```
tezos.getBalance('tz1fXdNLZ4jrkjtgJWMcfeNpFDK9mbCBsaV4')
  .then(balance => console.log(balance));
```
Parameters
- address: string
  
  The contract for which to retrieve the balance
- Optional block: string | number = 'head'
  
  The block to query against
Returns Promise<string>

getBallotList

getBallotList(block??: string | number): Promise<any[]>
Description
Ballots casted so far during a voting period

Returns
Ballots casted so far during a voting period

Example
```
tezos.getBallotList().then(ballotList => console.log(ballotList));
```
Parameters
- Optional block: string | number = 'head'
  
  The block to query against
Returns Promise<any[]>

getBallots

getBallots(block??: string | number): Promise<{ nay: number; pass: number; yay: number }>
Description
Sum of ballots casted so far during a voting period

Returns
Sum of ballots casted so far during a voting period

Example
```
tezos.getBallots().then(({ yay, nay, pass }) => console.log(yay, nay, pass));
```
Parameters
- Optional block: string | number = 'head'
  
  The block to query against
Returns Promise<{ nay: number; pass: number; yay: number }>

getBlock

getBlock(block??: string | number): Promise<Block>
Description
Get the current head block of the chain

Returns
The current head block

Example
```
tezos.getHead().then(head => console.log(head));
```
Parameters
- Optional block: string | number = 'head'
  
  The block to retrieve
Returns Promise<Block>

getBlockHash

getBlockHash(block??: string | number): Promise<string>
Description
Get the current head block hash of the chain

Returns
The block's hash, its unique identifier

Example
```
tezos.getHeadHash().then(headHash => console.log(headHash))
```
Parameters
- Optional block: string | number = 'head'
  
  The block to retrieve the hash from
Returns Promise<string>

getBlockHeader

getBlockHeader(block??: string | number): Promise<Header>
Description
Get the header of the current head

Returns
The whole block header

Example
```
tezos.getHeader().then(header => console.log(header));
```
Parameters
- Optional block: string | number = 'head'
  
  The block to retrieve the header from
Returns Promise<Header>

getBlockMetadata

getBlockMetadata(block??: string | number): Promise<Header>
Description
Get the metadata of the current head

Returns
The head block metadata

Example
```
tezos.getBlockMetadata().then(metadata => console.log(metadata));
```
Parameters
- Optional block: string | number = 'head'
  
  The block to retrieve the block metadata from
Returns Promise<Header>

getCounter

getCounter(address: string, block??: string | number): Promise<string>
Description
Get the counter for an contract

Returns
The counter of a contract, if any

Example
```
tezos.getCounter('tz1fXdNLZ4jrkjtgJWMcfeNpFDK9mbCBsaV4')
  .then(counter => console.log(counter));
```
Parameters
- address: string
  
  The contract for which to retrieve the counter
- Optional block: string | number = 'head'
  
  The block to query against
Returns Promise<string>

getDelegate

getDelegate(address: string, block??: string | number): Promise<string>
Description
Get the delegate for a contract

Returns
The delegate of a contract, if any

Example
```
tezos.getDelegate('tz1fXdNLZ4jrkjtgJWMcfeNpFDK9mbCBsaV4')
  .then(delegate => console.log(delegate));
```
Parameters
- address: string
  
  The contract for which to retrieve the delegate
- Optional block: string | number = 'head'
  
  The block to query against
Returns Promise<string>

getListings

getListings(block??: string | number): Promise<any[]>
Description
List of delegates with their voting weight, in number of rolls

Returns
The ballots of the current voting period

Example
```
tezos.getListings().then(listings => console.log(listings));
```
Parameters
- Optional block: string | number = 'head'
  
  The block to query against
Returns Promise<any[]>

getManager

getManager(address: string, block??: string): Promise<{ key: string; manager: string }>
Description
Get the manager for a contract

Returns
The manager of a contract

Example
```
tezos.getManager('tz1fXdNLZ4jrkjtgJWMcfeNpFDK9mbCBsaV4')
  .then(({ manager, key }) => console.log(manager, key));
```
Parameters
- address: string
  
  The contract for which to retrieve the manager
- Optional block: string = 'head'
  
  The block to query against
Returns Promise<{ key: string; manager: string }>

getPendingOperations

getPendingOperations(): Promise<any>
Description
Current pending operations in the mempool

Returns
Pending operations

Example
```
tezos.getPendingOperations().then(({ applied }) => console.log(applied));
```
Returns Promise<any>

getProposal

getProposal(block??: string | number): Promise<string>
Description
Current proposal under evaluation

Returns
Current proposal under evaluation

Example
```
tezos.getProposal().then(currentProposal => console.log(currentProposal));
```
Parameters
- Optional block: string | number = 'head'
  
  The block to query against
Returns Promise<string>

getProposalPeriod

getProposalPeriod(block??: string | number): Promise<any>
Description
Current period kind

Returns
Current period kind

Example
```
tezos.getProposalPeriod().then(proposalPeriod => console.log(proposalPeriod));
```
Parameters
- Optional block: string | number = 'head'
  
  The block to query against
Returns Promise<any>

getProposals

getProposals(block??: string | number): Promise<any[]>
Description
List of proposals with number of supporters

Returns
List of proposals with number of supporters

Example
```
tezos.getProposals().then(proposals => {
  console.log(proposals[0][0], proposals[0][1])
  console.log(proposals[1][0], proposals[1][1])
);
```
Parameters
- Optional block: string | number = 'head'
  
  The block to query against
Returns Promise<any[]>

getQuorum

getQuorum(block??: string | number): Promise<number>
Description
Current expected quorum

Returns
Current expected quorum

Example
```
tezos.getQuorum().then(quorum => console.log(quorum));
```
Parameters
- Optional block: string | number = 'head'
  
  The block to query against
Returns Promise<number>

importKey

importKey(key: string, passphrase?: string, email?: string): Promise<void>
Description
Import a secret key

Example
```
await tezos.importKey('edskRv6ZnkLQMVustbYHFPNsABu1Js6pEEWyMUFJQTqEZjVCU2WHh8ckcc7YA4uBzPiJjZCsv3pC1NDdV99AnyLzPjSip4uC3y')
```
Parameters
- key: string
  
  The secret key
- Optional passphrase: string
  
  The passphrase of the encrypted key
- Optional email: string
  
  The email associated with the fundraiser account
Returns Promise<void>

importLedger

importLedger(transport: any, path??: string, curve??: string): Promise<void>
Description
Import a ledger public key

Example
```
import TransportNodeHid from "@ledgerhq/hw-transport-node-hid";
await tezos.importLedger(TransportNodeHid, "44'/1729'/0'/0'");
```
Parameters
- transport: any
  
  The ledger transport (https://github.com/LedgerHQ/ledgerjs)
- Optional path: string = "44'/1729'/0'/0'"
  
  The ledger path
- Optional curve: string = 'tz1'
  
  The curve parameter
Returns Promise<void>

inject

inject(opOb: <internal>.OperationObject, sopbytes: string): Promise<any>
Description
Inject an operation

Returns
Object containing the injected operation hash
Parameters
- opOb: <internal>.OperationObject
  
  The operation object
- sopbytes: string
  
  The signed operation bytes
Returns Promise<any>

loadContract

loadContract(address: string): Promise<Contract>

Description

Looks up a contract and returns an initialized contract

Returns

An initialized contract class

Example

// Load contract
const contract = await tezos.loadContract('KT1MKm4ynxPSzRjw26jPSJbaMFTqTc4dVPdK');
// List defined contract methods
const { methods } = contract;
// Retrieve contract storage
const storage = await contract.storage();
// Get big map keys
await storage.ledger.get('tz1P1n8LvweoarK3DTPSnAHtiGVRujhvR2vk');
// Determine method schema
await contract.methods.transfer('tz1P1n8LvweoarK3DTPSnAHtiGVRujhvR2vk', 100).schema();
// Send contract operation
await contract.methods.transfer('tz1P1n8LvweoarK3DTPSnAHtiGVRujhvR2vk', 100).send({
  fee: '100000',
  gasLimit: '800000',
  storageLimit: '60000',
});

Parameters

address: string

The contract address

Returns Promise<Contract>

originate

originate(paramObject: ContractParams): Promise<any>
Description
Originate a new contract

Returns
Object containing the injected operation hash
Parameters
- paramObject: ContractParams
  
  The parameters for the operation
Returns Promise<any>

packData

packData(data: string | <internal>.Micheline, type: string | <internal>.Micheline): Promise<any>
Description
Serializes a piece of data to a binary representation

Returns
Serialized data
Parameters
- data: string | <internal>.Micheline
  
  The data
- type: string | <internal>.Micheline
  
  The data type
Returns Promise<any>

prepareOperation

prepareOperation(paramObject: OperationParams): Promise<<internal>.ForgedBytes>

Description

Prepares an operation

Returns

Object containing the prepared operation

Example

tezos.prepareOperation({
  operation: {
    kind: 'transaction',
    fee: 1420,
    gas_limit: 10600,
    storage_limit: 300,
    amount: 1000,
    destination: 'tz1RvhdZ5pcjD19vCCK9PgZpnmErTba3dsBs',
  }
}).then(({ opbytes, opOb, counter }) => console.log(opbytes, opOb, counter));

Parameters

paramObject: OperationParams

The parameters for the operation

Returns Promise<<internal>.ForgedBytes>

query

query(path: string, payload?: any, method?: string): Promise<any>
Description
Queries a node given a path and payload

Returns
The response of the query

Example
sotez.query(/chains/main/blocks/head) .then(head => console.log(head));
Parameters
- path: string
  
  The RPC path to query
- Optional payload: any
  
  The payload of the query
- Optional method: string
  
  The request method. Either 'GET' or 'POST'
Returns Promise<any>

Inherited from AbstractTezModule.query

registerDelegate

registerDelegate(paramObject?: { fee?: number; gasLimit?: number; storageLimit?: number }): Promise<any>
Description
Register an account as a delegate

Returns
Object containing the injected operation hash
Parameters
- paramObject: { fee?: number; gasLimit?: number; storageLimit?: number } = {}
  
  The parameters for the operation
  - Optional fee?: number
    
    The fee to set for the transaction
  - Optional gasLimit?: number
    
    The gas limit to set for the transaction
  - Optional storageLimit?: number
    
    The storage limit to set for the transaction
Returns Promise<any>

runCode

runCode(code: string | <internal>.Micheline, amount: number, input: string | <internal>.Micheline, storage: string | <internal>.Micheline, trace??: boolean): Promise<any>
Description
Runs or traces code against an input and storage

Returns
Run results
Parameters
- code: string | <internal>.Micheline
  
  Code to run
- amount: number
  
  Amount in tez to send
- input: string | <internal>.Micheline
  
  Input to run though code
- storage: string | <internal>.Micheline
  
  State of storage
- Optional trace: boolean = false
  
  Whether to trace
Returns Promise<any>

sendOperation

sendOperation(paramObject: OperationParams): Promise<any>

Description

Send an operation

Returns

Object containing the injected operation hash

Example

const operation = {
  kind: 'transaction',
  fee: 1420,
  gas_limit: 10600,
  storage_limit: 300,
  amount: 1000,
  destination: 'tz1RvhdZ5pcjD19vCCK9PgZpnmErTba3dsBs',
};

tezos.sendOperation({ operation }).then(result => console.log(result));

tezos.sendOperation({ operation: [operation, operation] }).then(result => console.log(result));

Parameters

paramObject: OperationParams

The parameters for the operation

Returns Promise<any>

setDelegate

setDelegate(paramObject: { delegate: string; fee?: number; gasLimit?: number; source?: string; storageLimit?: number }): Promise<any>
Description
Set a delegate for an account

Returns
Object containing the injected operation hash
Parameters
- paramObject: { delegate: string; fee?: number; gasLimit?: number; source?: string; storageLimit?: number }
  
  The parameters for the operation
  - delegate: string
    
    The delegate for the new account
  - Optional fee?: number
    
    The fee to set for the transaction
  - Optional gasLimit?: number
    
    The gas limit to set for the transaction
  - Optional source?: string
    
    The source address of the operation
  - Optional storageLimit?: number
    
    The storage limit to set for the transaction
Returns Promise<any>

setProvider

setProvider(provider: string, chain?: string): void
Parameters
- provider: string
- chain: string = ...
Returns void

Inherited from AbstractTezModule.setProvider

silentInject

silentInject(sopbytes: string): Promise<any>
Description
Inject an operation without prevalidation

Returns
Object containing the injected operation hash
Parameters
- sopbytes: string
  
  The signed operation bytes
Returns Promise<any>

simulateOperation

simulateOperation(paramObject: OperationParams): Promise<any>

Description

Simulate an operation

Returns

The simulated operation result

Example

tezos.simulateOperation({
  operation: {
    kind: 'transaction',
    fee: 1420,
    gas_limit: 10600,
    storage_limit: 300,
    amount: 1000,
    destination: 'tz1RvhdZ5pcjD19vCCK9PgZpnmErTba3dsBs',
  },
}).then(result => console.log(result));

Parameters

paramObject: OperationParams

The parameters for the operation

Returns Promise<any>

transfer

transfer(transferParams: <internal>.RpcParams | <internal>.RpcParams[]): Promise<any>
Description
Transfer operation

Returns
Object containing the injected operation hash

Example
```
tezos.transfer({
  to: 'tz1RvhdZ5pcjD19vCCK9PgZpnmErTba3dsBs',
  amount: 1000000,
  fee: 1420,
}).then(result => console.log(result));
```
Parameters
- transferParams: <internal>.RpcParams | <internal>.RpcParams[]
  
  The parameters for the operation
Returns Promise<any>

typecheckCode

typecheckCode(code: string | <internal>.Micheline, gas?: number): Promise<any>
Description
Typechecks the provided code

Returns
Typecheck result
Parameters
- code: string | <internal>.Micheline
  
  The code to typecheck
- gas: number = 10000
  
  The the gas limit
Returns Promise<any>

typecheckData

typecheckData(data: string | <internal>.Micheline, type: string | <internal>.Micheline): Promise<any>
Description
Typechecks data against a type

Returns
Typecheck result
Parameters
- data: string | <internal>.Micheline
  
  The data
- type: string | <internal>.Micheline
  
  The data type
Returns Promise<any>

Class Sotez

Example

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

provider: string = 'http://127.0.0.1:8732'

options: ModuleOptions = {}

Returns Sotez

Properties

_chain

_debugMode

_defaultFee

_localForge

_provider

_useLimitEstimator

_useMutez

_validateLocalForge

key

Accessors

chain

Returns string

Parameters

value: string

Returns void

debugMode

Returns boolean

Parameters

t: boolean

Returns void

defaultFee

Returns number

Parameters

fee: number

Returns void

localForge

Returns boolean

Parameters

value: boolean

Returns void

provider

Returns string

Parameters

provider: string

Returns void

useLimitEstimator

Returns boolean

Parameters

t: boolean

Returns void

useMutez

Returns boolean

Parameters

t: boolean

Returns void

validateLocalForge

Returns boolean

Parameters

value: boolean

Returns void

Methods

activate

Description

Returns

Example

Parameters

pkh: string

secret: string

Returns Promise<any>

awaitOperation

Description

Returns

Example

Parameters

hash: string

`Optional` interval: number = 5

`Optional` timeout: number = 180

`Optional` source: string

`Optional` block: string | number = 'head'

`Optional` block: string | number = 'head'

`Optional` block: string | number = 'head'

`Optional` block: string | number = 'head'

`Optional` block: string | number = 'head'

`Optional` block: string | number = 'head'

`Optional` block: string | number = 'head'

`Optional` block: string | number = 'head'