@polymeshassociation/polymesh-sdk / api/entities/Account/MultiSig

Defined in: api/entities/Account/MultiSig/index.ts:49

Represents a MultiSig Account. A MultiSig Account is composed of one or more signing Accounts. In order to submit a transaction, a specific amount of those signing Accounts must approve it first

• Account

address: string

Defined in: api/entities/Account/index.ts:110

Polymesh-specific address of the Account. Serves as an identifier

Account.address

authorizations: Authorizations<Account>

Defined in: api/entities/Account/index.ts:119

Account.authorizations

key: string

Defined in: api/entities/Account/index.ts:116

A hex representation of the cryptographic public key of the Account. This is consistent across Substrate chains, while the address depends on the chain as well.

Account.key

staking: Staking

Defined in: api/entities/Account/index.ts:121

Account.staking

subsidies: Subsidies

Defined in: api/entities/Account/index.ts:120

Account.subsidies

uuid: string

Defined in: api/entities/Entity.ts:46

Account.uuid

checkPermissions(permissions): Promise<CheckPermissionsResult<Account>>

Defined in: api/entities/Account/index.ts:394

Check if this Account possesses certain Permissions to act on behalf of its corresponding Identity

Parameter	Type
permissions	SimplePermissions

Promise<CheckPermissionsResult<Account>>

which permissions the Account is missing (if any) and the final result

Account.checkPermissions

details(): Promise<MultiSigDetails>

Defined in: api/entities/Account/MultiSig/index.ts:80

Return details about this MultiSig such as the signing Accounts and the required number of signatures to execute a MultiSigProposal

Promise<MultiSigDetails>

exists(): Promise<boolean>

Defined in: api/entities/Account/index.ts:477

Determine whether this Account exists on chain

Promise<boolean>

Account.exists

getAdmin(): Promise<Identity | null>

Defined in: api/entities/Account/MultiSig/index.ts:264

Returns the Identity of the MultiSig admin. This Identity can add or remove signers directly without creating a MultiSigProposal first.

Promise<Identity | null>

getAssetBalances(args?): Promise<PortfolioBalance[]>

Defined in: api/entities/Account/index.ts:676

Retrieve the balances of all fungible assets in this Account

Parameter	Type	Description
args?	{ assets: (string | FungibleAsset)[]; }	-
args.assets?	(string | FungibleAsset)[]	array of FungibleAssets (or tickers) for which to fetch balances (optional, all balances are retrieved if not passed)

Promise<PortfolioBalance[]>

Account.getAssetBalances

getBalance(): Promise<AccountBalance>

Defined in: api/entities/Account/index.ts:145

Get the free/locked POLYX balance of the Account

Promise<AccountBalance>

Promise that resolves to the Account's POLYX balance information

Account.getBalance

getBalance(callback): Promise<UnsubCallback>

Defined in: api/entities/Account/index.ts:156

Get the free/locked POLYX balance of the Account (with subscription support)

Parameter	Type	Description
callback	SubCallback<AccountBalance>	Callback function that receives balance updates

Promise<UnsubCallback>

Promise that resolves to an unsubscribe function

can be subscribed to, if connected to node using a web socket

Account.getBalance

getCollections(args?): Promise<PortfolioCollection[]>

Defined in: api/entities/Account/index.ts:756

Retrieve the NFTs held in this Account

Parameter	Type	Description
args?	{ collections: (string | NftCollection)[]; }	-
args.collections?	(string | NftCollection)[]	array of NftCollection (or tickers) for which to fetch holdings (optional, all holdings are retrieved if not passed)

Promise<PortfolioCollection[]>

Account.getCollections

getCurrentNonce(): Promise<BigNumber>

Defined in: api/entities/Account/index.ts:491

Retrieve the current nonce for this Account

Promise<BigNumber>

Account.getCurrentNonce

getHistoricalProposals(opts?): Promise<ResultSet<HistoricalMultiSigProposal>>

Defined in: api/entities/Account/MultiSig/index.ts:198

Return a set of MultiSigProposal for this MultiSig Account

Parameter	Type
opts?	{ size?: BigNumber; start?: BigNumber; }
opts.size?	BigNumber
opts.start?	BigNumber

Promise<ResultSet<HistoricalMultiSigProposal>>

uses the middlewareV2

getIdentity(): Promise<Identity | null>

Defined in: api/entities/Account/index.ts:175

Retrieve the Identity associated to this Account (null if there is none)

Promise<Identity | null>

Account.getIdentity

getMultiSig(): Promise<MultiSig | null>

Defined in: api/entities/Account/index.ts:449

Fetch the MultiSig this Account is part of. If this Account is not a signer on any MultiSig, return null

Promise<MultiSig | null>

Account.getMultiSig

getNextAssetId(): Promise<string>

Defined in: api/entities/Account/index.ts:629

Returns next assetID that will be generated for this Identity

Promise<string>

Account.getNextAssetId

getOffChainReceipts(): Promise<BigNumber[]>

Defined in: api/entities/Account/index.ts:602

Returns all off chain receipts used by this Account

Promise<BigNumber[]>

Account.getOffChainReceipts

getPayer(): Promise<Identity | null>

Defined in: api/entities/Account/MultiSig/index.ts:290

Returns the payer for the MultiSig, if set the primary account of the identity will pay for any fees the MultiSig may incur

Promise<Identity | null>

getPendingProposals(): Promise<MultiSigProposal[]>

Defined in: api/entities/Account/index.ts:586

Returns pending MultiSig proposals for this Account

Promise<MultiSigProposal[]>

uses the middleware

if the Account is not a signer on any MultiSig

Account.getPendingProposals

getPermissions(): Promise<Permissions>

Defined in: api/entities/Account/index.ts:341

Retrieve the Permissions this Account has as a Permissioned Account for its corresponding Identity

Promise<Permissions>

if there is no Identity associated with the Account

Account.getPermissions

getPolyxTransactions(filters): Promise<ResultSet<HistoricPolyxTransaction>>

Defined in: api/entities/Account/index.ts:568

Returns POLYX transactions associated with this account

Parameter	Type	Description
filters	{ size?: BigNumber; start?: BigNumber; }	-
filters.size?	BigNumber	page size
filters.start?	BigNumber	page offset

Promise<ResultSet<HistoricPolyxTransaction>>

uses the middleware

Account.getPolyxTransactions

getProposal(args): Promise<MultiSigProposal>

Defined in: api/entities/Account/MultiSig/index.ts:116

Given an ID, fetch a MultiSigProposal for this MultiSig

Parameter	Type
args	{ id: BigNumber; }
args.id	BigNumber

Promise<MultiSigProposal>

if the MultiSigProposal is not found

getProposals(): Promise<MultiSigProposal[]>

Defined in: api/entities/Account/MultiSig/index.ts:136

Return all active MultiSig Proposals for this MultiSig Account

Promise<MultiSigProposal[]>

getTransactionHistory(filters?): Promise<ResultSet<ExtrinsicData>>

Defined in: api/entities/Account/index.ts:211

Retrieve a list of transactions signed by this Account. Can be filtered using parameters

Parameter	Type	Description
filters	{ blockHash?: string; blockNumber?: BigNumber; orderBy?: ExtrinsicsOrderBy; size?: BigNumber; start?: BigNumber; success?: boolean; tag?: TxTag; }	-
filters.blockHash?	string	-
filters.blockNumber?	BigNumber	-
filters.orderBy?	ExtrinsicsOrderBy	-
filters.size?	BigNumber	page size
filters.start?	BigNumber	page offset
filters.success?	boolean	whether the transaction was successful or not
filters.tag?	TxTag	tag associated with the transaction

Promise<ResultSet<ExtrinsicData>>

if both blockNumber and blockHash are passed, only blockNumber is taken into account. Also, for ordering by block_id, one should pass ExtrinsicsOrderBy.BlockIdAsc or ExtrinsicsOrderBy.BlockIdDesc in order of their choice (since block ID is a string field in middleware v2)

uses the middleware v2

Account.getTransactionHistory

getTypeInfo(): Promise<AccountTypeInfo>

Defined in: api/entities/Account/index.ts:512

Retrieve the type of Account, and its relation to an Identity, if applicable

Promise<AccountTypeInfo>

Account.getTypeInfo

isEqual(entity): boolean

Defined in: api/entities/Entity.ts:61

Determine whether this Entity is the same as another one

Parameter	Type
entity	Entity<unknown, unknown>

boolean

Account.isEqual

isFrozen(): Promise<boolean>

Defined in: api/entities/Account/index.ts:320

Check whether this Account is frozen. If frozen, it cannot perform any Identity related action until the primary Account of the Identity unfreezes all secondary Accounts

Promise<boolean>

returns false if the Account isn't associated to any Identity

Account.isFrozen

modify(args, opts?): Promise<GenericPolymeshTransaction<void, void>>

Defined in: api/entities/Account/MultiSig/index.ts:315

Modify the signers for the MultiSig. The signing Account must belong to the Identity of the creator of the MultiSig

Parameter	Type
args	Pick<ModifyMultiSigParams, "signers" | "requiredSignatures">
opts?	ProcedureOpts

Promise<GenericPolymeshTransaction<void, void>>

this method is of type ProcedureMethod, which means you can call modify.checkAuthorization on it to see whether the signing Account and Identity have the required roles and permissions to run it

removePayer(opts?): Promise<GenericPolymeshTransaction<void, void>>

Defined in: api/entities/Account/MultiSig/index.ts:332

A MultiSig's creator is initially responsible for any fees the MultiSig may incur. This method allows for the MultiSig to pay for it's own fees.

Parameter	Type
opts?	ProcedureOpts

Promise<GenericPolymeshTransaction<void, void>>

This method must be called by one of the MultiSig signer's or by the paying identity.

this method is of type NoArgsProcedureMethod, which means you can call removePayer.checkAuthorization on it to see whether the signing Account and Identity have the required roles and permissions to run it

setAdmin(args, opts?): Promise<GenericPolymeshTransaction<void, void>>

Defined in: api/entities/Account/MultiSig/index.ts:324

Set an admin for the MultiSig. When setting an admin it must be signed by one of the MultiSig signers and ran as a proposal. When removing an admin it must be called by account belonging to the admin's identity

Parameter	Type
args	SetMultiSigAdminParams
opts?	ProcedureOpts

Promise<GenericPolymeshTransaction<void, void>>

this method is of type ProcedureMethod, which means you can call setAdmin.checkAuthorization on it to see whether the signing Account and Identity have the required roles and permissions to run it

toHuman(): string

Defined in: api/entities/Account/index.ts:484

Return the Account's address

string

Account.toHuman

static generateUuid<Identifiers>(identifiers): string

Defined in: api/entities/Entity.ts:14

Generate the Entity's UUID from its identifying properties

Type Parameter
Identifiers

Parameter	Type	Description
identifiers	Identifiers	-

string

Account.generateUuid

static unserialize<Identifiers>(serialized): Identifiers

Defined in: api/entities/Entity.ts:23

Unserialize a UUID into its Unique Identifiers

Type Parameter
Identifiers

Parameter	Type	Description
serialized	string	UUID to unserialize

Identifiers

Account.unserialize