732 lines
29 KiB
C
732 lines
29 KiB
C
#include <string.h>
|
|
#include "eth_plugin_interface.h"
|
|
#include "shared_context.h" // TODO : rewrite as independant code
|
|
#include "eth_plugin_internal.h" // TODO : rewrite as independant code
|
|
#include "stark_utils.h"
|
|
#include "utils.h"
|
|
|
|
#ifdef HAVE_STARKWARE
|
|
|
|
typedef enum {
|
|
|
|
STARKWARE_REGISTER = 0,
|
|
STARKWARE_DEPOSIT_TOKEN,
|
|
STARKWARE_DEPOSIT_ETH,
|
|
STARKWARE_DEPOSIT_CANCEL,
|
|
STARKWARE_DEPOSIT_RECLAIM,
|
|
STARKWARE_WITHDRAW,
|
|
STARKWARE_FULL_WITHDRAW,
|
|
STARKWARE_FREEZE,
|
|
STARKWARE_ESCAPE,
|
|
STARKWARE_VERIFY_ESCAPE,
|
|
STARKWARE_WITHDRAW_TO,
|
|
STARKWARE_DEPOSIT_NFT,
|
|
STARKWARE_DEPOSIT_NFT_RECLAIM,
|
|
STARKWARE_WITHDRAW_AND_MINT,
|
|
STARKWARE_WITHDRAW_NFT,
|
|
STARKWARE_WITHDRAW_NFT_TO
|
|
} starkwareSelector_t;
|
|
|
|
#ifndef HAVE_TOKENS_EXTRA_LIST
|
|
|
|
static const uint8_t DEVERSIFI_CONTRACT[] = {0x01, 0x5d, 0x22, 0x04, 0x5d, 0xac, 0xea,
|
|
0xb0, 0x3b, 0x15, 0x80, 0x31, 0xec, 0xb7,
|
|
0xd9, 0xd0, 0x6f, 0xad, 0x24, 0x60, 0x9b};
|
|
|
|
#else
|
|
|
|
static const uint8_t DEVERSIFI_CONTRACT[] = {
|
|
0x02, 0xe7, 0x3a, 0x39, 0x4a, 0xde, 0x4d, 0x94, 0xa0, 0x73, 0x50, 0x2d, 0xa8, 0x70,
|
|
0x3e, 0xa2, 0x34, 0x90, 0xdc, 0x7b, 0x6a, 0x69, 0xC6, 0x39, 0x2E, 0xb0, 0x2a, 0x28,
|
|
0x82, 0x31, 0x41, 0x34, 0xc9, 0x8D, 0xDC, 0xBF, 0x73, 0xB7, 0xAd, 0xBa, 0xb1};
|
|
|
|
#endif
|
|
|
|
// register : address (20), stark key (32), drop param 3
|
|
// Registration
|
|
// Contract Name
|
|
// From ETH address
|
|
// Master account
|
|
// deposit token : stark key (32), verify assetType (32), vaultId (4), quantized Amount (32)
|
|
// Deposit
|
|
// Contract Name
|
|
// Master Account
|
|
// Token Account
|
|
// Amount
|
|
// deposit : stark key (32), verify assetType (32), vaultId (4)
|
|
// Flow similar to deposit
|
|
// deposit cancel, deposit reclaim : stark key (32), assetType (reclaim) / assetId (cancel) (32)
|
|
// ignored, vaultId(4) full withdrawal, freeze : stark key (32), vaultId (4) Cancel Deposit |
|
|
// Reclaim Deposit | Full Withdrawal | Freeze Contract Name Master Account Token Account
|
|
// withdrawal : stark key (32), verify assetType (32)
|
|
// Withdrawal
|
|
// Contract Name
|
|
// Master Account
|
|
// To Eth Address
|
|
// Token Symbol
|
|
// withdrawal to : stark key (32), verify assetType (32), address (20)
|
|
// Withdrawal To
|
|
// Contract Name
|
|
// Master Account
|
|
// To Eth Address
|
|
// Token Symbol
|
|
// escape : stark key (32), vaultId (4), verify assetType (32), quantized Amount (32)
|
|
// Escape
|
|
// Contract Name
|
|
// Amount
|
|
// Master Account
|
|
// Token Account
|
|
// verify escape : escapeProof (ignore)
|
|
// Verify Escape
|
|
// Contract Name
|
|
// deposit NFT : stark key (32), verify assetType (32), vault id (4), token id (32)
|
|
// Deposit
|
|
// Contract Name
|
|
// Master Account
|
|
// Token Account
|
|
// NFT Contract
|
|
// Token ID
|
|
// deposit NFT reclaim : stark key (32), verify assetType (32), vault id (4), token id (32)
|
|
// Reclaim Deposit
|
|
// Contract Name
|
|
// Master Account
|
|
// Token Account
|
|
// NFT Contract
|
|
// Token ID
|
|
// withdraw and mint : stark key (32), verify assetType (32), mintable blob (ignored variable)
|
|
// Withdrawal
|
|
// Contract Name
|
|
// Master Account
|
|
// Asset Contract
|
|
// withdraw NFT : stark key (32), verify assetType (32), token id (32)
|
|
// Withdrawal
|
|
// Contract Name
|
|
// Master Account
|
|
// To Eth Address
|
|
// NFT Contract
|
|
// Token ID
|
|
// withdraw NFT To : stark key (32), verify assetType (32), token id (32), address (20)
|
|
// Withdrawal To
|
|
// Contract Name
|
|
// Master Account
|
|
// To Eth Address
|
|
// NFT Contract
|
|
// Token ID
|
|
|
|
static const uint8_t STARKWARE_EXPECTED_DATA_SIZE[] = {0,
|
|
4 + 32 + 32 + 32 + 32,
|
|
4 + 32 + 32 + 32,
|
|
4 + 32 + 32 + 32,
|
|
4 + 32 + 32 + 32,
|
|
4 + 32 + 32,
|
|
4 + 32 + 32,
|
|
4 + 32 + 32,
|
|
4 + 32 + 32 + 32 + 32,
|
|
0,
|
|
4 + 32 + 32 + 32,
|
|
4 + 32 + 32 + 32 + 32,
|
|
4 + 32 + 32 + 32 + 32,
|
|
0,
|
|
4 + 32 + 32 + 32,
|
|
4 + 32 + 32 + 32 + 32};
|
|
|
|
static const uint8_t STARKWARE_NUM_SCREENS[] = {4 - 1,
|
|
5 - 1,
|
|
5 - 1,
|
|
4 - 1,
|
|
4 - 1,
|
|
5 - 1,
|
|
4 - 1,
|
|
4 - 1,
|
|
5 - 1,
|
|
2 - 1,
|
|
5 - 1,
|
|
6 - 1,
|
|
6 - 1,
|
|
4 - 1,
|
|
6 - 1,
|
|
6 - 1};
|
|
|
|
typedef struct starkware_parameters_t {
|
|
uint8_t vaultId[4];
|
|
uint8_t selectorIndex;
|
|
uint8_t starkKey[32];
|
|
uint8_t amount[32];
|
|
uint8_t validToken;
|
|
|
|
} starkware_parameters_t;
|
|
|
|
bool is_deversify_contract(const uint8_t *address) {
|
|
uint32_t offset = 0;
|
|
uint8_t i;
|
|
|
|
for (i = 0; i < DEVERSIFI_CONTRACT[0]; i++) {
|
|
if (memcmp(address, DEVERSIFI_CONTRACT + offset + 1, 20) == 0) {
|
|
return true;
|
|
}
|
|
offset += 20;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// TODO : rewrite as independant code
|
|
bool starkware_verify_asset_id(uint8_t *tmp32, uint8_t *tokenId, bool assetTypeOnly) {
|
|
if (quantumSet) {
|
|
cx_sha3_t sha3;
|
|
tokenDefinition_t *currentToken = NULL;
|
|
if (dataContext.tokenContext.quantumIndex != MAX_TOKEN) {
|
|
currentToken = &tmpCtx.transactionContext.tokens[dataContext.tokenContext.quantumIndex];
|
|
}
|
|
cx_keccak_init(&sha3, 256);
|
|
compute_token_id(&sha3,
|
|
(currentToken != NULL ? currentToken->address : NULL),
|
|
dataContext.tokenContext.quantumType,
|
|
dataContext.tokenContext.quantum,
|
|
dataContext.tokenContext.mintingBlob,
|
|
assetTypeOnly,
|
|
tmp32);
|
|
if (memcmp(tokenId, tmp32, 32) != 0) {
|
|
PRINTF("Token ID not matching - computed %.*H\n", 32, tmp32);
|
|
PRINTF("Current quantum %.*H\n", 32, dataContext.tokenContext.quantum);
|
|
PRINTF("Requested %.*H\n", 32, tokenId);
|
|
return false;
|
|
}
|
|
} else {
|
|
PRINTF("Quantum not set\n");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool starkware_verify_nft_token_id(uint8_t *tokenId) {
|
|
if (!quantumSet) {
|
|
PRINTF("Quantum not set\n");
|
|
return false;
|
|
}
|
|
switch (dataContext.tokenContext.quantumType) {
|
|
case STARK_QUANTUM_ERC721:
|
|
case STARK_QUANTUM_MINTABLE_ERC721:
|
|
break;
|
|
default:
|
|
PRINTF("Unexpected quantum type for NFT token id check %d\n",
|
|
dataContext.tokenContext.quantumType);
|
|
return false;
|
|
}
|
|
if (memcmp(dataContext.tokenContext.quantum, tokenId, 32) != 0) {
|
|
PRINTF("Token ID not matching - expected %.*H\n", 32, dataContext.tokenContext.quantum);
|
|
PRINTF("Current token ID %.*H\n", 32, tokenId);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void starkware_print_vault_id(uint32_t vaultId, char *destination) {
|
|
snprintf(destination, 10, "%d", vaultId);
|
|
}
|
|
|
|
void starkware_print_stark_key(uint8_t *starkKey, char *destination) {
|
|
snprintf(destination, 70, "0x%.*H", 32, starkKey);
|
|
}
|
|
|
|
// TODO : rewrite as independant code
|
|
void starkware_print_eth_address(uint8_t *address, char *destination) {
|
|
destination[0] = '0';
|
|
destination[1] = 'x';
|
|
getEthAddressStringFromBinary(address,
|
|
(uint8_t *) (destination + 2),
|
|
&global_sha3,
|
|
chainConfig);
|
|
destination[42] = '\0';
|
|
}
|
|
|
|
// TODO : rewrite as independant code
|
|
void starkware_print_amount(uint8_t *amountData, char *destination, bool forEscape) {
|
|
uint256_t amount, amountPre, quantum;
|
|
uint8_t decimals;
|
|
char *ticker = (char *) PIC(chainConfig->coinName);
|
|
|
|
if ((amountData == NULL) ||
|
|
(forEscape && (dataContext.tokenContext.quantumIndex == MAX_TOKEN))) {
|
|
decimals = WEI_TO_ETHER;
|
|
if (!forEscape) {
|
|
convertUint256BE(tmpContent.txContent.value.value,
|
|
tmpContent.txContent.value.length,
|
|
&amount);
|
|
} else {
|
|
readu256BE(amountData, &amountPre);
|
|
}
|
|
} else {
|
|
tokenDefinition_t *token =
|
|
&tmpCtx.transactionContext.tokens[dataContext.tokenContext.quantumIndex];
|
|
decimals = token->decimals;
|
|
ticker = (char *) token->ticker;
|
|
readu256BE(amountData, &amountPre);
|
|
}
|
|
if (amountData != NULL) {
|
|
readu256BE(dataContext.tokenContext.quantum, &quantum);
|
|
mul256(&amountPre, &quantum, &amount);
|
|
}
|
|
tostring256(&amount, 10, (char *) (G_io_apdu_buffer + 100), 100);
|
|
strcpy(destination, ticker);
|
|
adjustDecimals((char *) (G_io_apdu_buffer + 100),
|
|
strlen((char *) (G_io_apdu_buffer + 100)),
|
|
destination + strlen(ticker),
|
|
50 - strlen(ticker),
|
|
decimals);
|
|
}
|
|
|
|
// TODO : rewrite as independant code
|
|
void starkware_print_ticker(char *destination) {
|
|
char *ticker = (char *) PIC(chainConfig->coinName);
|
|
|
|
if (dataContext.tokenContext.quantumIndex != MAX_TOKEN) {
|
|
tokenDefinition_t *token =
|
|
&tmpCtx.transactionContext.tokens[dataContext.tokenContext.quantumIndex];
|
|
ticker = (char *) token->ticker;
|
|
}
|
|
strcpy(destination, ticker);
|
|
}
|
|
|
|
// TODO : rewrite as independant code
|
|
void starkware_print_asset_contract(char *destination) {
|
|
// token has been validated to be present previously
|
|
if (dataContext.tokenContext.quantumIndex != MAX_TOKEN) {
|
|
tokenDefinition_t *token =
|
|
&tmpCtx.transactionContext.tokens[dataContext.tokenContext.quantumIndex];
|
|
starkware_print_eth_address(token->address, destination);
|
|
} else {
|
|
strcpy(destination, "UNKNOWN");
|
|
}
|
|
}
|
|
|
|
// TODO : rewrite as independant code
|
|
void starkware_get_source_address(char *destination) {
|
|
uint8_t privateKeyData[32];
|
|
cx_ecfp_private_key_t privateKey;
|
|
cx_ecfp_public_key_t publicKey;
|
|
os_perso_derive_node_bip32(CX_CURVE_256K1,
|
|
tmpCtx.transactionContext.bip32Path,
|
|
tmpCtx.transactionContext.pathLength,
|
|
privateKeyData,
|
|
NULL);
|
|
cx_ecfp_init_private_key(CX_CURVE_256K1, privateKeyData, 32, &privateKey);
|
|
io_seproxyhal_io_heartbeat();
|
|
cx_ecfp_generate_pair(CX_CURVE_256K1, &publicKey, &privateKey, 1);
|
|
explicit_bzero(&privateKey, sizeof(privateKey));
|
|
explicit_bzero(privateKeyData, sizeof(privateKeyData));
|
|
io_seproxyhal_io_heartbeat();
|
|
destination[0] = '0';
|
|
destination[1] = 'x';
|
|
getEthAddressStringFromKey(&publicKey,
|
|
(uint8_t *) (destination + 2),
|
|
&global_sha3,
|
|
chainConfig);
|
|
destination[42] = '\0';
|
|
}
|
|
|
|
void starkware_plugin_call(int message, void *parameters) {
|
|
switch (message) {
|
|
case ETH_PLUGIN_INIT_CONTRACT: {
|
|
uint8_t i;
|
|
ethPluginInitContract_t *msg = (ethPluginInitContract_t *) parameters;
|
|
starkware_parameters_t *context = (starkware_parameters_t *) msg->pluginContext;
|
|
PRINTF("starkware plugin init\n");
|
|
for (i = 0; i < NUM_STARKWARE_SELECTORS; i++) {
|
|
if (memcmp((const void *) PIC(STARKWARE_SELECTORS[i]),
|
|
msg->selector,
|
|
SELECTOR_SIZE) == 0) {
|
|
context->selectorIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
if (i == NUM_STARKWARE_SELECTORS) {
|
|
PRINTF("Unknown selector %.*H\n", SELECTOR_SIZE, msg->selector);
|
|
break;
|
|
}
|
|
if (STARKWARE_EXPECTED_DATA_SIZE[context->selectorIndex] != 0) {
|
|
if (msg->dataSize != STARKWARE_EXPECTED_DATA_SIZE[context->selectorIndex]) {
|
|
PRINTF("Unexpected data size for command %d expected %d got %d\n",
|
|
context->selectorIndex,
|
|
STARKWARE_EXPECTED_DATA_SIZE[context->selectorIndex],
|
|
msg->dataSize);
|
|
break;
|
|
}
|
|
}
|
|
context->validToken = true;
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
} break;
|
|
|
|
case ETH_PLUGIN_PROVIDE_PARAMETER: {
|
|
ethPluginProvideParameter_t *msg = (ethPluginProvideParameter_t *) parameters;
|
|
starkware_parameters_t *context = (starkware_parameters_t *) msg->pluginContext;
|
|
PRINTF("starkware plugin provide parameter %d %.*H\n",
|
|
msg->parameterOffset,
|
|
32,
|
|
msg->parameter);
|
|
// Ignore for verify escape
|
|
if (context->selectorIndex == STARKWARE_VERIFY_ESCAPE) {
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
}
|
|
switch (msg->parameterOffset) {
|
|
case 4:
|
|
switch (context->selectorIndex) {
|
|
case STARKWARE_REGISTER:
|
|
memmove(context->amount, msg->parameter + 32 - 20, 20);
|
|
break;
|
|
|
|
case STARKWARE_DEPOSIT_TOKEN:
|
|
case STARKWARE_DEPOSIT_ETH:
|
|
case STARKWARE_DEPOSIT_CANCEL:
|
|
case STARKWARE_DEPOSIT_RECLAIM:
|
|
case STARKWARE_WITHDRAW:
|
|
case STARKWARE_FULL_WITHDRAW:
|
|
case STARKWARE_FREEZE:
|
|
case STARKWARE_ESCAPE:
|
|
case STARKWARE_WITHDRAW_TO:
|
|
case STARKWARE_DEPOSIT_NFT:
|
|
case STARKWARE_DEPOSIT_NFT_RECLAIM:
|
|
case STARKWARE_WITHDRAW_AND_MINT:
|
|
case STARKWARE_WITHDRAW_NFT:
|
|
case STARKWARE_WITHDRAW_NFT_TO:
|
|
memmove(context->starkKey, msg->parameter, 32);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
|
|
case 4 + 32:
|
|
switch (context->selectorIndex) {
|
|
case STARKWARE_REGISTER:
|
|
memmove(context->starkKey, msg->parameter, 32);
|
|
break;
|
|
|
|
case STARKWARE_ESCAPE:
|
|
memmove(context->vaultId, msg->parameter + 32 - 4, 4);
|
|
break;
|
|
|
|
case STARKWARE_DEPOSIT_CANCEL:
|
|
case STARKWARE_DEPOSIT_RECLAIM:
|
|
break;
|
|
|
|
case STARKWARE_FULL_WITHDRAW:
|
|
case STARKWARE_FREEZE:
|
|
memmove(context->vaultId, msg->parameter + 32 - 4, 4);
|
|
break;
|
|
|
|
case STARKWARE_DEPOSIT_ETH:
|
|
case STARKWARE_DEPOSIT_TOKEN:
|
|
case STARKWARE_WITHDRAW:
|
|
case STARKWARE_WITHDRAW_TO:
|
|
case STARKWARE_DEPOSIT_NFT:
|
|
case STARKWARE_DEPOSIT_NFT_RECLAIM:
|
|
case STARKWARE_WITHDRAW_AND_MINT:
|
|
case STARKWARE_WITHDRAW_NFT:
|
|
case STARKWARE_WITHDRAW_NFT_TO:
|
|
context->validToken =
|
|
starkware_verify_asset_id(context->amount, msg->parameter, true);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
|
|
case 4 + 32 + 32:
|
|
switch (context->selectorIndex) {
|
|
case STARKWARE_ESCAPE:
|
|
context->validToken =
|
|
starkware_verify_asset_id(context->amount, msg->parameter, true);
|
|
break;
|
|
|
|
case STARKWARE_DEPOSIT_CANCEL:
|
|
case STARKWARE_DEPOSIT_RECLAIM:
|
|
case STARKWARE_DEPOSIT_ETH:
|
|
case STARKWARE_DEPOSIT_TOKEN:
|
|
case STARKWARE_DEPOSIT_NFT:
|
|
case STARKWARE_DEPOSIT_NFT_RECLAIM:
|
|
memmove(context->vaultId, msg->parameter + 32 - 4, 4);
|
|
break;
|
|
|
|
case STARKWARE_WITHDRAW_TO:
|
|
memmove(context->amount, msg->parameter + 32 - 20, 20);
|
|
break;
|
|
|
|
case STARKWARE_WITHDRAW_NFT:
|
|
case STARKWARE_WITHDRAW_NFT_TO:
|
|
context->validToken = starkware_verify_nft_token_id(msg->parameter);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
|
|
case 4 + 32 + 32 + 32:
|
|
switch (context->selectorIndex) {
|
|
case STARKWARE_ESCAPE:
|
|
case STARKWARE_DEPOSIT_TOKEN:
|
|
memmove(context->amount, msg->parameter, 32);
|
|
break;
|
|
|
|
case STARKWARE_WITHDRAW_NFT_TO:
|
|
memmove(context->amount, msg->parameter + 32 - 20, 20);
|
|
break;
|
|
|
|
case STARKWARE_DEPOSIT_NFT:
|
|
case STARKWARE_DEPOSIT_NFT_RECLAIM:
|
|
context->validToken = starkware_verify_nft_token_id(msg->parameter);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
|
|
default:
|
|
switch (context->selectorIndex) {
|
|
case STARKWARE_REGISTER:
|
|
case STARKWARE_VERIFY_ESCAPE:
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
|
|
default:
|
|
PRINTF("Unhandled parameter offset\n");
|
|
break;
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case ETH_PLUGIN_FINALIZE: {
|
|
ethPluginFinalize_t *msg = (ethPluginFinalize_t *) parameters;
|
|
starkware_parameters_t *context = (starkware_parameters_t *) msg->pluginContext;
|
|
PRINTF("starkware plugin finalize\n");
|
|
if (!context->validToken) {
|
|
msg->result = ETH_PLUGIN_RESULT_FALLBACK;
|
|
} else {
|
|
msg->uiType = ETH_UI_TYPE_GENERIC;
|
|
msg->numScreens = STARKWARE_NUM_SCREENS[context->selectorIndex];
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
}
|
|
} break;
|
|
|
|
case ETH_PLUGIN_QUERY_CONTRACT_ID: {
|
|
ethQueryContractID_t *msg = (ethQueryContractID_t *) parameters;
|
|
starkware_parameters_t *context = (starkware_parameters_t *) msg->pluginContext;
|
|
PRINTF("starkware query contract id\n");
|
|
switch (context->selectorIndex) {
|
|
case STARKWARE_REGISTER:
|
|
strcpy(msg->name, "Register");
|
|
break;
|
|
case STARKWARE_DEPOSIT_TOKEN:
|
|
case STARKWARE_DEPOSIT_ETH:
|
|
case STARKWARE_DEPOSIT_NFT:
|
|
strcpy(msg->name, "Deposit");
|
|
break;
|
|
case STARKWARE_DEPOSIT_CANCEL:
|
|
strcpy(msg->name, "Cancel Deposit");
|
|
break;
|
|
case STARKWARE_DEPOSIT_RECLAIM:
|
|
case STARKWARE_DEPOSIT_NFT_RECLAIM:
|
|
strcpy(msg->name, "Reclaim Deposit");
|
|
break;
|
|
case STARKWARE_WITHDRAW:
|
|
case STARKWARE_WITHDRAW_NFT:
|
|
case STARKWARE_WITHDRAW_AND_MINT:
|
|
strcpy(msg->name, "Withdrawal");
|
|
break;
|
|
case STARKWARE_FULL_WITHDRAW:
|
|
strcpy(msg->name, "Full Withdrawal");
|
|
break;
|
|
case STARKWARE_FREEZE:
|
|
strcpy(msg->name, "Freeze");
|
|
break;
|
|
case STARKWARE_ESCAPE:
|
|
strcpy(msg->name, "Escape");
|
|
break;
|
|
case STARKWARE_VERIFY_ESCAPE:
|
|
strcpy(msg->name, "Verify Escape");
|
|
break;
|
|
case STARKWARE_WITHDRAW_TO:
|
|
case STARKWARE_WITHDRAW_NFT_TO:
|
|
strcpy(msg->name, "Withdrawal To");
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
strcpy(msg->version,
|
|
is_deversify_contract(tmpContent.txContent.destination) ? "DeversiFi"
|
|
: "Starkware");
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
} break;
|
|
|
|
case ETH_PLUGIN_QUERY_CONTRACT_UI: {
|
|
ethQueryContractUI_t *msg = (ethQueryContractUI_t *) parameters;
|
|
starkware_parameters_t *context = (starkware_parameters_t *) msg->pluginContext;
|
|
switch (msg->screenIndex) {
|
|
case 0:
|
|
strcpy(msg->title, "Contract Name");
|
|
if (is_deversify_contract(tmpContent.txContent.destination)) {
|
|
strcpy(msg->msg, "DeversiFi");
|
|
} else {
|
|
starkware_print_eth_address(tmpContent.txContent.destination, msg->msg);
|
|
}
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
case 1:
|
|
switch (context->selectorIndex) {
|
|
case STARKWARE_REGISTER:
|
|
strcpy(msg->title, "From ETH Address");
|
|
starkware_print_eth_address(context->amount, msg->msg);
|
|
break;
|
|
case STARKWARE_ESCAPE:
|
|
strcpy(msg->title, "Amount");
|
|
starkware_print_amount(context->amount, msg->msg, true);
|
|
break;
|
|
case STARKWARE_DEPOSIT_TOKEN:
|
|
case STARKWARE_DEPOSIT_ETH:
|
|
case STARKWARE_DEPOSIT_CANCEL:
|
|
case STARKWARE_DEPOSIT_RECLAIM:
|
|
case STARKWARE_WITHDRAW:
|
|
case STARKWARE_FULL_WITHDRAW:
|
|
case STARKWARE_FREEZE:
|
|
case STARKWARE_VERIFY_ESCAPE:
|
|
case STARKWARE_WITHDRAW_TO:
|
|
case STARKWARE_DEPOSIT_NFT:
|
|
case STARKWARE_DEPOSIT_NFT_RECLAIM:
|
|
case STARKWARE_WITHDRAW_AND_MINT:
|
|
case STARKWARE_WITHDRAW_NFT:
|
|
case STARKWARE_WITHDRAW_NFT_TO:
|
|
strcpy(msg->title, "Master Account");
|
|
starkware_print_stark_key(context->starkKey, msg->msg);
|
|
break;
|
|
default:
|
|
PRINTF("Unexpected screen %d for %d\n",
|
|
msg->screenIndex,
|
|
context->selectorIndex);
|
|
break;
|
|
}
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
case 2:
|
|
switch (context->selectorIndex) {
|
|
case STARKWARE_REGISTER:
|
|
case STARKWARE_ESCAPE:
|
|
strcpy(msg->title, "Master Account");
|
|
starkware_print_stark_key(context->starkKey, msg->msg);
|
|
break;
|
|
|
|
case STARKWARE_DEPOSIT_TOKEN:
|
|
case STARKWARE_DEPOSIT_ETH:
|
|
case STARKWARE_DEPOSIT_CANCEL:
|
|
case STARKWARE_DEPOSIT_RECLAIM:
|
|
case STARKWARE_FULL_WITHDRAW:
|
|
case STARKWARE_FREEZE:
|
|
case STARKWARE_DEPOSIT_NFT:
|
|
case STARKWARE_DEPOSIT_NFT_RECLAIM:
|
|
strcpy(msg->title, "Token Account");
|
|
starkware_print_vault_id(U4BE(context->vaultId, 0), msg->msg);
|
|
break;
|
|
case STARKWARE_WITHDRAW:
|
|
case STARKWARE_WITHDRAW_NFT:
|
|
strcpy(msg->title, "To ETH Address");
|
|
starkware_get_source_address(msg->msg);
|
|
break;
|
|
case STARKWARE_WITHDRAW_TO:
|
|
case STARKWARE_WITHDRAW_NFT_TO:
|
|
strcpy(msg->title, "To ETH Address");
|
|
starkware_print_eth_address(context->amount, msg->msg);
|
|
break;
|
|
case STARKWARE_WITHDRAW_AND_MINT:
|
|
strcpy(msg->title, "Asset Contract");
|
|
starkware_print_asset_contract(msg->msg);
|
|
break;
|
|
|
|
default:
|
|
PRINTF("Unexpected screen %d for %d\n",
|
|
msg->screenIndex,
|
|
context->selectorIndex);
|
|
break;
|
|
}
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
|
|
case 3:
|
|
switch (context->selectorIndex) {
|
|
case STARKWARE_ESCAPE:
|
|
strcpy(msg->title, "Token Account");
|
|
starkware_print_vault_id(U4BE(context->vaultId, 0), msg->msg);
|
|
break;
|
|
case STARKWARE_DEPOSIT_TOKEN:
|
|
case STARKWARE_DEPOSIT_ETH:
|
|
strcpy(msg->title, "Amount");
|
|
starkware_print_amount(
|
|
(context->selectorIndex == STARKWARE_DEPOSIT_ETH ? NULL
|
|
: context->amount),
|
|
msg->msg,
|
|
false);
|
|
break;
|
|
case STARKWARE_WITHDRAW:
|
|
case STARKWARE_WITHDRAW_TO:
|
|
strcpy(msg->title, "Token Symbol");
|
|
starkware_print_ticker(msg->msg);
|
|
break;
|
|
|
|
case STARKWARE_WITHDRAW_NFT:
|
|
case STARKWARE_WITHDRAW_NFT_TO:
|
|
case STARKWARE_DEPOSIT_NFT:
|
|
case STARKWARE_DEPOSIT_NFT_RECLAIM:
|
|
strcpy(msg->title, "NFT Contract");
|
|
starkware_print_asset_contract(msg->msg);
|
|
break;
|
|
|
|
default:
|
|
PRINTF("Unexpected screen %d for %d\n",
|
|
msg->screenIndex,
|
|
context->selectorIndex);
|
|
break;
|
|
}
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
|
|
case 4:
|
|
switch (context->selectorIndex) {
|
|
case STARKWARE_WITHDRAW_NFT:
|
|
case STARKWARE_WITHDRAW_NFT_TO:
|
|
case STARKWARE_DEPOSIT_NFT:
|
|
case STARKWARE_DEPOSIT_NFT_RECLAIM:
|
|
strcpy(msg->title, "TokenID");
|
|
starkware_print_stark_key(dataContext.tokenContext.quantum, msg->msg);
|
|
break;
|
|
|
|
default:
|
|
PRINTF("Unexpected screen %d for %d\n",
|
|
msg->screenIndex,
|
|
context->selectorIndex);
|
|
break;
|
|
}
|
|
msg->result = ETH_PLUGIN_RESULT_OK;
|
|
break;
|
|
|
|
default:
|
|
PRINTF("Unexpected screen %d for %d\n",
|
|
msg->screenIndex,
|
|
context->selectorIndex);
|
|
break;
|
|
}
|
|
} break;
|
|
|
|
default:
|
|
PRINTF("Unhandled message %d\n", message);
|
|
}
|
|
}
|
|
|
|
#endif
|