Skip to main content

@iota/sdk-wasm

Enumerations​

Classes​

Interfaces​

Type Aliases​

AuthenticatorFunctionRef​

AuthenticatorFunctionRef: Readonly<{
  create: (partial) => AuthenticatorFunctionRef;
  defaults: () => Partial<AuthenticatorFunctionRef>;
  new: (partial) => AuthenticatorFunctionRef;
}>;

Generated factory for AuthenticatorFunctionRef record objects.

AuthenticatorMetadataV1​

AuthenticatorMetadataV1: Readonly<{
  create: (partial) => AuthenticatorMetadataV1;
  defaults: () => Partial<AuthenticatorMetadataV1>;
  new: (partial) => AuthenticatorMetadataV1;
}>;

Generated factory for AuthenticatorMetadataV1 record objects.

BatchSendStatus​

BatchSendStatus: Readonly<{
  create: (partial) => BatchSendStatus;
  defaults: () => Partial<BatchSendStatus>;
  new: (partial) => BatchSendStatus;
}>;

Generated factory for BatchSendStatus record objects.

ChangedObject​

ChangedObject: Readonly<{
  create: (partial) => ChangedObject;
  defaults: () => Partial<ChangedObject>;
  new: (partial) => ChangedObject;
}>;

Generated factory for ChangedObject record objects.

CheckpointSummaryPage​

CheckpointSummaryPage: Readonly<{
  create: (partial) => CheckpointSummaryPage;
  defaults: () => Partial<CheckpointSummaryPage>;
  new: (partial) => CheckpointSummaryPage;
}>;

Generated factory for CheckpointSummaryPage record objects.

CoinInfo​

CoinInfo: Readonly<{
  create: (partial) => CoinInfo;
  defaults: () => Partial<CoinInfo>;
  new: (partial) => CoinInfo;
}>;

Generated factory for CoinInfo record objects.

CoinMetadata​

CoinMetadata: Readonly<{
  create: (partial) => CoinMetadata;
  defaults: () => Partial<CoinMetadata>;
  new: (partial) => CoinMetadata;
}>;

Generated factory for CoinMetadata record objects.

CoinPage​

CoinPage: Readonly<{
  create: (partial) => CoinPage;
  defaults: () => Partial<CoinPage>;
  new: (partial) => CoinPage;
}>;

Generated factory for CoinPage record objects.

CommandArgumentError​

const CommandArgumentError: Readonly<{
  IndexOutOfBounds: typeof IndexOutOfBounds_;
  instanceOf: (obj) => obj is CommandArgumentError;
  InvalidArgumentArity: typeof InvalidArgumentArity_;
  InvalidArgumentToPrivateEntryFunction: typeof InvalidArgumentToPrivateEntryFunction_;
  InvalidBcsBytes: typeof InvalidBcsBytes_;
  InvalidGasCoinUsage: typeof InvalidGasCoinUsage_;
  InvalidObjectByMutRef: typeof InvalidObjectByMutRef_;
  InvalidObjectByValue: typeof InvalidObjectByValue_;
  InvalidResultArity: typeof InvalidResultArity_;
  InvalidUsageOfPureArgument: typeof InvalidUsageOfPureArgument_;
  InvalidValueUsage: typeof InvalidValueUsage_;
  SecondaryIndexOutOfBounds: typeof SecondaryIndexOutOfBounds_;
  SharedObjectOperationNotAllowed: typeof SharedObjectOperationNotAllowed_;
  TypeMismatch: typeof TypeMismatch_;
}>;

An error with an argument to a command

BCS

The BCS serialized form for this type is defined by the following ABNF:

command-argument-error =  type-mismatch
=/ invalid-bcs-bytes
=/ invalid-usage-of-pure-argument
=/ invalid-argument-to-private-entry-function
=/ index-out-of-bounds
=/ secondary-index-out-of-bound
=/ invalid-result-arity
=/ invalid-gas-coin-usage
=/ invalid-value-usage
=/ invalid-object-by-value
=/ invalid-object-by-mut-ref
=/ shared-object-operation-not-allowed

type-mismatch                               = %d00
invalid-bcs-bytes                           = %d01
invalid-usage-of-pure-argument              = %d02
invalid-argument-to-private-entry-function  = %d03
index-out-of-bounds                         = %d04 u16
secondary-index-out-of-bound                = %d05 u16 u16
invalid-result-arity                        = %d06 u16
invalid-gas-coin-usage                      = %d07
invalid-value-usage                         = %d08
invalid-object-by-value                     = %d09
invalid-object-by-mut-ref                   = %d10
shared-object-operation-not-allowed         = %d11

ConfigKey​

ConfigKey: Readonly<{
  create: (partial) => ConfigKey;
  defaults: () => Partial<ConfigKey>;
  new: (partial) => ConfigKey;
}>;

Generated factory for ConfigKey record objects.

default​

default: {
  iota_sdk_ffi: __module;
};

Type Declaration​

iota_sdk_ffi​
iota_sdk_ffi: __module;

DenyRuleSet​

DenyRuleSet: Readonly<{
  create: (partial) => DenyRuleSet;
  defaults: () => Partial<DenyRuleSet>;
  new: (partial) => DenyRuleSet;
}>;

Generated factory for DenyRuleSet record objects.

DryRunEffect​

DryRunEffect: Readonly<{
  create: (partial) => DryRunEffect;
  defaults: () => Partial<DryRunEffect>;
  new: (partial) => DryRunEffect;
}>;

Generated factory for DryRunEffect record objects.

DryRunMutation​

DryRunMutation: Readonly<{
  create: (partial) => DryRunMutation;
  defaults: () => Partial<DryRunMutation>;
  new: (partial) => DryRunMutation;
}>;

Generated factory for DryRunMutation record objects.

DryRunResult​

DryRunResult: Readonly<{
  create: (partial) => DryRunResult;
  defaults: () => Partial<DryRunResult>;
  new: (partial) => DryRunResult;
}>;

Generated factory for DryRunResult record objects.

DryRunReturn​

DryRunReturn: Readonly<{
  create: (partial) => DryRunReturn;
  defaults: () => Partial<DryRunReturn>;
  new: (partial) => DryRunReturn;
}>;

Generated factory for DryRunReturn record objects.

DynamicFieldName​

DynamicFieldName: Readonly<{
  create: (partial) => DynamicFieldName;
  defaults: () => Partial<DynamicFieldName>;
  new: (partial) => DynamicFieldName;
}>;

Generated factory for DynamicFieldName record objects.

DynamicFieldOutput​

DynamicFieldOutput: Readonly<{
  create: (partial) => DynamicFieldOutput;
  defaults: () => Partial<DynamicFieldOutput>;
  new: (partial) => DynamicFieldOutput;
}>;

Generated factory for DynamicFieldOutput record objects.

DynamicFieldOutputPage​

DynamicFieldOutputPage: Readonly<{
  create: (partial) => DynamicFieldOutputPage;
  defaults: () => Partial<DynamicFieldOutputPage>;
  new: (partial) => DynamicFieldOutputPage;
}>;

Generated factory for DynamicFieldOutputPage record objects.

DynamicFieldValue​

DynamicFieldValue: Readonly<{
  create: (partial) => DynamicFieldValue;
  defaults: () => Partial<DynamicFieldValue>;
  new: (partial) => DynamicFieldValue;
}>;

Generated factory for DynamicFieldValue record objects.

EndOfEpochData​

EndOfEpochData: Readonly<{
  create: (partial) => EndOfEpochData;
  defaults: () => Partial<EndOfEpochData>;
  new: (partial) => EndOfEpochData;
}>;

Generated factory for EndOfEpochData record objects.

Epoch​

Epoch: Readonly<{
  create: (partial) => Epoch;
  defaults: () => Partial<Epoch>;
  new: (partial) => Epoch;
}>;

Generated factory for Epoch record objects.

EpochPage​

EpochPage: Readonly<{
  create: (partial) => EpochPage;
  defaults: () => Partial<EpochPage>;
  new: (partial) => EpochPage;
}>;

Generated factory for EpochPage record objects.

Event​

Event: Readonly<{
  create: (partial) => Event;
  defaults: () => Partial<Event>;
  new: (partial) => Event;
}>;

Generated factory for Event record objects.

EventFilter​

EventFilter: Readonly<{
  create: (partial) => EventFilter;
  defaults: () => Partial<EventFilter>;
  new: (partial) => EventFilter;
}>;

Generated factory for EventFilter record objects.

EventPage​

EventPage: Readonly<{
  create: (partial) => EventPage;
  defaults: () => Partial<EventPage>;
  new: (partial) => EventPage;
}>;

Generated factory for EventPage record objects.

EventUpdate​

const EventUpdate: Readonly<{
  Event: typeof Event_;
  instanceOf: (obj) => obj is EventUpdate;
  Interrupted: typeof Interrupted_;
}>;

An item delivered by a subscription.

A subscription recovers from a lost connection or from falling behind the server on its own, so those interruptions are delivered as updates rather than raised as errors: a caller that does not care about the gap can ignore them and keep reading.

ExecutionError​

const ExecutionError: Readonly<{
  AddressDeniedForCoin: typeof AddressDeniedForCoin_;
  ArityMismatch: typeof ArityMismatch_;
  CertificateDenied: typeof CertificateDenied_;
  CircularObjectOwnership: typeof CircularObjectOwnership_;
  CoinBalanceOverflow: typeof CoinBalanceOverflow_;
  CoinTypeGlobalPause: typeof CoinTypeGlobalPause_;
  CommandArgument: typeof CommandArgument_;
  EffectsTooLarge: typeof EffectsTooLarge_;
  ExecutionCanceledDueToExecutionWorkerCongestion: typeof ExecutionCanceledDueToExecutionWorkerCongestion_;
  ExecutionCanceledDueToRandomnessUnavailable: typeof ExecutionCanceledDueToRandomnessUnavailable_;
  ExecutionCanceledDueToSharedObjectCongestion: typeof ExecutionCanceledDueToSharedObjectCongestion_;
  ExecutionCanceledDueToSharedObjectCongestionV2: typeof ExecutionCanceledDueToSharedObjectCongestionV2_;
  FeatureNotYetSupported: typeof FeatureNotYetSupported_;
  FunctionNotFound: typeof FunctionNotFound_;
  InputObjectDeleted: typeof InputObjectDeleted_;
  instanceOf: (obj) => obj is ExecutionError;
  InsufficientCoinBalance: typeof InsufficientCoinBalance_;
  InsufficientGas: typeof InsufficientGas_;
  InvalidGasObject: typeof InvalidGasObject_;
  InvalidLinkage: typeof InvalidLinkage_;
  InvalidPublicFunctionReturnType: typeof InvalidPublicFunctionReturnType_;
  InvalidTransferObject: typeof InvalidTransferObject_;
  InvariantViolation: typeof InvariantViolation_;
  IotaMoveVerification: typeof IotaMoveVerification_;
  IotaMoveVerificationTimeout: typeof IotaMoveVerificationTimeout_;
  MoveAbort: typeof MoveAbort_;
  MoveAuthentication: typeof MoveAuthentication_;
  MovePrimitiveRuntime: typeof MovePrimitiveRuntime_;
  NonEntryFunctionInvoked: typeof NonEntryFunctionInvoked_;
  ObjectTooBig: typeof ObjectTooBig_;
  PackageTooBig: typeof PackageTooBig_;
  PackageUpgrade: typeof PackageUpgrade_;
  PublishErrorNonZeroAddress: typeof PublishErrorNonZeroAddress_;
  PublishUpgradeDependencyDowngrade: typeof PublishUpgradeDependencyDowngrade_;
  PublishUpgradeMissingDependency: typeof PublishUpgradeMissingDependency_;
  SharedObjectOperationNotAllowed: typeof SharedObjectOperationNotAllowed_;
  TypeArgument: typeof TypeArgument_;
  TypeArityMismatch: typeof TypeArityMismatch_;
  UnusedValueWithoutDrop: typeof UnusedValueWithoutDrop_;
  VmInvariantViolation: typeof VmInvariantViolation_;
  VmVerificationOrDeserialization: typeof VmVerificationOrDeserialization_;
  WrittenObjectsTooLarge: typeof WrittenObjectsTooLarge_;
}>;

An error that can occur during the execution of a transaction

BCS

The BCS serialized form for this type is defined by the following ABNF:


execution-error =  insufficient-gas
=/ invalid-gas-object
=/ invariant-violation
=/ feature-not-yet-supported
=/ object-too-big
=/ package-too-big
=/ circular-object-ownership
=/ insufficient-coin-balance
=/ coin-balance-overflow
=/ publish-error-non-zero-address
=/ iota-move-verification-error
=/ move-primitive-runtime-error
=/ move-abort
=/ vm-verification-or-deserialization-error
=/ vm-invariant-violation
=/ function-not-found
=/ arity-mismatch
=/ type-arity-mismatch
=/ non-entry-function-invoked
=/ command-argument-error
=/ type-argument-error
=/ unused-value-without-drop
=/ invalid-public-function-return-type
=/ invalid-transfer-object
=/ effects-too-large
=/ publish-upgrade-missing-dependency
=/ publish-upgrade-dependency-downgrade
=/ package-upgrade-error
=/ written-objects-too-large
=/ certificate-denied
=/ iota-move-verification-timeout
=/ shared-object-operation-not-allowed
=/ input-object-deleted
=/ execution-canceled-due-to-shared-object-congestion
=/ address-denied-for-coin
=/ coin-type-global-pause
=/ execution-canceled-due-to-randomness-unavailable
=/ execution-canceled-due-to-shared-object-congestion-v2
=/ invalid-linkage
=/ move-authentication-error
=/ execution-canceled-due-to-execution-worker-congestion

insufficient-gas                                       = %d00
invalid-gas-object                                     = %d01
invariant-violation                                    = %d02
feature-not-yet-supported                              = %d03
object-too-big                                         = %d04 u64 u64
package-too-big                                        = %d05 u64 u64
circular-object-ownership                              = %d06 object-id
insufficient-coin-balance                              = %d07
coin-balance-overflow                                  = %d08
publish-error-non-zero-address                         = %d09
iota-move-verification-error                           = %d10
move-primitive-runtime-error                           = %d11 (option move-location)
move-abort                                             = %d12 move-location u64
vm-verification-or-deserialization-error               = %d13
vm-invariant-violation                                 = %d14
function-not-found                                     = %d15
arity-mismatch                                         = %d16
type-arity-mismatch                                    = %d17
non-entry-function-invoked                             = %d18
command-argument-error                                 = %d19 u16 command-argument-error
type-argument-error                                    = %d20 u16 type-argument-error
unused-value-without-drop                              = %d21 u16 u16
invalid-public-function-return-type                    = %d22 u16
invalid-transfer-object                                = %d23
effects-too-large                                      = %d24 u64 u64
publish-upgrade-missing-dependency                     = %d25
publish-upgrade-dependency-downgrade                   = %d26
package-upgrade-error                                  = %d27 package-upgrade-error
written-objects-too-large                              = %d28 u64 u64
certificate-denied                                     = %d29
iota-move-verification-timeout                         = %d30
shared-object-operation-not-allowed                    = %d31
input-object-deleted                                   = %d32
execution-canceled-due-to-shared-object-congestion    = %d33 (vector object-id)
address-denied-for-coin                                = %d34 address string
coin-type-global-pause                                 = %d35 string
execution-canceled-due-to-randomness-unavailable      = %d36
execution-canceled-due-to-shared-object-congestion-v2 = %d37 (vector object-id) u64
invalid-linkage                                        = %d38
move-authentication-error                              = %d39 execution-error
execution-canceled-due-to-execution-worker-congestion  = %d40 u64

ExecutionStatus​

const ExecutionStatus: Readonly<{
  Failure: typeof Failure_;
  instanceOf: (obj) => obj is ExecutionStatus;
  Success: typeof Success_;
}>;

The status of an executed Transaction

BCS

The BCS serialized form for this type is defined by the following ABNF:

execution-status = success / failure
success = %d00
failure = %d01 execution-error (option u64)

FaucetReceipt​

FaucetReceipt: Readonly<{
  create: (partial) => FaucetReceipt;
  defaults: () => Partial<FaucetReceipt>;
  new: (partial) => FaucetReceipt;
}>;

Generated factory for FaucetReceipt record objects.

GasCostSummary​

GasCostSummary: Readonly<{
  create: (partial) => GasCostSummary;
  defaults: () => Partial<GasCostSummary>;
  new: (partial) => GasCostSummary;
}>;

Generated factory for GasCostSummary record objects.

GasPayment​

GasPayment: Readonly<{
  create: (partial) => GasPayment;
  defaults: () => Partial<GasPayment>;
  new: (partial) => GasPayment;
}>;

Generated factory for GasPayment record objects.

GqlAddress​

GqlAddress: Readonly<{
  create: (partial) => GqlAddress;
  defaults: () => Partial<GqlAddress>;
  new: (partial) => GqlAddress;
}>;

Generated factory for GqlAddress record objects.

GraphQlEvent​

GraphQlEvent: Readonly<{
  create: (partial) => GraphQlEvent;
  defaults: () => Partial<GraphQlEvent>;
  new: (partial) => GraphQlEvent;
}>;

Generated factory for GraphQlEvent record objects.

ModuleMetadataV1​

ModuleMetadataV1: Readonly<{
  create: (partial) => ModuleMetadataV1;
  defaults: () => Partial<ModuleMetadataV1>;
  new: (partial) => ModuleMetadataV1;
}>;

Generated factory for ModuleMetadataV1 record objects.

MoveEnum​

MoveEnum: Readonly<{
  create: (partial) => MoveEnum;
  defaults: () => Partial<MoveEnum>;
  new: (partial) => MoveEnum;
}>;

Generated factory for MoveEnum record objects.

MoveEnumConnection​

MoveEnumConnection: Readonly<{
  create: (partial) => MoveEnumConnection;
  defaults: () => Partial<MoveEnumConnection>;
  new: (partial) => MoveEnumConnection;
}>;

Generated factory for MoveEnumConnection record objects.

MoveEnumVariant​

MoveEnumVariant: Readonly<{
  create: (partial) => MoveEnumVariant;
  defaults: () => Partial<MoveEnumVariant>;
  new: (partial) => MoveEnumVariant;
}>;

Generated factory for MoveEnumVariant record objects.

MoveField​

MoveField: Readonly<{
  create: (partial) => MoveField;
  defaults: () => Partial<MoveField>;
  new: (partial) => MoveField;
}>;

Generated factory for MoveField record objects.

MoveFunctionConnection​

MoveFunctionConnection: Readonly<{
  create: (partial) => MoveFunctionConnection;
  defaults: () => Partial<MoveFunctionConnection>;
  new: (partial) => MoveFunctionConnection;
}>;

Generated factory for MoveFunctionConnection record objects.

MoveFunctionTypeParameter​

MoveFunctionTypeParameter: Readonly<{
  create: (partial) => MoveFunctionTypeParameter;
  defaults: () => Partial<MoveFunctionTypeParameter>;
  new: (partial) => MoveFunctionTypeParameter;
}>;

Generated factory for MoveFunctionTypeParameter record objects.

MoveLocation​

MoveLocation: Readonly<{
  create: (partial) => MoveLocation;
  defaults: () => Partial<MoveLocation>;
  new: (partial) => MoveLocation;
}>;

Generated factory for MoveLocation record objects.

MoveModule​

MoveModule: Readonly<{
  create: (partial) => MoveModule;
  defaults: () => Partial<MoveModule>;
  new: (partial) => MoveModule;
}>;

Generated factory for MoveModule record objects.

MoveModuleConnection​

MoveModuleConnection: Readonly<{
  create: (partial) => MoveModuleConnection;
  defaults: () => Partial<MoveModuleConnection>;
  new: (partial) => MoveModuleConnection;
}>;

Generated factory for MoveModuleConnection record objects.

MoveModuleQuery​

MoveModuleQuery: Readonly<{
  create: (partial) => MoveModuleQuery;
  defaults: () => Partial<MoveModuleQuery>;
  new: (partial) => MoveModuleQuery;
}>;

Generated factory for MoveModuleQuery record objects.

MoveObject​

MoveObject: Readonly<{
  create: (partial) => MoveObject;
  defaults: () => Partial<MoveObject>;
  new: (partial) => MoveObject;
}>;

Generated factory for MoveObject record objects.

MovePackagePage​

MovePackagePage: Readonly<{
  create: (partial) => MovePackagePage;
  defaults: () => Partial<MovePackagePage>;
  new: (partial) => MovePackagePage;
}>;

Generated factory for MovePackagePage record objects.

MovePackageQuery​

MovePackageQuery: Readonly<{
  create: (partial) => MovePackageQuery;
  defaults: () => Partial<MovePackageQuery>;
  new: (partial) => MovePackageQuery;
}>;

Generated factory for MovePackageQuery record objects.

MoveStruct​

MoveStruct: Readonly<{
  create: (partial) => MoveStruct;
  defaults: () => Partial<MoveStruct>;
  new: (partial) => MoveStruct;
}>;

Generated factory for MoveStruct record objects.

MoveStructConnection​

MoveStructConnection: Readonly<{
  create: (partial) => MoveStructConnection;
  defaults: () => Partial<MoveStructConnection>;
  new: (partial) => MoveStructConnection;
}>;

Generated factory for MoveStructConnection record objects.

MoveStructQuery​

MoveStructQuery: Readonly<{
  create: (partial) => MoveStructQuery;
  defaults: () => Partial<MoveStructQuery>;
  new: (partial) => MoveStructQuery;
}>;

Generated factory for MoveStructQuery record objects.

MoveStructTypeParameter​

MoveStructTypeParameter: Readonly<{
  create: (partial) => MoveStructTypeParameter;
  defaults: () => Partial<MoveStructTypeParameter>;
  new: (partial) => MoveStructTypeParameter;
}>;

Generated factory for MoveStructTypeParameter record objects.

MoveViewResult​

MoveViewResult: Readonly<{
  create: (partial) => MoveViewResult;
  defaults: () => Partial<MoveViewResult>;
  new: (partial) => MoveViewResult;
}>;

Generated factory for MoveViewResult record objects.

NameRegistrationPage​

NameRegistrationPage: Readonly<{
  create: (partial) => NameRegistrationPage;
  defaults: () => Partial<NameRegistrationPage>;
  new: (partial) => NameRegistrationPage;
}>;

Generated factory for NameRegistrationPage record objects.

ObjectFilter​

ObjectFilter: Readonly<{
  create: (partial) => ObjectFilter;
  defaults: () => Partial<ObjectFilter>;
  new: (partial) => ObjectFilter;
}>;

Generated factory for ObjectFilter record objects.

ObjectIn​

const ObjectIn: Readonly<{
  Data: typeof Data_;
  instanceOf: (obj) => obj is ObjectIn;
  Missing: typeof Missing_;
}>;

State of an object prior to execution

If an object exists (at root-level) in the store prior to this transaction, it should be Data, otherwise it's Missing, e.g. wrapped objects should be Missing.

BCS

The BCS serialized form for this type is defined by the following ABNF:

object-in = object-in-missing / object-in-data

object-in-missing = %d00
object-in-data    = %d01 u64 digest owner

ObjectOut​

const ObjectOut: Readonly<{
  instanceOf: (obj) => obj is ObjectOut;
  Missing: typeof Missing_;
  ObjectWrite: typeof ObjectWrite_;
  PackageWrite: typeof PackageWrite_;
}>;

State of an object after execution

BCS

The BCS serialized form for this type is defined by the following ABNF:

object-out  =  object-out-missing
=/ object-out-object-write
=/ object-out-package-write

object-out-missing        = %d00
object-out-object-write   = %d01 digest owner
object-out-package-write  = %d02 version digest

ObjectPage​

ObjectPage: Readonly<{
  create: (partial) => ObjectPage;
  defaults: () => Partial<ObjectPage>;
  new: (partial) => ObjectPage;
}>;

Generated factory for ObjectPage record objects.

ObjectRef​

ObjectRef: Readonly<{
  create: (partial) => ObjectRef;
  defaults: () => Partial<ObjectRef>;
  new: (partial) => ObjectRef;
}>;

Generated factory for ObjectRef record objects.

ObjectReference​

ObjectReference: Readonly<{
  create: (partial) => ObjectReference;
  defaults: () => Partial<ObjectReference>;
  new: (partial) => ObjectReference;
}>;

Generated factory for ObjectReference record objects.

OpenMoveType​

OpenMoveType: Readonly<{
  create: (partial) => OpenMoveType;
  defaults: () => Partial<OpenMoveType>;
  new: (partial) => OpenMoveType;
}>;

Generated factory for OpenMoveType record objects.

PackageUpgradeError​

const PackageUpgradeError: Readonly<{
  DigestDoesNotMatch: typeof DigestDoesNotMatch_;
  IncompatibleUpgrade: typeof IncompatibleUpgrade_;
  instanceOf: (obj) => obj is PackageUpgradeError;
  NotAPackage: typeof NotAPackage_;
  PackageIdDoesNotMatch: typeof PackageIdDoesNotMatch_;
  UnableToFetchPackage: typeof UnableToFetchPackage_;
  UnknownUpgradePolicy: typeof UnknownUpgradePolicy_;
}>;

An error with a upgrading a package

BCS

The BCS serialized form for this type is defined by the following ABNF:

package-upgrade-error = unable-to-fetch-package /
not-a-package           /
incompatible-upgrade    /
digest-does-not-match   /
unknown-upgrade-policy  /
package-id-does-not-match

unable-to-fetch-package     = %d00 object-id
not-a-package               = %d01 object-id
incompatible-upgrade        = %d02
digest-does-not-match       = %d03 digest
unknown-upgrade-policy      = %d04 u8
package-id-does-not-match   = %d05 object-id object-id

PageInfo​

PageInfo: Readonly<{
  create: (partial) => PageInfo;
  defaults: () => Partial<PageInfo>;
  new: (partial) => PageInfo;
}>;

Generated factory for PageInfo record objects.

PaginationFilter​

PaginationFilter: Readonly<{
  create: (partial) => PaginationFilter;
  defaults: () => Partial<PaginationFilter>;
  new: (partial) => PaginationFilter;
}>;

Generated factory for PaginationFilter record objects.

Payment​

Payment: Readonly<{
  create: (partial) => Payment;
  defaults: () => Partial<Payment>;
  new: (partial) => Payment;
}>;

Generated factory for Payment record objects.

PoolTokenExchangeRate​

PoolTokenExchangeRate: Readonly<{
  create: (partial) => PoolTokenExchangeRate;
  defaults: () => Partial<PoolTokenExchangeRate>;
  new: (partial) => PoolTokenExchangeRate;
}>;

Generated factory for PoolTokenExchangeRate record objects.

ProtocolConfigAttr​

ProtocolConfigAttr: Readonly<{
  create: (partial) => ProtocolConfigAttr;
  defaults: () => Partial<ProtocolConfigAttr>;
  new: (partial) => ProtocolConfigAttr;
}>;

Generated factory for ProtocolConfigAttr record objects.

ProtocolConfigFeatureFlag​

ProtocolConfigFeatureFlag: Readonly<{
  create: (partial) => ProtocolConfigFeatureFlag;
  defaults: () => Partial<ProtocolConfigFeatureFlag>;
  new: (partial) => ProtocolConfigFeatureFlag;
}>;

Generated factory for ProtocolConfigFeatureFlag record objects.

ProtocolConfigs​

ProtocolConfigs: Readonly<{
  create: (partial) => ProtocolConfigs;
  defaults: () => Partial<ProtocolConfigs>;
  new: (partial) => ProtocolConfigs;
}>;

Generated factory for ProtocolConfigs record objects.

Query​

Query: Readonly<{
  create: (partial) => Query;
  defaults: () => Partial<Query>;
  new: (partial) => Query;
}>;

Generated factory for Query record objects.

RandomnessStateUpdate​

RandomnessStateUpdate: Readonly<{
  create: (partial) => RandomnessStateUpdate;
  defaults: () => Partial<RandomnessStateUpdate>;
  new: (partial) => RandomnessStateUpdate;
}>;

Generated factory for RandomnessStateUpdate record objects.

SdkFfiError​

const SdkFfiError: {
  Generic: typeof Generic;
  instanceOf: (e) => e is Generic;
};

Type Declaration​

Generic​
Generic: typeof Generic;
instanceOf​
instanceOf: (e) => e is Generic;
Parameters​
e​

any

Returns​

e is Generic

ServiceConfig​

ServiceConfig: Readonly<{
  create: (partial) => ServiceConfig;
  defaults: () => Partial<ServiceConfig>;
  new: (partial) => ServiceConfig;
}>;

Generated factory for ServiceConfig record objects.

SharedObjectReference​

SharedObjectReference: Readonly<{
  create: (partial) => SharedObjectReference;
  defaults: () => Partial<SharedObjectReference>;
  new: (partial) => SharedObjectReference;
}>;

Generated factory for SharedObjectReference record objects.

SignedTransaction​

SignedTransaction: Readonly<{
  create: (partial) => SignedTransaction;
  defaults: () => Partial<SignedTransaction>;
  new: (partial) => SignedTransaction;
}>;

Generated factory for SignedTransaction record objects.

SignedTransactionPage​

SignedTransactionPage: Readonly<{
  create: (partial) => SignedTransactionPage;
  defaults: () => Partial<SignedTransactionPage>;
  new: (partial) => SignedTransactionPage;
}>;

Generated factory for SignedTransactionPage record objects.

SubscriptionEventFilter​

SubscriptionEventFilter: Readonly<{
  create: (partial) => SubscriptionEventFilter;
  defaults: () => Partial<SubscriptionEventFilter>;
  new: (partial) => SubscriptionEventFilter;
}>;

Generated factory for SubscriptionEventFilter record objects.

SubscriptionTransactionFilter​

SubscriptionTransactionFilter: Readonly<{
  create: (partial) => SubscriptionTransactionFilter;
  defaults: () => Partial<SubscriptionTransactionFilter>;
  new: (partial) => SubscriptionTransactionFilter;
}>;

Generated factory for SubscriptionTransactionFilter record objects.

TransactionArgument​

const TransactionArgument: Readonly<{
  GasCoin: typeof GasCoin_;
  Input: typeof Input_;
  instanceOf: (obj) => obj is TransactionArgument;
  Result: typeof Result_;
}>;

A transaction argument used in programmable transactions.

TransactionDataEffects​

TransactionDataEffects: Readonly<{
  create: (partial) => TransactionDataEffects;
  defaults: () => Partial<TransactionDataEffects>;
  new: (partial) => TransactionDataEffects;
}>;

Generated factory for TransactionDataEffects record objects.

TransactionDataEffectsPage​

TransactionDataEffectsPage: Readonly<{
  create: (partial) => TransactionDataEffectsPage;
  defaults: () => Partial<TransactionDataEffectsPage>;
  new: (partial) => TransactionDataEffectsPage;
}>;

Generated factory for TransactionDataEffectsPage record objects.

TransactionDenyRulesUpdate​

TransactionDenyRulesUpdate: Readonly<{
  create: (partial) => TransactionDenyRulesUpdate;
  defaults: () => Partial<TransactionDenyRulesUpdate>;
  new: (partial) => TransactionDenyRulesUpdate;
}>;

Generated factory for TransactionDenyRulesUpdate record objects.

TransactionEffectsPage​

TransactionEffectsPage: Readonly<{
  create: (partial) => TransactionEffectsPage;
  defaults: () => Partial<TransactionEffectsPage>;
  new: (partial) => TransactionEffectsPage;
}>;

Generated factory for TransactionEffectsPage record objects.

TransactionEffectsV1​

TransactionEffectsV1: Readonly<{
  create: (partial) => TransactionEffectsV1;
  defaults: () => Partial<TransactionEffectsV1>;
  new: (partial) => TransactionEffectsV1;
}>;

Generated factory for TransactionEffectsV1 record objects.

TransactionExpiration​

const TransactionExpiration: Readonly<{
  Epoch: typeof Epoch_;
  instanceOf: (obj) => obj is TransactionExpiration;
  None: typeof None_;
}>;

A TTL for a transaction

BCS

The BCS serialized form for this type is defined by the following ABNF:

transaction-expiration =  %d00      ; none
=/ %d01 u64  ; epoch

TransactionMetadata​

TransactionMetadata: Readonly<{
  create: (partial) => TransactionMetadata;
  defaults: () => Partial<TransactionMetadata>;
  new: (partial) => TransactionMetadata;
}>;

Generated factory for TransactionMetadata record objects.

TransactionsFilter​

TransactionsFilter: Readonly<{
  create: (partial) => TransactionsFilter;
  defaults: () => Partial<TransactionsFilter>;
  new: (partial) => TransactionsFilter;
}>;

Generated factory for TransactionsFilter record objects.

TransactionSignerFnOutput​

TransactionSignerFnOutput: Readonly<{
  create: (partial) => TransactionSignerFnOutput;
  defaults: () => Partial<TransactionSignerFnOutput>;
  new: (partial) => TransactionSignerFnOutput;
}>;

Generated factory for TransactionSignerFnOutput record objects.

TransactionUpdate​

const TransactionUpdate: Readonly<{
  instanceOf: (obj) => obj is TransactionUpdate;
  Interrupted: typeof Interrupted_;
  Transaction: typeof Transaction_;
}>;

An item delivered by a subscription.

A subscription recovers from a lost connection or from falling behind the server on its own, so those interruptions are delivered as updates rather than raised as errors: a caller that does not care about the gap can ignore them and keep reading.

TypeOrigin​

TypeOrigin: Readonly<{
  create: (partial) => TypeOrigin;
  defaults: () => Partial<TypeOrigin>;
  new: (partial) => TypeOrigin;
}>;

Generated factory for TypeOrigin record objects.

UnchangedSharedKind​

const UnchangedSharedKind: Readonly<{
  Canceled: typeof Canceled_;
  instanceOf: (obj) => obj is UnchangedSharedKind;
  MutateDeleted: typeof MutateDeleted_;
  PerEpochConfig: typeof PerEpochConfig_;
  ReadDeleted: typeof ReadDeleted_;
  ReadOnlyRoot: typeof ReadOnlyRoot_;
}>;

Type of unchanged shared object

BCS

The BCS serialized form for this type is defined by the following ABNF:

unchanged-shared-object-kind =  read-only-root
=/ mutate-deleted
=/ read-deleted
=/ canceled
=/ per-epoch-config

read-only-root      = %d00 u64 digest
mutate-deleted      = %d01 u64
read-deleted        = %d02 u64
canceled           = %d03 u64
per-epoch-config    = %d04

UnchangedSharedObject​

UnchangedSharedObject: Readonly<{
  create: (partial) => UnchangedSharedObject;
  defaults: () => Partial<UnchangedSharedObject>;
  new: (partial) => UnchangedSharedObject;
}>;

Generated factory for UnchangedSharedObject record objects.

UpgradeInfo​

UpgradeInfo: Readonly<{
  create: (partial) => UpgradeInfo;
  defaults: () => Partial<UpgradeInfo>;
  new: (partial) => UpgradeInfo;
}>;

Generated factory for UpgradeInfo record objects.

Validator​

Validator: Readonly<{
  create: (partial) => Validator;
  defaults: () => Partial<Validator>;
  new: (partial) => Validator;
}>;

Generated factory for Validator record objects.

ValidatorCommittee​

ValidatorCommittee: Readonly<{
  create: (partial) => ValidatorCommittee;
  defaults: () => Partial<ValidatorCommittee>;
  new: (partial) => ValidatorCommittee;
}>;

Generated factory for ValidatorCommittee record objects.

ValidatorCommitteeMember​

ValidatorCommitteeMember: Readonly<{
  create: (partial) => ValidatorCommitteeMember;
  defaults: () => Partial<ValidatorCommitteeMember>;
  new: (partial) => ValidatorCommitteeMember;
}>;

Generated factory for ValidatorCommitteeMember record objects.

ValidatorConnection​

ValidatorConnection: Readonly<{
  create: (partial) => ValidatorConnection;
  defaults: () => Partial<ValidatorConnection>;
  new: (partial) => ValidatorConnection;
}>;

Generated factory for ValidatorConnection record objects.

ValidatorCredentials​

ValidatorCredentials: Readonly<{
  create: (partial) => ValidatorCredentials;
  defaults: () => Partial<ValidatorCredentials>;
  new: (partial) => ValidatorCredentials;
}>;

Generated factory for ValidatorCredentials record objects.

ValidatorPage​

ValidatorPage: Readonly<{
  create: (partial) => ValidatorPage;
  defaults: () => Partial<ValidatorPage>;
  new: (partial) => ValidatorPage;
}>;

Generated factory for ValidatorPage record objects.

ValidatorSet​

ValidatorSet: Readonly<{
  create: (partial) => ValidatorSet;
  defaults: () => Partial<ValidatorSet>;
  new: (partial) => ValidatorSet;
}>;

Generated factory for ValidatorSet record objects.

Functions​