@elysium-onchain-id/identity-sdk

import { BigNumber, Signer, Contract } from 'ethers'; import { Provider, TransactionResponse } from '@ethersproject/providers'; import { EventFragment, FunctionFragment, Interface } from 'ethers/lib/utils'; import { ClaimData, ClaimScheme, ClaimTopic } from '../claim/Claim.interface'; import { Key, KeyPurpose, KeyType } from './Key.interface'; import { IdentityInterface } from './identity.interface'; import { BlockchainOptions } from '../core/utils/blockchain-options'; export declare class KeyPurposeAlreadyRegisteredError extends Error { constructor({ message }?: { message?: string; }); } export declare class KeyPurposeNotRegisteredError extends Error { constructor({ message }?: { message?: string; }); } export declare class InvalidKeyError extends Error { constructor({ message }?: { message?: string; }); } export declare class InvalidClaimError extends Error { constructor({ message }?: { message?: string; }); } export declare class NonExistingClaimError extends Error { constructor({ message }?: { message?: string; }); } export declare class Identity implements IdentityInterface { keyHolderInstance?: Contract; claimHolderInstance?: Contract; address?: string; provider?: Provider | Signer; private deploymentContract?; /** * Instantiate a new Identity with the provided address or ENS string that will be resolved. * @param addressOrENS Must be a valid Ethereum address, checksumed, all lower-case or all uppercase. * @param options * @params options.provider If provided, the identity will use this provider for all blockchain operation (unless override) instead of the SDK default provider. */ static at(addressOrENS: string, options?: BlockchainOptions): Promise<Identity>; /** * Compute the address an ONCHAINID deployed using a Factory/Gateway would have. * @param factory The address of the factory contract (this is not the address of the Gateway contract) * @param unprefixedSalt The salt specified when requesting the deployment, usually the address of the identity owner. * @param implementationAuthority The address of the implementation authority contract used by the Factory. */ static computeDeploymentAddress({ factory, unprefixedSalt, implementationAuthority }: { factory: string; unprefixedSalt: string; implementationAuthority: string; }): string; /** * Deploy a new Identity, and return the Identity object. * The signer will pay for the deployment, and will be added in the MANAGEMENT keys. * If not given, the Signer will use the default provider from the SDK if it is defined and is a Signer. * Note that the identity will be returned with the provided Signer, thus management operation can be chained. * @param config - Configuration of the identity to deploy. * @param config.managementKey - Ethereum address to set as the initial management key. * @param config.implementationAuthority - Ethereum address of the implementation authority to use. * @param options * @example Usually called with `identity.deployed()`: * ```typescript * const identity = await Identity.deployNew(); * await identity.deployed(); * ``` */ static deployNew(config: { managementKey: string; implementationAuthority: string; }, options: BlockchainOptions): Promise<Identity>; /** * Deploy a new Identity for a given wallet and a specific salt, and return the Identity object, using an ONCHAINID * Gateway. To deploy an identity using this method, the gatewa requires a signature from an approved signer that * contains the salt and the address of the identity owner (see specifications). * The signer will pay for the deployment. * If not given, the Signer will use the default provider from the SDK if it is defined and is a Signer. * Note that the identity will be returned with the provided Signer, thus management operation can be chained. * @param config - Configuration of the identity to deploy. * @param config.gateway - address of the gateway to use * @param config.identityOwner - address of the identity owner * @param config.salt - address of the factory to deploy a proxy identity. * @param config.signature - signature of salt + identityOwner + expiry (see specifications) * @param config.signatureExpiry - the block timestamp where the signature will expire (in seconds and as a BigNumber) * @param options * @param options.signer - the signer to use to sign and send the transaction * @example Usually called with `identity.deployed()`: * ```typescript * const identity = await Identity.deployUsingGatewayWithSalt({ * gateway: '0x...', * identityOwner: '0x..', * salt: 'some-salt', * signature: '0x...', * signatureExpiry: BigNumber.from('1689583125'), * }); * await identity.deployed(); * ``` */ static deployUsingGatewayWithSalt(config: { gateway: string; identityOwner: string; salt: string; signature: string; signatureExpiry: BigNumber; }, options: BlockchainOptions): Promise<TransactionResponse>; /** * Deploy a new Identity for a given wallet and a specific salt, and return the Identity object, using an ONCHAINID * Gateway. To deploy an identity using this method, the gateway requires a signature from an approved signer that * contains the salt and the address of the identity owner and the list of management keys (see specifications). * The signer will pay for the deployment. * If not given, the Signer will use the default provider from the SDK if it is defined and is a Signer. * Note that the identity will be returned with the provided Signer, thus management operation can be chained. * @param config - Configuration of the identity to deploy. * @param config.gateway - address of the gateway to use * @param config.identityOwner - address of the identity owner * @param config.salt - address of the factory to deploy a proxy identity. * @param config.managementKeys - list of management keys to add to the identity * @param config.signature - signature of salt + identityOwner + expiry (see specifications) * @param config.signatureExpiry - the block timestamp where the signature will expire (in seconds and as a BigNumber) * @param options * @param options.signer - the signer to use to sign and send the transaction * @example Usually called with `identity.deployed()`: * ```typescript * const identity = await Identity.deployUsingGatewayWithSalt({ * gateway: '0x...', * identityOwner: '0x..', * salt: 'some-salt', * managementKeys: [IdentitySDK.utils.encodeAndHash(['address'], ['0x...'])], * signature: '0x...', * signatureExpiry: BigNumber.from('1689583125'), * }); * await identity.deployed(); * ``` */ static deployUsingGatewayWithSaltAndManagementKeys(config: { gateway: string; identityOwner: string; salt: string; managementKeys: string[]; signature: string; signatureExpiry: BigNumber; }, options: BlockchainOptions): Promise<TransactionResponse>; /** * Deploy a new Identity, and return the Identity object, using an ONCHAINID Gateway. This method only deploys * an identity for the wallet that signed the transaction. * The signer will pay for the deployment. * If not given, the Signer will use the default provider from the SDK if it is defined and is a Signer. * Note that the identity will be returned with the provided Signer, thus management operation can be chained. * @param config - Configuration of the identity to deploy. * @param config.gateway - address of the gateway to use * @param config.identityOwner - address of the identity owner, must be the address of the signer * @param options * @param options.signer - the signer to use to sign and send the transaction * @example Usually called with `identity.deployed()`: * ```typescript * const identity = await Identity.deployUsingGatewayWithSalt({ * gateway: '0x...', * identityOwner: '0x..', * }); * await identity.deployed(); * ``` */ static deployUsingGatewayForWallet(config: { gateway: string; identityOwner: string; }, options: BlockchainOptions): Promise<TransactionResponse>; /** * Instantiate an Identity. * @param address A valid Ethereum address (not an ENS, use `Identity#at(ens)`.). * @param provider Override the default provider of SDK, and use for all operation of this Identity. */ constructor(address: string, provider?: Provider | Signer); /** * Add a claim to an Identity. * The signature must have been signed with a keypair having the public key in the CLAIM keys of Identity. * @param topic * @param scheme * @param issuer * @param signature * @param data * @param uri * @param [options] */ addClaim(topic: ClaimTopic, scheme: ClaimScheme, issuer: string, signature: string, data: string, uri: string, options?: BlockchainOptions): Promise<TransactionResponse>; /** * Add a Key to an Identity. * The Signer must have a MANAGEMENT key in the Identity. * @param key Must be a valid byte32 hex string (pass the keccak256 hash of the key string encoded (abi.encode)). * @param purpose Must be an integer. It is recommended to use the standard KeyPurpose enum. * @param type Must be a an integer. It is recommended to use the standard KeyType enum. * @param [options] */ addKey(key: string, purpose: KeyPurpose, type: KeyType, options?: BlockchainOptions): Promise<TransactionResponse>; /** * Returns the Identity if the Identity was deployed, or awaits for the Identity to be deployed before returning it. * * @example Usually called after a `Identity.deployNew()`: * ```typescript * const identity = await Identity.deployNew(); * await identity.deployed(); * ``` */ deployed(): Promise<Identity>; /** * Get ClaimData details for an Identity. * @param claimId * @param [options] */ getClaim(claimId: string, options?: BlockchainOptions): Promise<ClaimData>; /** * Get claims details for an Identity. * @deprecated * @param claimId * @param [options] */ getClaims(claimId: string, options?: BlockchainOptions): Promise<ClaimData[]>; /** * Get Claims details by topic for an Identity. * @param topic * @param [options] */ getClaimsByTopic(topic: ClaimTopic | number, options?: BlockchainOptions): Promise<ClaimData[]>; /** * Get ClaimData IDs by topic for an Identity. * @param topic * @param [options] */ getClaimIdsByTopic(topic: ClaimTopic | number, options?: BlockchainOptions): Promise<string[]>; /** * Returns the deployment transaction of the Identity if it was previously created with Identity.deployNew(). * * @example Can be called only after a `Identity.deployNew()`: * ```typescript * const identity = await Identity.deployNew(); * identity.getDeployTransaction(); * ``` */ getDeployTransaction(): TransactionResponse | null; /** * Get the details of a key in an Identity. * @param key * @param [options] */ getKey(key: string, options?: BlockchainOptions): Promise<Key>; /** * Get the purpose of a key in an identity. * @param key * @param [options] */ getKeyPurposes(key: string, options?: BlockchainOptions): Promise<KeyPurpose[]>; /** * Get the details of the keys contained in an Identity by purpose. * @param purpose * @param [options] */ getKeysByPurpose(purpose: KeyPurpose, options?: BlockchainOptions): Promise<Key[]>; /** * Instantiate the Identity IdentityInterface Contract with the Identity's address. * @param [providerOrSigner] */ instantiateClaimHolder(providerOrSigner?: Provider | Signer): Promise<Contract>; /** * Instantiate the Identity KeyHolder Contract with the Identity's address. * @param [providerOrSigner] */ instantiateKeyHolder(providerOrSigner?: Provider | Signer): Promise<Contract>; /** * Instantiate an Identity with the given abi using the object's address. * @param abi * @param [providerOrSigner] */ instantiate(abi: Array<string | FunctionFragment | EventFragment> | string | Interface, providerOrSigner?: Provider | Signer): Promise<Contract>; /** * Instantiate an Identity with the given abi at a given address. * @param address * @param abi * @param [providerOrSigner] */ instantiateAtAddress(address: string, abi: Array<string | FunctionFragment | EventFragment> | string | Interface, providerOrSigner?: Provider | Signer): Promise<Contract>; /** * Check if a key has at least the given purpose. * @param key * @param purpose * @param [options] */ keyHasPurpose(key: string, purpose: KeyPurpose, options?: BlockchainOptions): Promise<boolean>; /** * Remove a claim, provided the signer has the right to do so. * @param claimId * @param [options] */ removeClaim(claimId: string, options?: BlockchainOptions): Promise<TransactionResponse>; /** * Remove a Key from an Identity. * The Signer must have a MANAGEMENT key in the Identity. * @param key Key must be a valid byte32 hex string. * @param purpose KeyPurpose must be a valid byte32 hex string. * @param [options] */ removeKey(key: string, purpose: number, options?: BlockchainOptions): Promise<TransactionResponse>; /** * Use another provider or signer to interact with the Identity. * This will reset all contract instances of the identity that will need to be instantiated once again with the new provider. * @param providerOrSigner */ useProvider(providerOrSigner: Provider | Signer): void; /** * Verify if the message was signed with a key that is authorized to perform action for this Identity. * @param message * @param signature * @param [options] */ validateSignature(message: string, signature: string, options?: BlockchainOptions): Promise<boolean>; /** * Verify a specific claim given with full data or by ID. * @param claim Claim object or ID. * @param [options] */ verifyClaim(claim: any | string, options?: BlockchainOptions): Promise<{ valid: boolean; reason?: string; }>; }