@provablehq/sdk 0.6.9

package/dist/account.d.ts

@@ -0,0 +1,137 @@
+import { Address, PrivateKey, Signature, ViewKey, PrivateKeyCiphertext, RecordCiphertext } from "./index";
+interface AccountParam {
+    privateKey?: string;
+    seed?: Uint8Array;
+}
+/**
+ * Key Management class. Enables the creation of a new Aleo Account, importation of an existing account from
+ * an existing private key or seed, and message signing and verification functionality.
+ *
+ * An Aleo Account is generated from a randomly generated seed (number) from which an account private key, view key,
+ * and a public account address are derived. The private key lies at the root of an Aleo account. It is a highly
+ * sensitive secret and should be protected as it allows for creation of Aleo Program executions and arbitrary value
+ * transfers. The View Key allows for decryption of a user's activity on the blockchain. The Address is the public
+ * address to which other users of Aleo can send Aleo credits and other records to. This class should only be used
+ * environments where the safety of the underlying key material can be assured.
+ *
+ * @example
+ * // Create a new account
+ * const myRandomAccount = new Account();
+ *
+ * // Create an account from a randomly generated seed
+ * const seed = new Uint8Array([94, 91, 52, 251, 240, 230, 226, 35, 117, 253, 224, 210, 175, 13, 205, 120, 155, 214, 7, 169, 66, 62, 206, 50, 188, 40, 29, 122, 40, 250, 54, 18]);
+ * const mySeededAccount = new Account({seed: seed});
+ *
+ * // Create an account from an existing private key
+ * const myExistingAccount = new Account({privateKey: 'myExistingPrivateKey'})
+ *
+ * // Sign a message
+ * const hello_world = Uint8Array.from([104, 101, 108, 108, 111 119, 111, 114, 108, 100])
+ * const signature = myRandomAccount.sign(hello_world)
+ *
+ * // Verify a signature
+ * myRandomAccount.verify(hello_world, signature)
+ */
+export declare class Account {
+    _privateKey: PrivateKey;
+    _viewKey: ViewKey;
+    _address: Address;
+    constructor(params?: AccountParam);
+    /**
+     * Attempts to create an account from a private key ciphertext
+     * @param {PrivateKeyCiphertext | string} ciphertext
+     * @param {string} password
+     * @returns {PrivateKey | Error}
+     *
+     * @example
+     * const ciphertext = PrivateKey.newEncrypted("password");
+     * const account = Account.fromCiphertext(ciphertext, "password");
+     */
+    static fromCiphertext(ciphertext: PrivateKeyCiphertext | string, password: string): Account;
+    private privateKeyFromParams;
+    privateKey(): PrivateKey;
+    viewKey(): ViewKey;
+    address(): Address;
+    toString(): string;
+    /**
+     * Encrypt the account's private key with a password
+     * @param {string} ciphertext
+     * @returns {PrivateKeyCiphertext}
+     *
+     * @example
+     * const account = new Account();
+     * const ciphertext = account.encryptAccount("password");
+     */
+    encryptAccount(password: string): PrivateKeyCiphertext;
+    /**
+     * Decrypts a Record in ciphertext form into plaintext
+     * @param {string} ciphertext
+     * @returns {Record}
+     *
+     * @example
+     * const account = new Account();
+     * const record = account.decryptRecord("record1ciphertext");
+     */
+    decryptRecord(ciphertext: string): string;
+    /**
+     * Decrypts an array of Records in ciphertext form into plaintext
+     * @param {string[]} ciphertexts
+     * @returns {Record[]}
+     *
+     * @example
+     * const account = new Account();
+     * const record = account.decryptRecords(["record1ciphertext", "record2ciphertext"]);
+     */
+    decryptRecords(ciphertexts: string[]): string[];
+    /**
+     * Determines whether the account owns a ciphertext record
+     * @param {RecordCipherText | string} ciphertext
+     * @returns {boolean}
+     *
+     * @example
+     * // Create a connection to the Aleo network and an account
+     * const connection = new NodeConnection("vm.aleo.org/api");
+     * const account = Account.fromCiphertext("ciphertext", "password");
+     *
+     * // Get a record from the network
+     * const record = connection.getBlock(1234);
+     * const recordCipherText = record.transactions[0].execution.transitions[0].id;
+     *
+     * // Check if the account owns the record
+     * if account.ownsRecord(recordCipherText) {
+     *     // Then one can do something like:
+     *     // Decrypt the record and check if it's spent
+     *     // Store the record in a local database
+     *     // Etc.
+     * }
+     */
+    ownsRecordCiphertext(ciphertext: RecordCiphertext | string): boolean;
+    /**
+     * Signs a message with the account's private key.
+     * Returns a Signature.
+     *
+     * @param {Uint8Array} message
+     * @returns {Signature}
+     *
+     * @example
+     * const account = new Account();
+     * const message = Uint8Array.from([104, 101, 108, 108, 111 119, 111, 114, 108, 100])
+     * account.sign(message);
+     */
+    sign(message: Uint8Array): Signature;
+    /**
+     * Verifies the Signature on a message.
+     *
+     * @param {Uint8Array} message
+     * @param {Signature} signature
+     * @returns {boolean}
+     *
+     * @example
+     * const account = new Account();
+     * const message = Uint8Array.from([104, 101, 108, 108, 111 119, 111, 114, 108, 100])
+     * const signature = account.sign(message);
+     * account.verify(message, signature);
+     */
+    verify(message: Uint8Array, signature: Signature): boolean;
+}
+export {};

package/dist/function-key-provider.d.ts

@@ -0,0 +1,336 @@
+import { ProvingKey, VerifyingKey } from "./index";
+type FunctionKeyPair = [ProvingKey, VerifyingKey];
+type CachedKeyPair = [Uint8Array, Uint8Array];
+type AleoKeyProviderInitParams = {
+    proverUri?: string;
+    verifierUri?: string;
+    cacheKey?: string;
+};
+/**
+ * Interface for record search parameters. This allows for arbitrary search parameters to be passed to record provider
+ * implementations.
+ */
+interface KeySearchParams {
+    [key: string]: any;
+}
+/**
+ * AleoKeyProviderParams search parameter for the AleoKeyProvider. It allows for the specification of a proverUri and
+ * verifierUri to fetch keys via HTTP from a remote resource as well as a unique cacheKey to store the keys in memory.
+ */
+declare class AleoKeyProviderParams implements KeySearchParams {
+    proverUri: string | undefined;
+    verifierUri: string | undefined;
+    cacheKey: string | undefined;
+    /**
+     * Create a new AleoKeyProviderParams object which implements the KeySearchParams interface. Users can optionally
+     * specify a url for the proverUri & verifierUri to fetch keys via HTTP from a remote resource as well as a unique
+     * cacheKey to store the keys in memory for future use. If no proverUri or verifierUri is specified, a cachekey must
+     * be provided.
+     *
+     * @param { AleoKeyProviderInitParams } params - Optional search parameters
+     */
+    constructor(params: {
+        proverUri?: string;
+        verifierUri?: string;
+        cacheKey?: string;
+    });
+}
+/**
+ * KeyProvider interface. Enables the retrieval of public proving and verifying keys for Aleo Programs.
+ */
+interface FunctionKeyProvider {
+    /**
+     * Get bond_public function keys from the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the bond_public function
+     */
+    bondPublicKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Get bond_validator function keys from the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the bond_validator function
+     */
+    bondValidatorKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Cache a set of keys. This will overwrite any existing keys with the same keyId. The user can check if a keyId
+     * exists in the cache using the containsKeys method prior to calling this method if overwriting is not desired.
+     *
+     * @param {string} keyId access key for the cache
+     * @param {FunctionKeyPair} keys keys to cache
+     */
+    cacheKeys(keyId: string, keys: FunctionKeyPair): void;
+    /**
+     * Get unbond_public function keys from the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the unbond_public function
+     */
+    claimUnbondPublicKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Get arbitrary function keys from a provider
+     *
+     * @param {KeySearchParams | undefined} params - Optional search parameters for the key provider
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the specified program
+     *
+     * @example
+     * // Create a search object which implements the KeySearchParams interface
+     * class IndexDbSearch implements KeySearchParams {
+     *     db: string
+     *     keyId: string
+     *     constructor(params: {db: string, keyId: string}) {
+     *         this.db = params.db;
+     *         this.keyId = params.keyId;
+     *     }
+     * }
+     *
+     * // Create a new object which implements the KeyProvider interface
+     * class IndexDbKeyProvider implements FunctionKeyProvider {
+     *     async functionKeys(params: KeySearchParams): Promise<FunctionKeyPair | Error> {
+     *         return new Promise((resolve, reject) => {
+     *             const request = indexedDB.open(params.db, 1);
+     *
+     *             request.onupgradeneeded = function(e) {
+     *                 const db = e.target.result;
+     *                 if (!db.objectStoreNames.contains('keys')) {
+     *                     db.createObjectStore('keys', { keyPath: 'id' });
+     *                 }
+     *             };
+     *
+     *             request.onsuccess = function(e) {
+     *                 const db = e.target.result;
+     *                 const transaction = db.transaction(["keys"], "readonly");
+     *                 const store = transaction.objectStore("keys");
+     *                 const request = store.get(params.keyId);
+     *                 request.onsuccess = function(e) {
+     *                     if (request.result) {
+     *                         resolve(request.result as FunctionKeyPair);
+     *                     } else {
+     *                         reject(new Error("Key not found"));
+     *                     }
+     *                 };
+     *                 request.onerror = function(e) { reject(new Error("Error fetching key")); };
+     *             };
+     *
+     *             request.onerror = function(e) { reject(new Error("Error opening database")); };
+     *         });
+     *     }
+     *
+     *     // implement the other methods...
+     * }
+     *
+     *
+     * const keyProvider = new AleoKeyProvider();
+     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const recordProvider = new NetworkRecordProvider(account, networkClient);
+     *
+     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
+     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     *
+     * // Keys can also be fetched manually
+     * const searchParams = new IndexDbSearch({db: "keys", keyId: "credits.aleo:transferPrivate"});
+     * const [transferPrivateProvingKey, transferPrivateVerifyingKey] = await keyProvider.functionKeys(searchParams);
+     */
+    functionKeys(params?: KeySearchParams): Promise<FunctionKeyPair | Error>;
+    /**
+     * Get fee_private function keys from the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
+     */
+    feePrivateKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Get fee_public function keys from the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
+     */
+    feePublicKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Get join function keys from the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
+     */
+    joinKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Get split function keys from the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
+     */
+    splitKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Get keys for a variant of the transfer function from the credits.aleo program
+     *
+     * @param {string} visibility Visibility of the transfer function (private, public, privateToPublic, publicToPrivate)
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the specified transfer function
+     *
+     * @example
+     * // Create a new object which implements the KeyProvider interface
+     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const keyProvider = new AleoKeyProvider();
+     * const recordProvider = new NetworkRecordProvider(account, networkClient);
+     *
+     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
+     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     *
+     * // Keys can also be fetched manually
+     * const [transferPublicProvingKey, transferPublicVerifyingKey] = await keyProvider.transferKeys("public");
+     */
+    transferKeys(visibility: string): Promise<FunctionKeyPair | Error>;
+    /**
+     * Get unbond_public function keys from the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
+     */
+    unBondPublicKeys(): Promise<FunctionKeyPair | Error>;
+}
+/**
+ * AleoKeyProvider class. Implements the KeyProvider interface. Enables the retrieval of Aleo program proving and
+ * verifying keys for the credits.aleo program over http from official Aleo sources and storing and retrieving function
+ * keys from a local memory cache.
+ */
+declare class AleoKeyProvider implements FunctionKeyProvider {
+    cache: Map<string, CachedKeyPair>;
+    cacheOption: boolean;
+    keyUris: string;
+    fetchBytes(url?: string): Promise<Uint8Array>;
+    constructor();
+    /**
+     * Use local memory to store keys
+     *
+     * @param {boolean} useCache whether to store keys in local memory
+     */
+    useCache(useCache: boolean): void;
+    /**
+     * Clear the key cache
+     */
+    clearCache(): void;
+    /**
+     * Cache a set of keys. This will overwrite any existing keys with the same keyId. The user can check if a keyId
+     * exists in the cache using the containsKeys method prior to calling this method if overwriting is not desired.
+     *
+     * @param {string} keyId access key for the cache
+     * @param {FunctionKeyPair} keys keys to cache
+     */
+    cacheKeys(keyId: string, keys: FunctionKeyPair): void;
+    /**
+     * Determine if a keyId exists in the cache
+     *
+     * @param {string} keyId keyId of a proving and verifying key pair
+     * @returns {boolean} true if the keyId exists in the cache, false otherwise
+     */
+    containsKeys(keyId: string): boolean;
+    /**
+     * Delete a set of keys from the cache
+     *
+     * @param {string} keyId keyId of a proving and verifying key pair to delete from memory
+     * @returns {boolean} true if the keyId exists in the cache and was deleted, false if the key did not exist
+     */
+    deleteKeys(keyId: string): boolean;
+    /**
+     * Get a set of keys from the cache
+     * @param keyId keyId of a proving and verifying key pair
+     *
+     * @returns {FunctionKeyPair | Error} Proving and verifying keys for the specified program
+     */
+    getKeys(keyId: string): FunctionKeyPair | Error;
+    /**
+     * Get arbitrary function keys from a provider
+     *
+     * @param {KeySearchParams} params parameters for the key search in form of: {proverUri: string, verifierUri: string, cacheKey: string}
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the specified program
+     *
+     * @example
+     * // Create a new object which implements the KeyProvider interface
+     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const keyProvider = new AleoKeyProvider();
+     * const recordProvider = new NetworkRecordProvider(account, networkClient);
+     *
+     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
+     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     *
+     * // Keys can also be fetched manually using the key provider
+     * const keySearchParams = { "cacheKey": "myProgram:myFunction" };
+     * const [transferPrivateProvingKey, transferPrivateVerifyingKey] = await keyProvider.functionKeys(keySearchParams);
+     */
+    functionKeys(params?: KeySearchParams): Promise<FunctionKeyPair | Error>;
+    /**
+     * Returns the proving and verifying keys for a specified program from a specified url.
+     *
+     * @param {string} verifierUrl Url of the proving key
+     * @param {string} proverUrl Url the verifying key
+     * @param {string} cacheKey Key to store the keys in the cache
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the specified program
+     *
+     * @example
+     * // Create a new AleoKeyProvider object
+     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const keyProvider = new AleoKeyProvider();
+     * const recordProvider = new NetworkRecordProvider(account, networkClient);
+     *
+     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
+     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     *
+     * // Keys can also be fetched manually
+     * const [transferPrivateProvingKey, transferPrivateVerifyingKey] = await keyProvider.fetchKeys(
+     *     CREDITS_PROGRAM_KEYS.transfer_private.prover,
+     *     CREDITS_PROGRAM_KEYS.transfer_private.verifier,
+     * );
+     */
+    fetchKeys(proverUrl: string, verifierUrl: string, cacheKey?: string): Promise<FunctionKeyPair | Error>;
+    bondPublicKeys(): Promise<FunctionKeyPair | Error>;
+    bondValidatorKeys(): Promise<FunctionKeyPair | Error>;
+    claimUnbondPublicKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Returns the proving and verifying keys for the transfer functions in the credits.aleo program
+     * @param {string} visibility Visibility of the transfer function
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the transfer functions
+     *
+     * @example
+     * // Create a new AleoKeyProvider
+     * const networkClient = new AleoNetworkClient("https://api.explorer.aleo.org/v1");
+     * const keyProvider = new AleoKeyProvider();
+     * const recordProvider = new NetworkRecordProvider(account, networkClient);
+     *
+     * // Initialize a program manager with the key provider to automatically fetch keys for value transfers
+     * const programManager = new ProgramManager("https://api.explorer.aleo.org/v1", keyProvider, recordProvider);
+     * programManager.transfer(1, "aleo166q6ww6688cug7qxwe7nhctjpymydwzy2h7rscfmatqmfwnjvggqcad0at", "public", 0.5);
+     *
+     * // Keys can also be fetched manually
+     * const [transferPublicProvingKey, transferPublicVerifyingKey] = await keyProvider.transferKeys("public");
+     */
+    transferKeys(visibility: string): Promise<FunctionKeyPair | Error>;
+    /**
+     * Returns the proving and verifying keys for the join function in the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the join function
+     */
+    joinKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Returns the proving and verifying keys for the split function in the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the split function
+     * */
+    splitKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Returns the proving and verifying keys for the fee_private function in the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the fee function
+     */
+    feePrivateKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Returns the proving and verifying keys for the fee_public function in the credits.aleo program
+     *
+     * @returns {Promise<FunctionKeyPair | Error>} Proving and verifying keys for the fee function
+     */
+    feePublicKeys(): Promise<FunctionKeyPair | Error>;
+    /**
+     * Gets a verifying key. If the verifying key is for a credits.aleo function, get it from the wasm cache otherwise
+     *
+     * @returns {Promise<VerifyingKey | Error>} Verifying key for the function
+     */
+    getVerifyingKey(verifierUri: string): Promise<VerifyingKey | Error>;
+    unBondPublicKeys(): Promise<FunctionKeyPair | Error>;
+}
+export { AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, CachedKeyPair, FunctionKeyPair, FunctionKeyProvider, KeySearchParams };

package/dist/index.d.ts

@@ -0,0 +1,50 @@
+import { VerifyingKey } from "@provablehq/wasm";
+declare const KEY_STORE: string;
+interface Key {
+    locator: string;
+    prover: string;
+    verifier: string;
+    verifyingKey: () => VerifyingKey;
+}
+declare const CREDITS_PROGRAM_KEYS: {
+    bond_public: Key;
+    bond_validator: Key;
+    claim_unbond_public: Key;
+    fee_private: Key;
+    fee_public: Key;
+    inclusion: Key;
+    join: Key;
+    set_validator_state: Key;
+    split: Key;
+    transfer_private: Key;
+    transfer_private_to_public: Key;
+    transfer_public: Key;
+    transfer_public_as_signer: Key;
+    transfer_public_to_private: Key;
+    unbond_public: Key;
+};
+declare const PRIVATE_TRANSFER_TYPES: Set<string>;
+declare const VALID_TRANSFER_TYPES: Set<string>;
+declare const PRIVATE_TRANSFER: Set<string>;
+declare const PRIVATE_TO_PUBLIC_TRANSFER: Set<string>;
+declare const PUBLIC_TRANSFER: Set<string>;
+declare const PUBLIC_TRANSFER_AS_SIGNER: Set<string>;
+declare const PUBLIC_TO_PRIVATE_TRANSFER: Set<string>;
+declare function logAndThrow(message: string): Error;
+import { Account } from "./account";
+import { AleoNetworkClient, ProgramImports } from "./network-client";
+import { Block } from "./models/block";
+import { Execution } from "./models/execution";
+import { Input } from "./models/input";
+import { Output } from "./models/output";
+import { TransactionModel } from "./models/transactionModel";
+import { Transition } from "./models/transition";
+import { AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, CachedKeyPair, FunctionKeyPair, FunctionKeyProvider, KeySearchParams } from "./function-key-provider";
+import { OfflineKeyProvider, OfflineSearchParams } from "./offline-key-provider";
+import { BlockHeightSearch, NetworkRecordProvider, RecordProvider, RecordSearchParams } from "./record-provider";
+declare function initializeWasm(): Promise<void>;
+export { createAleoWorker } from "./managed-worker";
+export { ProgramManager } from "./program-manager";
+export { Address, Execution as FunctionExecution, ExecutionResponse, Field, OfflineQuery, PrivateKey, PrivateKeyCiphertext, Program, ProgramManager as ProgramManagerBase, ProvingKey, RecordCiphertext, RecordPlaintext, Signature, Transaction, VerifyingKey, ViewKey, initThreadPool, verifyFunctionExecution, } from "@provablehq/wasm";
+export { initializeWasm };
+export { Account, AleoKeyProvider, AleoKeyProviderParams, AleoKeyProviderInitParams, AleoNetworkClient, Block, BlockHeightSearch, CachedKeyPair, Execution, FunctionKeyPair, FunctionKeyProvider, Input, KeySearchParams, NetworkRecordProvider, ProgramImports, OfflineKeyProvider, OfflineSearchParams, Output, RecordProvider, RecordSearchParams, TransactionModel, Transition, CREDITS_PROGRAM_KEYS, KEY_STORE, PRIVATE_TRANSFER, PRIVATE_TO_PUBLIC_TRANSFER, PRIVATE_TRANSFER_TYPES, PUBLIC_TRANSFER, PUBLIC_TRANSFER_AS_SIGNER, PUBLIC_TO_PRIVATE_TRANSFER, VALID_TRANSFER_TYPES, logAndThrow, };