Variable DemosTransactions`Const`

DemosTransactions: {
    broadcast: ((validationData: RPCResponseWithValidityData, demos: Demos) => Promise<any>);
    broadcastAndWait: ((validationData: RPCResponseWithValidityData, demos: Demos, opts?: {
        failFastOnBroadcastError?: boolean;
        pollIntervalMs?: number;
        timeoutMs?: number;
    }) => Promise<{
        broadcast: RPCResponse;
        status: {
            blockNumber?: number;
            state: "included" | "failed";
        };
    }>);
    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;
    }>);
    _demNumberToOsBigint(amountDem: number): bigint;
    createL2PSHashUpdate(l2psUid: string, consolidatedHash: string, transactionCount: number, demos: Demos): Promise<Transaction>;
    pay(to: string, amount: number | bigint, demos: Demos): Promise<Transaction>;
    proposeNetworkUpgrade(params: {
        effectiveAtBlock: number;
        proposalId: string;
        proposedParameters: Partial<NetworkParameters>;
        rationale: string;
    }, demos: Demos): Promise<Transaction>;
    stake(amount: string, connectionUrl: string, demos: Demos): Promise<Transaction>;
    store(bytes: Uint8Array<ArrayBufferLike>, demos: Demos): Promise<Transaction>;
    transfer(to: string, amount: number | bigint, demos: Demos): Promise<Transaction>;
    unstake(demos: Demos): Promise<Transaction>;
    validatorExit(demos: Demos): Promise<Transaction>;
    voteOnUpgrade(proposalId: string, approve: boolean, 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
broadcastAndWait: ((validationData: RPCResponseWithValidityData, demos: Demos, opts?: {
    failFastOnBroadcastError?: boolean;
    pollIntervalMs?: number;
    timeoutMs?: number;
}) => Promise<{
    broadcast: RPCResponse;
    status: {
        blockNumber?: number;
        state: "included" | "failed";
    };
}>)
Broadcast a confirmed transaction and wait for inclusion.

Polls the node's getTransactionStatus RPC until the tx is observed included or failed, or until opts.timeoutMs elapses (default 30s).

Use this when you want a single call with a deterministic outcome. Use plain broadcast() when you want to handle async confirmation yourself.

On timeout, throws BroadcastTimeoutError carrying the tx hash, the last observed state, and the elapsed time so the caller can resume polling.

When opts.failFastOnBroadcastError is true, also throws BroadcastFailedError synchronously when the broadcast itself can't reach the node (e.g., ECONNREFUSED, ENOTFOUND). HTTP 5xx responses are NOT considered fail-fast cases - the server did answer, so the tx may still have landed and polling should run. Defaults to false for one release to preserve current callers' behavior.
- - (validationData, demos, opts?): Promise<{
        broadcast: RPCResponse;
        status: {
            blockNumber?: number;
            state: "included" | "failed";
        };
    }>
  - Parameters
    - validationData: RPCResponseWithValidityData
      The validity data of the transaction (from confirm)
    - demos: Demos
      The demos instance
    - Optionalopts: {
          failFastOnBroadcastError?: boolean;
          pollIntervalMs?: number;
          timeoutMs?: number;
      }
      OptionalfailFastOnBroadcastError?: boolean
      If true, throw BroadcastFailedError immediately when the broadcast can't contact the node. Defaults to false.
      
      OptionalpollIntervalMs?: number
      Delay between status polls. Defaults to 500.
      
      OptionaltimeoutMs?: number
      Total time to wait for inclusion. Defaults to 30_000.
    Returns Promise<{
        broadcast: RPCResponse;
        status: {
            blockNumber?: number;
            state: "included" | "failed";
        };
    }>
    The original broadcast response and the terminal status.
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.
_demNumberToOsBigint:function
- _demNumberToOsBigint(amountDem): bigint
- Convert a legacy DEM number input to an OS bigint for internal carrying. Only whole-DEM number inputs are accepted on this legacy path — fractional DEM is rejected with a clear error directing callers to the bigint OS path (denomination.demToOs).
  
  Rationale: silently flooring (the previous behaviour) discarded up to ~10^9 OS per call without warning. The migration period tolerates legacy number callers, but only at exact DEM granularity — anything sub-DEM must come in as bigint so the caller has explicitly opted into OS arithmetic.
  Parameters
  - amountDem: number
  Returns bigint
  Internal
  - Defined in src/websdk/DemosTransactions.ts:139
createL2PSHashUpdate:function
- createL2PSHashUpdate(l2psUid, consolidatedHash, transactionCount, demos): Promise<Transaction>
- Create a signed L2PS hash update transaction for DTR relay to validators.
  
  L2PS hash updates are self-directed transactions that carry consolidated hash information representing multiple L2PS transactions. These transactions are automatically relayed to validators via DTR (Distributed Transaction Routing) to enable consensus on L2PS network activity without exposing transaction content.
  Parameters
  - l2psUid: string
    The unique identifier of the L2PS network
  - consolidatedHash: string
    SHA-256 hash representing all L2PS transactions
  - transactionCount: number
    Number of transactions included in this hash update
  - demos: Demos
    The demos instance (for getting the address nonce)
  Returns Promise<Transaction>
  The signed L2PS hash update transaction
  Example
```
const hashUpdateTx = await DemosTransactions.createL2PSHashUpdate(
  "l2ps_network_123",
  "0x1234567890abcdef...",
  5,
  demos
)
```
  - Defined in src/websdk/DemosTransactions.ts:550
pay:function
- pay(to, amount, demos): Promise<Transaction>
- Create a signed DEMOS transaction to send native tokens to a given address.
  
  P4 dual-input:
  - bigint: OS amount (preferred — 1 DEM = 10^9 OS).
  - number: DEM amount (legacy, deprecated). Auto-converted to OS.
  Internal carrier in tx.content.amount is bigint OS; the serializerGate (run from demos.sign) emits the right wire shape per the connected node's fork status.
  Parameters
  - to: string
    The reciever
  - amount: number | bigint
    DEM number (legacy) or OS bigint.
  - demos: Demos
    The demos instance (for getting the address nonce)
  Returns Promise<Transaction>
  The signed transaction.
  - Defined in src/websdk/DemosTransactions.ts:65
proposeNetworkUpgrade:function
- proposeNetworkUpgrade(params, demos): Promise<Transaction>
- Create a signed networkUpgrade proposal transaction.
  
  Only active validators may propose. The node rejects proposals whose proposedParameters violate safety bounds (≤50% change, absolute floor/ceiling) or overlap keys with other pending/activating proposals.
  Parameters
  - params: {
        effectiveAtBlock: number;
        proposalId: string;
        proposedParameters: Partial<NetworkParameters>;
        rationale: string;
    }
    - effectiveAtBlock: number
      Activation block. Must be ≥ tallyBlock + grace period.
    - proposalId: string
      UUID. Also used as lexicographic activation-order tiebreaker.
    - proposedParameters: Partial<NetworkParameters>
      Subset of NetworkParameters to change.
    - rationale: string
      Human-readable reason, ≤1024 bytes.
  - demos: Demos
  Returns Promise<Transaction>
  - Defined in src/websdk/DemosTransactions.ts:695
stake:function
- stake(amount, connectionUrl, demos): Promise<Transaction>
- Create a signed validatorStake transaction. Used both for initial validator registration and to top up an existing stake.
  Parameters
  - amount: string
    Stake amount in base-unit DEMOS, encoded as a bigint string.
  - connectionUrl: string
    Validator's public endpoint (required on first stake; subsequent top-ups may overwrite it).
  - demos: Demos
    The demos instance (for nonce + signing).
  Returns Promise<Transaction>
  - Defined in src/websdk/DemosTransactions.ts:599
store:function
- store(bytes, demos): Promise<Transaction>
- Create a signed DEMOS transaction to store binary data on the blockchain. Data is stored in the sender's account.
  Parameters
  - bytes: Uint8Array<ArrayBufferLike>
    The binary data to store (will be base64-encoded)
  - demos: Demos
    The demos instance (for getting the address nonce)
  Returns Promise<Transaction>
  The signed storage transaction.
  - Defined in src/websdk/DemosTransactions.ts:500
transfer:function
- transfer(to, amount, demos): Promise<Transaction>
- Create a signed DEMOS transaction to send native tokens to a given address.
  
  Alias of pay. Same dual-input semantics — bigint OS preferred, number DEM accepted as the deprecated path.
  Parameters
  - to: string
    The reciever
  - amount: number | bigint
    DEM number (legacy) or OS bigint.
  - demos: Demos
    The demos instance (for getting the address nonce)
  Returns Promise<Transaction>
  The signed transaction.
  - Defined in src/websdk/DemosTransactions.ts:164
unstake:function
- unstake(demos): Promise<Transaction>
- Create a signed validatorUnstake transaction. Arms the unstake lock period; after UNSTAKE_LOCK_BLOCKS have elapsed the validator may call validatorExit.
  Parameters
  - demos: Demos
  Returns Promise<Transaction>
  - Defined in src/websdk/DemosTransactions.ts:641
validatorExit:function
- validatorExit(demos): Promise<Transaction>
- Create a signed validatorExit transaction. Only accepted by the network once unstake_available_at <= currentBlock.
  Parameters
  - demos: Demos
  Returns Promise<Transaction>
  - Defined in src/websdk/DemosTransactions.ts:663
voteOnUpgrade:function
- voteOnUpgrade(proposalId, approve, demos): Promise<Transaction>
- Create a signed networkUpgradeVote transaction.
  
  The voter must be in the validator snapshot taken at the proposal's confirmation block, and may cast exactly one vote per proposal (final, non-revocable).
  Parameters
  - proposalId: string
  - approve: boolean
  - demos: Demos
  Returns Promise<Transaction>
  - Defined in src/websdk/DemosTransactions.ts:775

Variable DemosTransactionsConst

Type declaration

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

Parameters

Returns Promise<any>

broadcastAndWait: ((validationData: RPCResponseWithValidityData, demos: Demos, opts?: { failFastOnBroadcastError?: boolean; pollIntervalMs?: number; timeoutMs?: number; }) => Promise<{ broadcast: RPCResponse; status: { blockNumber?: number; state: "included" | "failed"; }; }>)

Parameters

OptionalfailFastOnBroadcastError?: boolean

OptionalpollIntervalMs?: number

OptionaltimeoutMs?: number

Returns Promise<{ broadcast: RPCResponse; status: { blockNumber?: number; state: "included" | "failed"; }; }>

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; }>

_demNumberToOsBigint:function

Parameters

Returns bigint

Internal

createL2PSHashUpdate:function

Parameters

Returns Promise<Transaction>

Example

pay:function

Parameters

Returns Promise<Transaction>

proposeNetworkUpgrade:function

Parameters

effectiveAtBlock: number

proposalId: string

proposedParameters: Partial<NetworkParameters>

rationale: string

Returns Promise<Transaction>

stake:function

Parameters

Returns Promise<Transaction>

store:function

Parameters

Returns Promise<Transaction>

transfer:function

Parameters

Returns Promise<Transaction>

unstake:function

Parameters

Returns Promise<Transaction>

validatorExit:function

Parameters

Returns Promise<Transaction>

voteOnUpgrade:function

Parameters

Returns Promise<Transaction>

Settings

Variable DemosTransactions`Const`

broadcastAndWait: ((validationData: RPCResponseWithValidityData, demos: Demos, opts?: {
failFastOnBroadcastError?: boolean;
pollIntervalMs?: number;
timeoutMs?: number;
}) => Promise<{
broadcast: RPCResponse;
status: {
blockNumber?: number;
state: "included" | "failed";
};
}>)

`Optional`failFastOnBroadcastError?: boolean

`Optional`pollIntervalMs?: number

`Optional`timeoutMs?: number

Returns Promise<{
broadcast: RPCResponse;
status: {
blockNumber?: number;
state: "included" | "failed";
};
}>

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;
}>