deserialize static method

Account deserialize(
  1. Deserializer deserializer
)

Deserializes an account from the provided deserializer.

Throws a StateError for invalid signing schemes or key variants.

Implementation

static Account deserialize(Deserializer deserializer) {
  final schemeAndAddress = deserializeSchemeAndAddress(deserializer);
  final address = schemeAndAddress.address;
  switch (schemeAndAddress.signingScheme) {
    case SigningScheme.ed25519:
      final privateKey = Ed25519PrivateKey.deserialize(deserializer);
      return Ed25519Account(privateKey: privateKey, address: address);
    case SigningScheme.singleKey:
      final variantIndex = deserializer.deserializeUleb128AsU32();
      if (variantIndex == AnyPublicKeyVariant.ed25519.value) {
        final privateKey = Ed25519PrivateKey.deserialize(deserializer);
        return SingleKeyAccount(privateKey: privateKey, address: address);
      } else if (variantIndex == AnyPublicKeyVariant.secp256k1.value) {
        final privateKey = Secp256k1PrivateKey.deserialize(deserializer);
        return SingleKeyAccount(privateKey: privateKey, address: address);
      } else if (variantIndex == AnyPublicKeyVariant.keyless.value) {
        final components = _deserializeKeylessAccountCommon(deserializer);
        final claims = getIssAudAndUidVal(
          jwt: components.jwt,
          uidKey: components.uidKey,
        );
        return KeylessAccount(
          address: address,
          jwt: components.jwt,
          uidKey: components.uidKey,
          pepper: components.pepper,
          ephemeralKeyPair: components.ephemeralKeyPair,
          proof: components.proof,
          verificationKeyHash: components.verificationKeyHash,
          iss: claims.iss,
          uidVal: claims.uidVal,
          aud: claims.aud,
        );
      } else if (variantIndex == AnyPublicKeyVariant.federatedKeyless.value) {
        final components = _deserializeKeylessAccountCommon(deserializer);
        final jwkAddress = AccountAddress.deserialize(deserializer);
        final audless = deserializer.deserializeBool();
        final claims = getIssAudAndUidVal(
          jwt: components.jwt,
          uidKey: components.uidKey,
        );
        return FederatedKeylessAccount(
          address: address,
          jwt: components.jwt,
          uidKey: components.uidKey,
          pepper: components.pepper,
          ephemeralKeyPair: components.ephemeralKeyPair,
          proof: components.proof,
          verificationKeyHash: components.verificationKeyHash,
          jwkAddress: jwkAddress,
          audless: audless,
          iss: claims.iss,
          uidVal: claims.uidVal,
          aud: claims.aud,
        );
      } else {
        throw StateError('Unsupported public key variant $variantIndex');
      }
    case SigningScheme.multiKey:
      final multiKey = MultiKey.deserialize(deserializer);
      final length = deserializer.deserializeUleb128AsU32();
      final signers = <SingleKeySignerOrLegacyEd25519Account>[];
      for (var i = 0; i < length; i += 1) {
        final signer = deserialize(deserializer);
        if (!isSingleKeySigner(signer) && signer is! Ed25519Account) {
          throw StateError(
            'Deserialization of MultiKeyAccount failed. Signer is not a '
            'SingleKeySigner or Ed25519Account',
          );
        }
        signers.add(signer);
      }
      return MultiKeyAccount(
        multiKey: multiKey,
        signers: signers,
        address: address,
      );
    default:
      throw StateError(
        'Deserialization of Account failed: invalid signingScheme value '
        '${schemeAndAddress.signingScheme}',
      );
  }
}