Class BlockBuilder

constructor

• new BlockBuilder(
      block?:
          | string
          | ArrayBuffer
          | Block
          | {
              $hash: BlockHashString;
              $opening: boolean;
              account: TokenPublicKeyString | NetworkPublicKeyString | StoragePublicKeyString | MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
              date: string;
              network: string;
              operations: (
                  | {
                      amount: string;
                      to: string;
                      token: TokenPublicKeyString;
                      type: SEND;
                  } & { external?: string }
                  | { to: string; type: SET_REP } & {}
                  | {
                      description: string;
                      metadata: string;
                      name: string;
                      type: SET_INFO;
                  } & {
                      defaultPermission?: | false
                      | [string, number[]]
                      | [string, string]
                      | [number[] | BaseFlagNames, number[]];
                  }
                  | {
                      method: AdjustMethod;
                      permissions: | null
                      | false
                      | [string, number[]]
                      | [string, string]
                      | [number[] | BaseFlagNames, number[]];
                      principal: string;
                      type: MODIFY_PERMISSIONS;
                  } & { target?: string }
                  | { identifier: string; type: CREATE_IDENTIFIER } & {
                      createArguments?:
                          | {
                              quorum: string;
                              signers: (
                                  MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString
                              )[];
                              type: MULTISIG;
                          } & {}
                          | {
                              quorum: string;
                              signers: (
                                  MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString
                              )[];
                              type: MULTISIG;
                          } & {};
                  }
                  | { amount: string; method: ADD
                  | SUBTRACT; type: TOKEN_ADMIN_SUPPLY } & {}
                  | {
                      amount: string;
                      method: AdjustMethod;
                      token: TokenPublicKeyString;
                      type: TOKEN_ADMIN_MODIFY_BALANCE;
                  } & {}
                  | {
                      amount: string;
                      from: string;
                      token: TokenPublicKeyString;
                      type: RECEIVE;
                  } & { exact?: boolean; forward?: string }
                  | {
                      certificateOrHash:
                          | string
                          | CertificateHashString
                          | {
                              $hash: CertificateHashString;
                              issuer: string;
                              issuerDN: { name: string; value: string }[];
                              notAfter: string;
                              notBefore: string;
                              serial: string;
                              subject: string;
                              subjectDN: { name: string; value: string }[];
                              subjectPublicKey: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
                          } & {
                              $binary?: string;
                              $chain?: undefined;
                              baseExtensions?: {} & {
                                  authorityKeyIdentifier?: {
                                      contains: string;
                                      type: "context";
                                      value: 0;
                                  } & {};
                                  basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                                  keyUsage?: KeyUsage;
                                  subjectKeyIdentifier?: string;
                              };
                          }
                          | {
                              $hash: CertificateHashString;
                              issuer: string;
                              issuerDN: { name: string; value: string }[];
                              notAfter: string;
                              notBefore: string;
                              serial: string;
                              subject: string;
                              subjectDN: { name: string; value: string }[];
                              subjectPublicKey: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
                          } & {
                              $binary?: string;
                              $chain?: undefined;
                              baseExtensions?: {} & {
                                  authorityKeyIdentifier?: {
                                      contains: string;
                                      type: "context";
                                      value: 0;
                                  } & {};
                                  basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                                  keyUsage?: KeyUsage;
                                  subjectKeyIdentifier?: string;
                              };
                          };
                      method: ADD
                      | SUBTRACT;
                      type: MANAGE_CERTIFICATE;
                  } & {
                      intermediateCertificates?: | null
                      | string
                      | { certificates: string[] };
                  }
              )[];
              previous: BlockHashString;
              purpose: BlockPurpose;
              signer: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString | [MultisigPublicKeyString, (Secp256K1PublicKeyString | ... 2 more ... | [...])[]];
              version: 1
              | 2;
          } & {
              $binary?: string;
              idempotent?: string;
              signature?: string;
              signatures?: string[];
              subnet?: string;
          }
          | BlockJSON
          | {
              $hash: BlockHashString;
              $opening: boolean;
              account: TokenPublicKeyString | NetworkPublicKeyString | StoragePublicKeyString | MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
              date: string;
              network: string;
              operations: (
                  | {
                      amount: string;
                      to: string;
                      token: TokenPublicKeyString;
                      type: SEND;
                  } & { external?: string }
                  | { to: string; type: SET_REP } & {}
                  | {
                      description: string;
                      metadata: string;
                      name: string;
                      type: SET_INFO;
                  } & {
                      defaultPermission?: | false
                      | [string, number[]]
                      | [string, string]
                      | [number[] | BaseFlagNames, number[]];
                  }
                  | {
                      method: AdjustMethod;
                      permissions: | null
                      | false
                      | [string, number[]]
                      | [string, string]
                      | [number[] | BaseFlagNames, number[]];
                      principal: string;
                      type: MODIFY_PERMISSIONS;
                  } & { target?: string }
                  | { identifier: string; type: CREATE_IDENTIFIER } & {
                      createArguments?:
                          | {
                              quorum: string;
                              signers: (
                                  MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString
                              )[];
                              type: MULTISIG;
                          } & {}
                          | {
                              quorum: string;
                              signers: (
                                  MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString
                              )[];
                              type: MULTISIG;
                          } & {};
                  }
                  | { amount: string; method: ADD
                  | SUBTRACT; type: TOKEN_ADMIN_SUPPLY } & {}
                  | {
                      amount: string;
                      method: AdjustMethod;
                      token: TokenPublicKeyString;
                      type: TOKEN_ADMIN_MODIFY_BALANCE;
                  } & {}
                  | {
                      amount: string;
                      from: string;
                      token: TokenPublicKeyString;
                      type: RECEIVE;
                  } & { exact?: boolean; forward?: string }
                  | {
                      certificateOrHash:
                          | string
                          | CertificateHashString
                          | {
                              $hash: CertificateHashString;
                              issuer: string;
                              issuerDN: { name: string; value: string }[];
                              notAfter: string;
                              notBefore: string;
                              serial: string;
                              subject: string;
                              subjectDN: { name: string; value: string }[];
                              subjectPublicKey: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
                          } & {
                              $binary?: string;
                              $chain?: undefined;
                              baseExtensions?: {} & {
                                  authorityKeyIdentifier?: {
                                      contains: string;
                                      type: "context";
                                      value: 0;
                                  } & {};
                                  basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                                  keyUsage?: KeyUsage;
                                  subjectKeyIdentifier?: string;
                              };
                          }
                          | {
                              $hash: CertificateHashString;
                              issuer: string;
                              issuerDN: { name: string; value: string }[];
                              notAfter: string;
                              notBefore: string;
                              serial: string;
                              subject: string;
                              subjectDN: { name: string; value: string }[];
                              subjectPublicKey: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
                          } & {
                              $binary?: string;
                              $chain?: undefined;
                              baseExtensions?: {} & {
                                  authorityKeyIdentifier?: {
                                      contains: string;
                                      type: "context";
                                      value: 0;
                                  } & {};
                                  basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                                  keyUsage?: KeyUsage;
                                  subjectKeyIdentifier?: string;
                              };
                          };
                      method: ADD
                      | SUBTRACT;
                      type: MANAGE_CERTIFICATE;
                  } & {
                      intermediateCertificates?: | null
                      | string
                      | { certificates: string[] };
                  }
              )[];
              previous: BlockHashString;
              purpose: BlockPurpose;
              signer: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString | [MultisigPublicKeyString, (Secp256K1PublicKeyString | ... 2 more ... | [...])[]];
              version: 1
              | 2;
          } & {
              $binary?: string;
              idempotent?: string;
              signature?: string;
              signatures?: string[];
              subnet?: string;
          }
          | BlockJSONIncomplete,
  ): BlockBuilder

  Parameters

  • Optionalblock:
        | string
        | ArrayBuffer
        | Block
        | {
            $hash: BlockHashString;
            $opening: boolean;
            account: TokenPublicKeyString | NetworkPublicKeyString | StoragePublicKeyString | MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
            date: string;
            network: string;
            operations: (
                | {
                    amount: string;
                    to: string;
                    token: TokenPublicKeyString;
                    type: SEND;
                } & { external?: string }
                | { to: string; type: SET_REP } & {}
                | { description: string; metadata: string; name: string; type: SET_INFO } & {
                    defaultPermission?:
                        | false
                        | [string, number[]]
                        | [string, string]
                        | [number[] | BaseFlagNames, number[]];
                }
                | {
                    method: AdjustMethod;
                    permissions: | null
                    | false
                    | [string, number[]]
                    | [string, string]
                    | [number[] | BaseFlagNames, number[]];
                    principal: string;
                    type: MODIFY_PERMISSIONS;
                } & { target?: string }
                | { identifier: string; type: CREATE_IDENTIFIER } & {
                    createArguments?:
                        | {
                            quorum: string;
                            signers: (
                                MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString
                            )[];
                            type: MULTISIG;
                        } & {}
                        | {
                            quorum: string;
                            signers: (
                                MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString
                            )[];
                            type: MULTISIG;
                        } & {};
                }
                | { amount: string; method: ADD
                | SUBTRACT; type: TOKEN_ADMIN_SUPPLY } & {}
                | {
                    amount: string;
                    method: AdjustMethod;
                    token: TokenPublicKeyString;
                    type: TOKEN_ADMIN_MODIFY_BALANCE;
                } & {}
                | {
                    amount: string;
                    from: string;
                    token: TokenPublicKeyString;
                    type: RECEIVE;
                } & { exact?: boolean; forward?: string }
                | {
                    certificateOrHash:
                        | string
                        | CertificateHashString
                        | {
                            $hash: CertificateHashString;
                            issuer: string;
                            issuerDN: { name: string; value: string }[];
                            notAfter: string;
                            notBefore: string;
                            serial: string;
                            subject: string;
                            subjectDN: { name: string; value: string }[];
                            subjectPublicKey: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
                        } & {
                            $binary?: string;
                            $chain?: undefined;
                            baseExtensions?: {} & {
                                authorityKeyIdentifier?: {
                                    contains: string;
                                    type: "context";
                                    value: 0;
                                } & {};
                                basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                                keyUsage?: KeyUsage;
                                subjectKeyIdentifier?: string;
                            };
                        }
                        | {
                            $hash: CertificateHashString;
                            issuer: string;
                            issuerDN: { name: string; value: string }[];
                            notAfter: string;
                            notBefore: string;
                            serial: string;
                            subject: string;
                            subjectDN: { name: string; value: string }[];
                            subjectPublicKey: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
                        } & {
                            $binary?: string;
                            $chain?: undefined;
                            baseExtensions?: {} & {
                                authorityKeyIdentifier?: {
                                    contains: string;
                                    type: "context";
                                    value: 0;
                                } & {};
                                basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                                keyUsage?: KeyUsage;
                                subjectKeyIdentifier?: string;
                            };
                        };
                    method: ADD
                    | SUBTRACT;
                    type: MANAGE_CERTIFICATE;
                } & {
                    intermediateCertificates?: null
                    | string
                    | { certificates: string[] };
                }
            )[];
            previous: BlockHashString;
            purpose: BlockPurpose;
            signer: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString | [MultisigPublicKeyString, (Secp256K1PublicKeyString | ... 2 more ... | [...])[]];
            version: 1
            | 2;
        } & {
            $binary?: string;
            idempotent?: string;
            signature?: string;
            signatures?: string[];
            subnet?: string;
        }
        | BlockJSON
        | {
            $hash: BlockHashString;
            $opening: boolean;
            account: TokenPublicKeyString | NetworkPublicKeyString | StoragePublicKeyString | MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
            date: string;
            network: string;
            operations: (
                | {
                    amount: string;
                    to: string;
                    token: TokenPublicKeyString;
                    type: SEND;
                } & { external?: string }
                | { to: string; type: SET_REP } & {}
                | { description: string; metadata: string; name: string; type: SET_INFO } & {
                    defaultPermission?:
                        | false
                        | [string, number[]]
                        | [string, string]
                        | [number[] | BaseFlagNames, number[]];
                }
                | {
                    method: AdjustMethod;
                    permissions: | null
                    | false
                    | [string, number[]]
                    | [string, string]
                    | [number[] | BaseFlagNames, number[]];
                    principal: string;
                    type: MODIFY_PERMISSIONS;
                } & { target?: string }
                | { identifier: string; type: CREATE_IDENTIFIER } & {
                    createArguments?:
                        | {
                            quorum: string;
                            signers: (
                                MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString
                            )[];
                            type: MULTISIG;
                        } & {}
                        | {
                            quorum: string;
                            signers: (
                                MultisigPublicKeyString | Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString
                            )[];
                            type: MULTISIG;
                        } & {};
                }
                | { amount: string; method: ADD
                | SUBTRACT; type: TOKEN_ADMIN_SUPPLY } & {}
                | {
                    amount: string;
                    method: AdjustMethod;
                    token: TokenPublicKeyString;
                    type: TOKEN_ADMIN_MODIFY_BALANCE;
                } & {}
                | {
                    amount: string;
                    from: string;
                    token: TokenPublicKeyString;
                    type: RECEIVE;
                } & { exact?: boolean; forward?: string }
                | {
                    certificateOrHash:
                        | string
                        | CertificateHashString
                        | {
                            $hash: CertificateHashString;
                            issuer: string;
                            issuerDN: { name: string; value: string }[];
                            notAfter: string;
                            notBefore: string;
                            serial: string;
                            subject: string;
                            subjectDN: { name: string; value: string }[];
                            subjectPublicKey: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
                        } & {
                            $binary?: string;
                            $chain?: undefined;
                            baseExtensions?: {} & {
                                authorityKeyIdentifier?: {
                                    contains: string;
                                    type: "context";
                                    value: 0;
                                } & {};
                                basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                                keyUsage?: KeyUsage;
                                subjectKeyIdentifier?: string;
                            };
                        }
                        | {
                            $hash: CertificateHashString;
                            issuer: string;
                            issuerDN: { name: string; value: string }[];
                            notAfter: string;
                            notBefore: string;
                            serial: string;
                            subject: string;
                            subjectDN: { name: string; value: string }[];
                            subjectPublicKey: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString;
                        } & {
                            $binary?: string;
                            $chain?: undefined;
                            baseExtensions?: {} & {
                                authorityKeyIdentifier?: {
                                    contains: string;
                                    type: "context";
                                    value: 0;
                                } & {};
                                basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                                keyUsage?: KeyUsage;
                                subjectKeyIdentifier?: string;
                            };
                        };
                    method: ADD
                    | SUBTRACT;
                    type: MANAGE_CERTIFICATE;
                } & {
                    intermediateCertificates?: null
                    | string
                    | { certificates: string[] };
                }
            )[];
            previous: BlockHashString;
            purpose: BlockPurpose;
            signer: Secp256K1PublicKeyString | Secp256R1PublicKeyString | ED25519PublicKeyString | [MultisigPublicKeyString, (Secp256K1PublicKeyString | ... 2 more ... | [...])[]];
            version: 1
            | 2;
        } & {
            $binary?: string;
            idempotent?: string;
            signature?: string;
            signatures?: string[];
            subnet?: string;
        }
        | BlockJSONIncomplete

  Returns BlockBuilder

StaticAdjustMethod

StaticisInstance

StaticNO_PREVIOUS

StaticOperation

StaticOperationType

$opening

• get $opening(): undefined | boolean

  Returns undefined | boolean

account

• get account(): undefined | GenericAccount

  Returns undefined | GenericAccount

• set account(account: undefined | string | GenericAccount): void

  Parameters

  • account: undefined | string | GenericAccount

  Returns void

block

• get block(): undefined | Block

  Returns undefined | Block

date

• get date(): undefined | Date

  Returns undefined | Date

• set date(date: undefined | string | Date): void

  Parameters

  • date: undefined | string | Date

  Returns void

hash

• get hash(): undefined | BlockHash

  Returns undefined | BlockHash

idempotent

• get idempotent(): undefined | string

  Returns undefined | string

• set idempotent(idempotent: string | Buffer | ArrayBuffer): void

  Parameters

  • idempotent: string | Buffer | ArrayBuffer

  Returns void

network

• get network(): undefined | bigint

  Returns undefined | bigint

• set network(network: undefined | string | bigint): void

  Parameters

  • network: undefined | string | bigint

  Returns void

operations

• get operations(): undefined | BlockOperations[]

  Returns undefined | BlockOperations[]

previous

• get previous(): undefined | BlockHash

  Returns undefined | BlockHash

• set previous(blockhash: undefined | string | BlockHash): void

  Parameters

  • blockhash: undefined | string | BlockHash

  Returns void

purpose

• get purpose(): BlockPurpose

  Returns BlockPurpose

• set purpose(purpose: undefined | BlockPurpose): void

  Parameters

  • purpose: undefined | BlockPurpose

  Returns void

sealed

• get sealed(): boolean

  Returns boolean

signer

• get signer(): undefined | BlockSignerFieldJSON

  Returns undefined | BlockSignerFieldJSON

• set signer(signer: undefined | BlockSignerFieldJSON): void

  Parameters

  • signer: undefined | BlockSignerFieldJSON

  Returns void

subnet

• get subnet(): undefined | bigint

  Returns undefined | bigint

• set subnet(subnet: undefined | string | bigint): void

  Parameters

  • subnet: undefined | string | bigint

  Returns void

version

• get version(): undefined | number

  Returns undefined | number

• set version(version: undefined | number): void

  Parameters

  • version: undefined | number

  Returns void

addOperation

• addOperation(
      operation:
          | BlockJSONOperationSEND
          | BlockJSONOperationSET_REP
          | BlockJSONOperationSET_INFO
          | BlockJSONOperationMODIFY_PERMISSIONS
          | BlockJSONOperationCREATE_IDENTIFIER
          | BlockJSONOperationTOKEN_ADMIN_SUPPLY
          | BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE
          | BlockJSONOperationRECEIVE
          | BlockJSONOperationMANAGE_CERTIFICATE,
  ): void

  Parameters

  • operation:
        | BlockJSONOperationSEND
        | BlockJSONOperationSET_REP
        | BlockJSONOperationSET_INFO
        | BlockJSONOperationMODIFY_PERMISSIONS
        | BlockJSONOperationCREATE_IDENTIFIER
        | BlockJSONOperationTOKEN_ADMIN_SUPPLY
        | BlockJSONOperationTOKEN_ADMIN_MODIFY_BALANCE
        | BlockJSONOperationRECEIVE
        | BlockJSONOperationMANAGE_CERTIFICATE

  Returns void

getUnsignedBlock

• getUnsignedBlock(): Promise<UnsignedBlock>

  Returns Promise<UnsignedBlock>

seal

• seal(): Promise<Block>

  Returns Promise<Block>

toJSON

• toJSON(
      opts?: ToJSONSerializableOptions<boolean>,
  ): { purpose: BlockPurpose } & {
      $opening?: boolean;
      account?:
          | TokenPublicKeyString
          | NetworkPublicKeyString
          | StoragePublicKeyString
          | MultisigPublicKeyString
          | Secp256K1PublicKeyString
          | Secp256R1PublicKeyString
          | ED25519PublicKeyString;
      date?: string;
      idempotent?: string;
      network?: string;
      operations?: (
          | {
              amount: string;
              to: string;
              token: TokenPublicKeyString;
              type: SEND;
          } & { external?: string }
          | { to: string; type: SET_REP } & {}
          | { description: string; metadata: string; name: string; type: SET_INFO } & {
              defaultPermission?:
                  | false
                  | [string, number[]]
                  | [string, string]
                  | [number[] | BaseFlagNames, number[]];
          }
          | {
              method: AdjustMethod;
              permissions: | null
              | false
              | [string, number[]]
              | [string, string]
              | [number[] | BaseFlagNames, number[]];
              principal: string;
              type: MODIFY_PERMISSIONS;
          } & { target?: string }
          | { identifier: string; type: CREATE_IDENTIFIER } & {
              createArguments?:
                  | {
                      quorum: string;
                      signers: (
                          | MultisigPublicKeyString
                          | Secp256K1PublicKeyString
                          | Secp256R1PublicKeyString
                          | ED25519PublicKeyString
                      )[];
                      type: MULTISIG;
                  } & {}
                  | {
                      quorum: string;
                      signers: (
                          | MultisigPublicKeyString
                          | Secp256K1PublicKeyString
                          | Secp256R1PublicKeyString
                          | ED25519PublicKeyString
                      )[];
                      type: MULTISIG;
                  } & {};
          }
          | { amount: string; method: ADD
          | SUBTRACT; type: TOKEN_ADMIN_SUPPLY } & {}
          | {
              amount: string;
              method: AdjustMethod;
              token: TokenPublicKeyString;
              type: TOKEN_ADMIN_MODIFY_BALANCE;
          } & {}
          | {
              amount: string;
              from: string;
              token: TokenPublicKeyString;
              type: RECEIVE;
          } & { exact?: boolean; forward?: string }
          | {
              certificateOrHash:
                  | string
                  | CertificateHashString
                  | {
                      $hash: CertificateHashString;
                      issuer: string;
                      issuerDN: { name: string; value: string }[];
                      notAfter: string;
                      notBefore: string;
                      serial: string;
                      subject: string;
                      subjectDN: { name: string; value: string }[];
                      subjectPublicKey:
                          | Secp256K1PublicKeyString
                          | Secp256R1PublicKeyString
                          | ED25519PublicKeyString;
                  } & {
                      $binary?: string;
                      $chain?: undefined;
                      baseExtensions?: {} & {
                          authorityKeyIdentifier?: {
                              contains: string;
                              type: "context";
                              value: 0;
                          } & {};
                          basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                          keyUsage?: KeyUsage;
                          subjectKeyIdentifier?: string;
                      };
                  }
                  | {
                      $hash: CertificateHashString;
                      issuer: string;
                      issuerDN: { name: string; value: string }[];
                      notAfter: string;
                      notBefore: string;
                      serial: string;
                      subject: string;
                      subjectDN: { name: string; value: string }[];
                      subjectPublicKey:
                          | Secp256K1PublicKeyString
                          | Secp256R1PublicKeyString
                          | ED25519PublicKeyString;
                  } & {
                      $binary?: string;
                      $chain?: undefined;
                      baseExtensions?: {} & {
                          authorityKeyIdentifier?: {
                              contains: string;
                              type: "context";
                              value: 0;
                          } & {};
                          basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                          keyUsage?: KeyUsage;
                          subjectKeyIdentifier?: string;
                      };
                  };
              method: ADD
              | SUBTRACT;
              type: MANAGE_CERTIFICATE;
          } & {
              intermediateCertificates?: null
              | string
              | { certificates: string[] };
          }
      )[];
      previous?: BlockHashString;
      signer?: | string
      | [
          string,
          (
              | string
              | [
                  string,
                  (
                      | string
                      | [string, (string | [string, (string | [string, never[]])[]])[]]
                  )[],
              ]
          )[],
      ];
      subnet?: string;
      version?: number;
  }

  Parameters

  • Optionalopts: ToJSONSerializableOptions<boolean>

  Returns { purpose: BlockPurpose } & {
      $opening?: boolean;
      account?:
          | TokenPublicKeyString
          | NetworkPublicKeyString
          | StoragePublicKeyString
          | MultisigPublicKeyString
          | Secp256K1PublicKeyString
          | Secp256R1PublicKeyString
          | ED25519PublicKeyString;
      date?: string;
      idempotent?: string;
      network?: string;
      operations?: (
          | {
              amount: string;
              to: string;
              token: TokenPublicKeyString;
              type: SEND;
          } & { external?: string }
          | { to: string; type: SET_REP } & {}
          | { description: string; metadata: string; name: string; type: SET_INFO } & {
              defaultPermission?:
                  | false
                  | [string, number[]]
                  | [string, string]
                  | [number[] | BaseFlagNames, number[]];
          }
          | {
              method: AdjustMethod;
              permissions: | null
              | false
              | [string, number[]]
              | [string, string]
              | [number[] | BaseFlagNames, number[]];
              principal: string;
              type: MODIFY_PERMISSIONS;
          } & { target?: string }
          | { identifier: string; type: CREATE_IDENTIFIER } & {
              createArguments?:
                  | {
                      quorum: string;
                      signers: (
                          | MultisigPublicKeyString
                          | Secp256K1PublicKeyString
                          | Secp256R1PublicKeyString
                          | ED25519PublicKeyString
                      )[];
                      type: MULTISIG;
                  } & {}
                  | {
                      quorum: string;
                      signers: (
                          | MultisigPublicKeyString
                          | Secp256K1PublicKeyString
                          | Secp256R1PublicKeyString
                          | ED25519PublicKeyString
                      )[];
                      type: MULTISIG;
                  } & {};
          }
          | { amount: string; method: ADD
          | SUBTRACT; type: TOKEN_ADMIN_SUPPLY } & {}
          | {
              amount: string;
              method: AdjustMethod;
              token: TokenPublicKeyString;
              type: TOKEN_ADMIN_MODIFY_BALANCE;
          } & {}
          | {
              amount: string;
              from: string;
              token: TokenPublicKeyString;
              type: RECEIVE;
          } & { exact?: boolean; forward?: string }
          | {
              certificateOrHash:
                  | string
                  | CertificateHashString
                  | {
                      $hash: CertificateHashString;
                      issuer: string;
                      issuerDN: { name: string; value: string }[];
                      notAfter: string;
                      notBefore: string;
                      serial: string;
                      subject: string;
                      subjectDN: { name: string; value: string }[];
                      subjectPublicKey:
                          | Secp256K1PublicKeyString
                          | Secp256R1PublicKeyString
                          | ED25519PublicKeyString;
                  } & {
                      $binary?: string;
                      $chain?: undefined;
                      baseExtensions?: {} & {
                          authorityKeyIdentifier?: {
                              contains: string;
                              type: "context";
                              value: 0;
                          } & {};
                          basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                          keyUsage?: KeyUsage;
                          subjectKeyIdentifier?: string;
                      };
                  }
                  | {
                      $hash: CertificateHashString;
                      issuer: string;
                      issuerDN: { name: string; value: string }[];
                      notAfter: string;
                      notBefore: string;
                      serial: string;
                      subject: string;
                      subjectDN: { name: string; value: string }[];
                      subjectPublicKey:
                          | Secp256K1PublicKeyString
                          | Secp256R1PublicKeyString
                          | ED25519PublicKeyString;
                  } & {
                      $binary?: string;
                      $chain?: undefined;
                      baseExtensions?: {} & {
                          authorityKeyIdentifier?: {
                              contains: string;
                              type: "context";
                              value: 0;
                          } & {};
                          basicConstraints?: [ca: boolean, pathLenConstraint?: null | string];
                          keyUsage?: KeyUsage;
                          subjectKeyIdentifier?: string;
                      };
                  };
              method: ADD
              | SUBTRACT;
              type: MANAGE_CERTIFICATE;
          } & {
              intermediateCertificates?: null
              | string
              | { certificates: string[] };
          }
      )[];
      previous?: BlockHashString;
      signer?: | string
      | [
          string,
          (
              | string
              | [
                  string,
                  (
                      | string
                      | [string, (string | [string, (string | [string, never[]])[]])[]]
                  )[],
              ]
          )[],
      ];
      subnet?: string;
      version?: number;
  }

unseal

• unseal(): BlockJSONIncomplete

  Returns BlockJSONIncomplete