Enum sui::keytool::KeyToolCommand

pub enum KeyToolCommand {
    Alias {
        old_alias: String,
        new_alias: Option<String>,
    },
    Convert {
        value: String,
    },
    DecodeOrVerifyTx {
        tx_bytes: String,
        sig: Option<GenericSignature>,
        cur_epoch: u64,
    },
    DecodeMultiSig {
        multisig: MultiSig,
        tx_bytes: Option<String>,
        cur_epoch: u64,
    },
    Generate {
        key_scheme: SignatureScheme,
        derivation_path: Option<DerivationPath>,
        word_length: Option<String>,
    },
    Import {
        alias: Option<String>,
        input_string: String,
        key_scheme: SignatureScheme,
        derivation_path: Option<DerivationPath>,
    },
    Export {
        key_identity: KeyIdentity,
    },
    List {
        sort_by_alias: bool,
    },
    LoadKeypair {
        file: PathBuf,
    },
    MultiSigAddress {
        threshold: ThresholdUnit,
        pks: Vec<PublicKey>,
        weights: Vec<WeightUnit>,
    },
    MultiSigCombinePartialSig {
        sigs: Vec<GenericSignature>,
        pks: Vec<PublicKey>,
        weights: Vec<WeightUnit>,
        threshold: ThresholdUnit,
    },
    MultiSigCombinePartialSigLegacy {
        sigs: Vec<GenericSignature>,
        pks: Vec<PublicKey>,
        weights: Vec<WeightUnit>,
        threshold: ThresholdUnit,
    },
    Show {
        file: PathBuf,
    },
    Sign {
        address: KeyIdentity,
        data: String,
        intent: Option<Intent>,
    },
    SignKMS {
        data: String,
        keyid: String,
        intent: Option<Intent>,
        base64pk: String,
    },
    Unpack {
        keypair: String,
    },
    ZkLoginSignAndExecuteTx {
        max_epoch: EpochId,
        network: String,
        fixed: bool,
        test_multisig: bool,
        sign_with_sk: bool,
    },
    ZkLoginEnterToken {
        parsed_token: String,
        max_epoch: EpochId,
        jwt_randomness: String,
        kp_bigint: String,
        ephemeral_key_identifier: SuiAddress,
        network: String,
        test_multisig: bool,
        sign_with_sk: bool,
    },
    ZkLoginSigVerify {
        sig: String,
        bytes: Option<String>,
        intent_scope: u8,
        cur_epoch: Option<EpochId>,
        network: String,
    },
    ZkLoginInsecureSignPersonalMessage {
        data: String,
        max_epoch: EpochId,
    },
}

Variants

Alias

Fields

old_alias: String

new_alias: Option<String>

The alias must start with a letter and can contain only letters, digits, dots, hyphens (-), or underscores (_).

Update an old alias to a new one. If a new alias is not provided, a random one will be generated.

Convert

Fields

value: String

Convert private key in Hex or Base64 to new format (Bech32 encoded 33 byte flag || private key starting with “suiprivkey”). Hex private key format import and export are both deprecated in Sui Wallet and Sui CLI Keystore. Use sui keytool import if you wish to import a key to Sui Keystore.

DecodeOrVerifyTx

Fields

tx_bytes: String

sig: Option<GenericSignature>

cur_epoch: u64

Given a Base64 encoded transaction bytes, decode its components. If a signature is provided, verify the signature against the transaction and output the result.

DecodeMultiSig

Fields

multisig: MultiSig

tx_bytes: Option<String>

cur_epoch: u64

Given a Base64 encoded MultiSig signature, decode its components. If tx_bytes is passed in, verify the multisig.

Generate

Fields

key_scheme: SignatureScheme

derivation_path: Option<DerivationPath>

word_length: Option<String>

Generate a new keypair with key scheme flag {ed25519 | secp256k1 | secp256r1} with optional derivation path, default to m/44’/784’/0’/0’/0’ for ed25519 or m/54’/784’/0’/0/0 for secp256k1 or m/74’/784’/0’/0/0 for secp256r1. Word length can be { word12 | word15 | word18 | word21 | word24} default to word12 if not specified.

The keypair file is output to the current directory. The content of the file is a Base64 encoded string of 33-byte flag || privkey.

Use sui client new-address if you want to generate and save the key into sui.keystore.

Import

Fields

alias: Option<String>

Sets an alias for this address. The alias must start with a letter and can contain only letters, digits, hyphens (-), or underscores (_).

input_string: String

key_scheme: SignatureScheme

derivation_path: Option<DerivationPath>

Add a new key to Sui CLI Keystore using either the input mnemonic phrase or a Bech32 encoded 33-byte flag || privkey starting with “suiprivkey”, the key scheme flag {ed25519 | secp256k1 | secp256r1} and an optional derivation path, default to m/44’/784’/0’/0’/0’ for ed25519 or m/54’/784’/0’/0/0 for secp256k1 or m/74’/784’/0’/0/0 for secp256r1. Supports mnemonic phrase of word length 12, 15, 18, 21, 24. Set an alias for the key with the –alias flag. If no alias is provided, the tool will automatically generate one.

Export

Fields

key_identity: KeyIdentity

Output the private key of the given key identity in Sui CLI Keystore as Bech32 encoded string starting with suiprivkey.

List

Fields

sort_by_alias: bool

Sort by alias

List all keys by its Sui address, Base64 encoded public key, key scheme name in sui.keystore.

LoadKeypair

Fields

file: PathBuf

This reads the content at the provided file path. The accepted format can be [enum SuiKeyPair] (Base64 encoded of 33-byte flag || privkey) or type AuthorityKeyPair (Base64 encoded privkey). This prints out the account keypair as Base64 encoded flag || privkey, the network keypair, worker keypair, protocol keypair as Base64 encoded privkey.

MultiSigAddress

Fields

threshold: ThresholdUnit

pks: Vec<PublicKey>

weights: Vec<WeightUnit>

To MultiSig Sui Address. Pass in a list of all public keys flag || pk in Base64. See keytool list for example public keys.

MultiSigCombinePartialSig

Fields

sigs: Vec<GenericSignature>

pks: Vec<PublicKey>

weights: Vec<WeightUnit>

threshold: ThresholdUnit

Provides a list of participating signatures (flag || sig || pk encoded in Base64), threshold, a list of all public keys and a list of their weights that define the MultiSig address. Returns a valid MultiSig signature and its sender address. The result can be used as signature field for sui client execute-signed-tx. The sum of weights of all signatures must be >= the threshold.

The order of sigs must be the same as the order of pks. e.g. for [pk1, pk2, pk3, pk4, pk5], [sig1, sig2, sig5] is valid, but [sig2, sig1, sig5] is invalid.

MultiSigCombinePartialSigLegacy

Fields

sigs: Vec<GenericSignature>

pks: Vec<PublicKey>

weights: Vec<WeightUnit>

threshold: ThresholdUnit

Show

Fields

file: PathBuf

Read the content at the provided file path. The accepted format can be [enum SuiKeyPair] (Base64 encoded of 33-byte flag || privkey) or type AuthorityKeyPair (Base64 encoded privkey). It prints its Base64 encoded public key and the key scheme flag.

Sign

Fields

address: KeyIdentity

data: String

intent: Option<Intent>

Create signature using the private key for for the given address (or its alias) in sui keystore. Any signature commits to a [struct IntentMessage] consisting of the Base64 encoded of the BCS serialized transaction bytes itself and its intent. If intent is absent, default will be used.

SignKMS

Fields

data: String

keyid: String

intent: Option<Intent>

base64pk: String

Creates a signature by leveraging AWS KMS. Pass in a key-id to leverage Amazon KMS to sign a message and the base64 pubkey. Generate PubKey from pem using MystenLabs/base64pemkey Any signature commits to a [struct IntentMessage] consisting of the Base64 encoded of the BCS serialized transaction bytes itself and its intent. If intent is absent, default will be used.

Unpack

Fields

keypair: String

This takes [enum SuiKeyPair] of Base64 encoded of 33-byte flag || privkey). It outputs the keypair into a file at the current directory where the address is the filename, and prints out its Sui address, Base64 encoded public key, the key scheme, and the key scheme flag.

ZkLoginSignAndExecuteTx

Fields

max_epoch: EpochId

network: String

fixed: bool

test_multisig: bool

sign_with_sk: bool

Given the max_epoch, generate an OAuth url, ask user to paste the redirect with id_token, call salt server, then call the prover server, create a test transaction, use the ephemeral key to sign and execute it by assembling to a serialized zkLogin signature.

ZkLoginEnterToken

Fields

parsed_token: String

max_epoch: EpochId

jwt_randomness: String

kp_bigint: String

ephemeral_key_identifier: SuiAddress

network: String

test_multisig: bool

sign_with_sk: bool

A workaround to the above command because sometimes token pasting does not work (for Facebook). All the inputs required here are printed from the command above.

ZkLoginSigVerify

Fields

sig: String

The Base64 of the serialized zkLogin signature.

bytes: Option<String>

The Base64 of the BCS encoded TransactionData or PersonalMessage.

intent_scope: u8

Either 0 for TransactionData or 3 for PersonalMessage.

cur_epoch: Option<EpochId>

The current epoch for the network to verify the signature’s max_epoch against.

network: String

The network to verify the signature for, determines ZkLoginEnv.

Given a zkLogin signature, parse it if valid. If bytes provided, parse it as either as TransactionData or PersonalMessage based on intent_scope. It verifies the zkLogin signature based its latest JWK fetched. Example request: sui keytool zk-login-sig-verify –sig $SERIALIZED_ZKLOGIN_SIG –bytes $BYTES –intent-scope 0 –network devnet –curr-epoch 10

ZkLoginInsecureSignPersonalMessage

Fields

data: String

The base64 encoded string of the message to sign, without the intent message wrapping.

max_epoch: EpochId

The max epoch used for the zklogin signature validity.

TESTING ONLY: Generate a fixed ephemeral key and its JWT token with test issuer. Produce a zklogin signature for the given data and max epoch. e.g. sui keytool zk-login-insecure-sign-personal-message –data “hello” –max-epoch 5

Implementations

impl KeyToolCommand

pub async fn execute( self, keystore: &mut Keystore ) -> Result<CommandOutput, Error>

Trait Implementations

impl FromArgMatches for KeyToolCommand

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for KeyToolCommand

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self.

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can update self.

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand