Get SDK-instance info
Returns:
an instance of InfoData containing SDK-related properties.
public async Task<InfoData> getInfo() {
return new InfoData {
apiKey = this.apiKey,
dAppCode = this.dAppCode,
network = this.network,
visitorId = "[not implemented yet]",
sdkEnvironment = this.sdkEnvironment,
sdkVersion = this.sdkVersion
};
}
Get balances by Hedera id (address)
Parameters:
accountId: Hedera id (address), example: 0.0.112233
Returns:
an instance of AccountBalanceData containing account hbar and token balances.
public async Task<AccountBalanceData> getBalance(string accountId) {
return await apiService.getBalance(accountId);
}
Get account evmAddress and calculated evmAddress from public key
Parameters:
accountId: Hedera id (address), example: 0.0.112233
Returns:
an instance of AccountInfoData containing account id, evmAddress, calculatedEvmAddress
public async Task<AccountInfoData> getAccountInfo(string accountId) {
var account = await apiService.GET<AccountData>($"/api/v1/accounts/{accountId}");
string response = engine
.Evaluate($"window.bladeSdk.getAccountInfo('{accountId}', '{account.evm_address}', '{account.key.key}')")
.UnwrapIfPromise()
.ToString();
return this.processResponse<AccountInfoData>(response);
}
Method to execute Hbar transfers from current account to receiver
Parameters:
accountPrivateKey: sender's private key to sign transfer transaction
memo: memo (limited to 100 characters)
Returns:
an instance of ExecuteTxReceipt containing transaction receipt
public async Task<ExecuteTxReceipt> transferHbars(string accountId, string accountPrivateKey, string recieverAccount, string amount, string memo) {
string response = engine
.Evaluate($"window.bladeSdk.transferHbars('{accountId}', '{accountPrivateKey}', '{recieverAccount}', '{amount}', '{memo}')")
.UnwrapIfPromise()
.ToString();
SignedTx signedTx = this.processResponse<SignedTx>(response);
return await apiService.executeTx(signedTx.tx, signedTx.network);
}
Method to execute token transfers from current account to receiver
Parameters:
accountPrivateKey: sender's private key to sign transfer transaction
memo: memo (limited to 100 characters)
freeTransfer: for tokens configured for this dAppCode on Blade backend
Returns:
an instance of ExecuteTxReceipt containing transaction receipt
public async Task<ExecuteTxReceipt> transferTokens(string tokenId, string accountId, string accountPrivateKey, string recieverAccount, string amount, string memo, bool freeTransfer = false) {
TokenData meta = await apiService.GET<TokenData>($"/api/v1/tokens/{tokenId}");
double correctedAmount = double.Parse(amount) * Math.Pow(10, int.Parse(meta.decimals));
if (freeTransfer == true) {
// for free transfer BladeApi need to create TX, from our initial data.
// to call BladeApi we need TVTE-token
// after we get transactionBytes need to sign it with sender private key
// after signing - need to execute this TX
// generating TVTE token
string response = engine
.Evaluate($"window.bladeSdk.getTvteValue()")
.UnwrapIfPromise()
.ToString();
TVTEResponse tvteResponse = this.processResponse<TVTEResponse>(response);
// bladeApi create and sign TX, and return base64-encoded transactionBytes
FreeTokenTransferResponse freeTokenTransferResponse = await apiService.freeTokenTransfer(accountId, recieverAccount, correctedAmount, memo, tvteResponse.tvte);
// sign with sender private key
SignedTx signedTx = this.signTransaction(freeTokenTransferResponse.transactionBytes, "base64", accountPrivateKey);
//send tx to execution
return await apiService.executeTx(signedTx.tx, signedTx.network);
} else {
string response = engine
.Evaluate($"window.bladeSdk.transferTokens('{tokenId}', '{accountId}', '{accountPrivateKey}', '{recieverAccount}', {correctedAmount}, '{memo}')")
.UnwrapIfPromise()
.ToString();
SignedTx signedTx = this.processResponse<SignedTx>(response);
return await apiService.executeTx(signedTx.tx, signedTx.network);
}
}
Method to create Hedera account
Parameters:
deviceId: unique device id (advanced security feature, required only for some dApps)
Returns:
an instance of CreateAccountData containing new account data
public async Task<CreateAccountData> createAccount(string deviceId) {
// generateKeys
string keyResponse = engine
.Evaluate($"window.bladeSdk.generateKeys()")
.UnwrapIfPromise()
.ToString();
KeyPairData keyPairData = this.processResponse<KeyPairData>(keyResponse);
string tvteToken = this.getTvteToken();
CreateAccountResponse createAccountResponse = await apiService.createAccount(keyPairData.publicKey, deviceId, tvteToken);
// sign and execute transactions if any
if (createAccountResponse.updateAccountTransactionBytes != null) {
SignedTx signedTx = this.signTransaction(createAccountResponse.updateAccountTransactionBytes, "base64", keyPairData.privateKey);
ExecuteTxReceipt executeTxReceipt = await apiService.executeTx(signedTx.tx, signedTx.network);
// confirm account key update
if (executeTxReceipt.status == "SUCCESS") {
await apiService.confirmAccountUpdate(createAccountResponse.id, tvteToken);
}
}
if (createAccountResponse.transactionBytes != null) {
SignedTx signedTx = this.signTransaction(createAccountResponse.transactionBytes, "base64", keyPairData.privateKey);
ExecuteTxReceipt executeTxReceipt = await apiService.executeTx(signedTx.tx, signedTx.network);
}
CreateAccountData createAccountData = new CreateAccountData {
transactionId = createAccountResponse.transactionId,
status = string.IsNullOrEmpty(createAccountResponse.transactionId) ? "SUCCESS" : "PENDING",
seedPhrase = "[not supported in now]",
publicKey = keyPairData.publicKey,
privateKey = keyPairData.privateKey,
accountId = createAccountResponse.id,
evmAddress = keyPairData.evmAddress
};
return createAccountData;
}
Method to delete Hedera account
Parameters:
deleteAccountId: account to delete - id
deletePrivateKey: account to delete - private key
transferAccountId: The ID of the account to transfer the remaining funds to.
operatorAccountId: operator account Id
operatorPrivateKey: operator account private key
Returns:
an instance of ExecuteTxReceipt containing transaction receipt
public async Task<ExecuteTxReceipt> deleteAccount(string deleteAccountId, string deletePrivateKey, string transferAccountId, string operatorAccountId, string operatorPrivateKey) {
string signedTxResponse = engine
.Evaluate($"window.bladeSdk.deleteAccount('{deleteAccountId}', '{deletePrivateKey}', '{transferAccountId}', '{operatorAccountId}', '{operatorPrivateKey}')")
.UnwrapIfPromise()
.ToString();
SignedTx signedTx = this.processResponse<SignedTx>(signedTxResponse);
return await apiService.executeTx(signedTx.tx, signedTx.network);
}
Method to call smart-contract function
Parameters:
functionName: contract function name
params: function arguments (instance of ContractFunctionParameters)
accountId: sender account id
accountPrivateKey: sender's private key to sign transfer transaction
gas: gas amount for transaction (default 100000)
bladePayFee: blade pay fee, otherwise fee will be pay from sender accountId
Returns:
an instance of ExecuteTxReceipt containing transaction receipt
public async Task<ExecuteTxReceipt> contractCallFunction(string contractId, string functionName, ContractFunctionParameters parameters, string accountId, string accountPrivateKey, uint gas, bool bladePayFee = false) {
if (bladePayFee) {
string contractCallBytecodeResponse = engine
.Evaluate($"window.bladeSdk.getContractCallBytecode('{functionName}', '{parameters.encode()}')")
.UnwrapIfPromise()
.ToString();
ContractCallBytecode contractCallBytecode = this.processResponse<ContractCallBytecode>(contractCallBytecodeResponse);
SignContractCallResponse signContractCallResponse = await apiService.signContractCallTx(
contractCallBytecode.contractFunctionParameters,
contractId,
functionName,
gas,
this.getTvteToken(),
false
);
SignedTx signedTx = this.signTransaction(signContractCallResponse.transactionBytes, "base64", accountPrivateKey);
return await apiService.executeTx(signedTx.tx, signedTx.network);
} else {
string signedTxResponse = engine
.Evaluate($"window.bladeSdk.contractCallFunctionTransaction('{contractId}', '{functionName}', '{parameters.encode()}', '{accountId}', '{accountPrivateKey}', {gas})")
.UnwrapIfPromise()
.ToString();
SignedTx signedTx = this.processResponse<SignedTx>(signedTxResponse);
return await apiService.executeTx(signedTx.tx, signedTx.network);
}
}
Method to call smart-contract query
Parameters:
functionName: contract function name
params: function arguments (instance of ContractFunctionParameters)
accountId: sender account id
accountPrivateKey: sender's private key to sign transfer transaction
gas: gas amount for transaction (default 100000)
bladePayFee: blade pay fee, otherwise fee will be pay from sender accountId
returnTypes: array of return types, e.g. ["string", "int32"]
Returns:
an instance of ContractQueryData containing result from query with types
public async Task<ContractQueryData> contractCallQueryFunction(
string contractId,
string functionName,
ContractFunctionParameters parameters,
string accountId,
string accountPrivateKey,
uint gas,
uint fee,
List<string> returnTypes
) {
if (fee > 0) {
string nodeAccountId = "0.0.3";
string delayedQueryCallResponse = engine
.Evaluate($"window.bladeSdk.contractCallQueryFunction('{contractId}', '{functionName}', '{parameters.encode()}', '{accountId}', '{accountPrivateKey}', {gas}, {fee}, '{nodeAccountId}')")
.UnwrapIfPromise()
.ToString();
DelayedQueryCall delayedQueryCall = this.processResponse<DelayedQueryCall>(delayedQueryCallResponse);
DelayedQueryCallResult delayedQueryCallResult = await apiService.executeDelayedQueryCall(delayedQueryCall);
string contractCallQueryResponse = engine
.Evaluate($"window.bladeSdk.parseContractCallQueryResponse('{contractId}', '{delayedQueryCallResult.contractFunctionResult.gasUsed}', '{delayedQueryCallResult.rawResult}', ['{string.Join("', '", returnTypes)}'])")
.UnwrapIfPromise()
.ToString();
ContractQueryData contractQueryData = this.processResponse<ContractQueryData>(contractCallQueryResponse);
return contractQueryData;
} else {
// blade pay fee
throw new BladeSDKException("Error", "free queries not implemented yet");
}
}
Method to get C14 url for payment
Parameters:
asset: USDC, HBAR, KARATE or C14 asset uuid
account: receiver account id
Returns:
string with C14 url with preseted paramsbalances.
public async Task<string> getC14url(
string asset,
string account,
string amount
) {
string tvteToken = this.getTvteToken();
string clientId = await apiService.getC14token(tvteToken);
var purchaseParams = new Dictionary<string, object> {
{ "clientId", clientId }
};
switch (asset.ToUpper()) {
case "USDC":
purchaseParams["targetAssetId"] = "b0694345-1eb4-4bc4-b340-f389a58ee4f3";
purchaseParams["targetAssetIdLock"] = "true";
break;
case "HBAR":
purchaseParams["targetAssetId"] = "d9b45743-e712-4088-8a31-65ee6f371022";
purchaseParams["targetAssetIdLock"] = "true";
break;
case "KARATE":
purchaseParams["targetAssetId"] = "057d6b35-1af5-4827-bee2-c12842faa49e";
purchaseParams["targetAssetIdLock"] = "true";
break;
default:
if (asset.Split('-').Length == 5) {
purchaseParams["targetAssetId"] = asset;
purchaseParams["targetAssetIdLock"] = "true";
}
break;
}
if (!string.IsNullOrEmpty(amount)) {
purchaseParams["sourceAmount"] = amount;
purchaseParams["quoteAmountLock"] = "true";
}
if (!string.IsNullOrEmpty(account)) {
purchaseParams["targetAddress"] = account;
purchaseParams["targetAddressLock"] = "true";
}
string queryString = "";
foreach (var kv in purchaseParams) {
queryString = queryString + $"{HttpUtility.UrlEncode(kv.Key)}={HttpUtility.UrlEncode(kv.Value.ToString())}&";
}
var uriBuilder = new UriBuilder("https://pay.c14.money/");
uriBuilder.Query = queryString.ToString();
return uriBuilder.Uri.ToString();
}
Sign message with private key
Parameters:
messageEncoded: encoder message string
accountPrivateKey: private key string
encoding: message encoding. One of: hex, base64, utf8
Returns:
an instance of SignMessageData containing signature
public async Task<SignMessageData> sign(
string messageEncoded,
string accountPrivateKey,
string encoding // hex|base64|utf8
) {
string signMessageReponse = engine
.Evaluate($"window.bladeSdk.sign('{messageEncoded}', '{accountPrivateKey}', '{encoding}')")
.UnwrapIfPromise()
.ToString();
SignMessageData signMessageData = this.processResponse<SignMessageData>(signMessageReponse);
return signMessageData;
}
Verify message signature with public key
Parameters:
messageEncoded: message encoded
signatureHex: hex-encoded signature string
publicKey: public key string
encoding: message encoding. One of: hex, base64, utf8
Returns:
boolean. True if signature is valid
public async Task<bool> signVerify(
string messageEncoded,
string signatureHex,
string publicKey, // hex-encoded public key with DER header
string encoding // hex|base64|utf8
) {
string signVerifyMessageResponse = engine
.Evaluate($"window.bladeSdk.signVerify('{messageEncoded}', '{signatureHex}', '{publicKey}', '{encoding}')")
.UnwrapIfPromise()
.ToString();
SignVerifyMessageData signVerifyMessageData = this.processResponse<SignVerifyMessageData>(signVerifyMessageResponse);
return signVerifyMessageData.valid;
}
Sign message with private key (hethers lib)
Parameters:
messageEncoded: encoder message string
accountPrivateKey: private key string
encoding: message encoding. One of: hex, base64, utf8
Returns:
an instance of SignMessageData containing signature
public async Task<SignMessageData> hethersSign(
string messageEncoded,
string accountPrivateKey,
string encoding // hex|base64|utf8
) {
string signMessageReponse = engine
.Evaluate($"window.bladeSdk.hethersSign('{messageEncoded}', '{accountPrivateKey}', '{encoding}')")
.UnwrapIfPromise()
.ToString();
SignMessageData signMessageData = this.processResponse<SignMessageData>(signMessageReponse);
return signMessageData;
}
Method to split signature into v-r-s
Parameters:
signature: signature string "0x21fbf0696......"
Returns:
an instance of SplitSignatureData containing v, r, s
public async Task<SplitSignatureData> splitSignature(string signature) {
string splitSignatureResponse = engine
.Evaluate($"window.bladeSdk.splitSignature('{signature}')")
.UnwrapIfPromise()
.ToString();
SplitSignatureData splitSignatureData = this.processResponse<SplitSignatureData>(splitSignatureResponse);
return splitSignatureData;
}
Get signature for contract params into v-r-s
Parameters:
params: function arguments (instance of ContractFunctionParameters)
accountPrivateKey: account private key string
Returns:
an instance of SplitSignatureData containing v, r, s
public async Task<SplitSignatureData> getParamsSignature(
ContractFunctionParameters parameters,
string accountPrivateKey
) {
string splitSignatureResponse = engine
.Evaluate($"window.bladeSdk.getParamsSignature('{parameters.encode()}', '{accountPrivateKey}')")
.UnwrapIfPromise()
.ToString();
SplitSignatureData splitSignatureData = this.processResponse<SplitSignatureData>(splitSignatureResponse);
return splitSignatureData;
}
Method to get transactions history
Parameters:
accountId: accountId of history
transactionType: filter by type of transaction
nextPage: link from response to load next page of history
transactionsLimit: limit of transactions to load
Returns:
an instance of TransactionsHistoryData containing transaction records, filtered and aggregated
public async Task<TransactionsHistoryData> getTransactions(string accountId, string transactionType, string nextPage, int transactionsLimit) {
TransactionsHistoryData transactionsHistoryData = await apiService.getTransactionsFrom(accountId, transactionType, nextPage, transactionsLimit);
return transactionsHistoryData;
}
