feat: implement airdrop108 in ic_panda_frontend

Author: zensh

Cargo.lock

@@ -21,7 +21,7 @@ opt-level = 's'
 
 [workspace.package]
 edition = "2021"
-version = "2.6.1"
+version = "2.6.4"
 repository = "https://github.com/ldclabs/ic-panda"
 keywords = ["canister", "icp", "panda"]
 categories = ["web-programming"]

Cargo.toml

@@ -11,6 +11,11 @@ type AddPrizeInputV2 = record {
   quantity : nat16;
   expire : nat16;
 };
+type Airdrop = record {
+  weight : nat64;
+  subaccount : opt text;
+  neuron_id : opt text;
+};
 type AirdropClaimInput = record {
   recaptcha : opt text;
   challenge : text;
@@ -40,6 +45,21 @@ type AirdropStateOutput = record {
   claimed : nat;
   claimable : nat;
 };
+type Airdrops108Output = record {
+  status : int8;
+  ledger_updated_at : nat64;
+  airdrops : vec Airdrop;
+  ledger_weight_total : nat64;
+  tokens_per_weight : float64;
+  error : opt text;
+  neurons_hash : text;
+  neurons_airdropped : bool;
+  ledger_hash : text;
+  tokens_distributed : nat64;
+  neurons_weight_total : nat64;
+  neurons_updated_at : nat64;
+  ledger_airdropped : bool;
+};
 type CaptchaOutput = record { challenge : text; img_base64 : text };
 type ClaimPrizeInput = record { challenge : blob; code : text };
 type ClaimPrizeOutput = record {
@@ -102,18 +122,21 @@ type PrizeOutput = record {
 };
 type Result = variant { Ok : PrizeOutput; Err : text };
 type Result_1 = variant { Ok; Err : text };
-type Result_10 = variant { Ok : NameOutput; Err : text };
-type Result_11 = variant { Ok : State; Err };
-type Result_12 = variant { Ok : nat; Err : text };
-type Result_13 = variant { Ok : principal; Err };
+type Result_10 = variant { Ok : nat64; Err : text };
+type Result_11 = variant { Ok : opt NameOutput; Err };
+type Result_12 = variant { Ok : principal; Err : text };
+type Result_13 = variant { Ok : NameOutput; Err : text };
+type Result_14 = variant { Ok : State; Err };
+type Result_15 = variant { Ok : nat; Err : text };
+type Result_16 = variant { Ok : principal; Err };
 type Result_2 = variant { Ok : AirdropStateOutput; Err : text };
 type Result_3 = variant { Ok : AirdropStateOutput; Err };
-type Result_4 = variant { Ok : CaptchaOutput; Err : text };
-type Result_5 = variant { Ok : ClaimPrizeOutput; Err : text };
-type Result_6 = variant { Ok : LuckyDrawOutput; Err : text };
-type Result_7 = variant { Ok : text; Err : text };
-type Result_8 = variant { Ok : opt NameOutput; Err };
-type Result_9 = variant { Ok : principal; Err : text };
+type Result_4 = variant { Ok : Airdrops108Output; Err };
+type Result_5 = variant { Ok : CaptchaOutput; Err : text };
+type Result_6 = variant { Ok : ClaimPrizeOutput; Err : text };
+type Result_7 = variant { Ok : LuckyDrawOutput; Err : text };
+type Result_8 = variant { Ok : text; Err : text };
+type Result_9 = variant { Ok : bool; Err : text };
 type State = record {
   latest_luckydraw_logs : vec LuckyDrawLog;
   total_luckydraw : nat64;
@@ -135,34 +158,39 @@ type State = record {
 service : () -> {
   add_prize : (AddPrizeInputV2) -> (Result);
   admin_collect_icp : (nat) -> (Result_1);
+  admin_collect_tokens : (nat) -> (Result_1);
   admin_set_managers : (vec principal) -> (Result_1);
   airdrop : (AirdropClaimInput) -> (Result_2);
   airdrop_codes_of : (principal) -> (vec AirdropCodeOutput) query;
   airdrop_logs : (opt nat, opt nat) -> (vec AirdropLog) query;
   airdrop_state_of : (opt principal) -> (Result_3) query;
+  airdrops108_of : (opt principal) -> (Result_4) query;
   api_version : () -> (nat16) query;
-  captcha : () -> (Result_4);
-  claim_prize : (ClaimPrizeInput) -> (Result_5);
+  captcha : () -> (Result_5);
+  claim_prize : (ClaimPrizeInput) -> (Result_6);
   harvest : (AirdropHarvestInput) -> (Result_2);
-  luckydraw : (LuckyDrawInput) -> (Result_6);
+  luckydraw : (LuckyDrawInput) -> (Result_7);
   luckydraw_logs : (opt nat, opt nat) -> (vec LuckyDrawLog) query;
   manager_add_notification : (Notification) -> (Result_1);
-  manager_add_prize : (AddPrizeInput) -> (Result_7);
-  manager_add_prize_v2 : (AddPrizeInputV2) -> (Result_7);
+  manager_add_prize : (AddPrizeInput) -> (Result_8);
+  manager_add_prize_v2 : (AddPrizeInputV2) -> (Result_8);
   manager_ban_users : (vec principal) -> (Result_1);
-  manager_get_airdrop_key : () -> (Result_7) query;
+  manager_get_airdrop_key : () -> (Result_8) query;
   manager_remove_notifications : (blob) -> (Result_1);
   manager_set_challenge_pub_key : (text) -> (Result_1);
+  manager_start_airdrops108 : () -> (Result_9);
   manager_update_airdrop_amount : (nat64) -> (Result_1);
   manager_update_airdrop_balance : (nat64) -> (Result_1);
+  manager_update_airdrops108_ledger_list : (blob) -> (Result_10);
+  manager_update_airdrops108_neurons_list : (blob) -> (Result_10);
   manager_update_prize_subsidy : (
       opt record { nat64; nat16; nat32; nat8; nat32; nat16 },
     ) -> (Result_1);
   my_luckydraw_logs : (opt nat, opt nat) -> (vec LuckyDrawLog) query;
-  name_lookup : (text) -> (Result_8) query;
-  name_of : (opt principal) -> (Result_8) query;
+  name_lookup : (text) -> (Result_11) query;
+  name_of : (opt principal) -> (Result_11) query;
   notifications : () -> (vec Notification) query;
-  principal_by_luckycode : (text) -> (Result_9) query;
+  principal_by_luckycode : (text) -> (Result_12) query;
   prize : (text) -> (Result_2);
   prize_claim_logs : (principal, opt nat, opt nat) -> (vec PrizeClaimLog) query;
   prize_info : (text, opt principal) -> (Result) query;
@@ -171,13 +199,14 @@ service : () -> {
   prizes_of : (opt principal) -> (
       vec record { nat32; nat32; nat16; nat32; nat16; nat16 },
     ) query;
-  register_name : (NameInput) -> (Result_10);
-  state : () -> (Result_11) query;
-  unregister_name : (NameInput) -> (Result_12);
-  update_name : (NameInput) -> (Result_10);
-  validate2_admin_collect_icp : (nat) -> (Result_7);
-  validate2_admin_set_managers : (vec principal) -> (Result_7);
+  register_name : (NameInput) -> (Result_13);
+  state : () -> (Result_14) query;
+  unregister_name : (NameInput) -> (Result_15);
+  update_name : (NameInput) -> (Result_13);
+  validate2_admin_collect_icp : (nat) -> (Result_8);
+  validate2_admin_set_managers : (vec principal) -> (Result_8);
   validate_admin_collect_icp : (nat) -> (Result_1);
+  validate_admin_collect_tokens : (nat) -> (Result_8);
   validate_admin_set_managers : (vec principal) -> (Result_1);
-  whoami : () -> (Result_13) query;
+  whoami : () -> (Result_16) query;
 }

src/ic_message_frontend/src/declarations/ic_panda_luckypool/ic_panda_luckypool.did

@@ -15,6 +15,11 @@ export interface AddPrizeInputV2 {
   'quantity' : number,
   'expire' : number,
 }
+export interface Airdrop {
+  'weight' : bigint,
+  'subaccount' : [] | [string],
+  'neuron_id' : [] | [string],
+}
 export interface AirdropClaimInput {
   'recaptcha' : [] | [string],
   'challenge' : string,
@@ -47,6 +52,21 @@ export interface AirdropStateOutput {
   'claimed' : bigint,
   'claimable' : bigint,
 }
+export interface Airdrops108Output {
+  'status' : number,
+  'ledger_updated_at' : bigint,
+  'airdrops' : Array<Airdrop>,
+  'ledger_weight_total' : bigint,
+  'tokens_per_weight' : number,
+  'error' : [] | [string],
+  'neurons_hash' : string,
+  'neurons_airdropped' : boolean,
+  'ledger_hash' : string,
+  'tokens_distributed' : bigint,
+  'neurons_weight_total' : bigint,
+  'neurons_updated_at' : bigint,
+  'ledger_airdropped' : boolean,
+}
 export interface CaptchaOutput { 'challenge' : string, 'img_base64' : string }
 export interface ClaimPrizeInput {
   'challenge' : Uint8Array | number[],
@@ -114,29 +134,35 @@ export type Result = { 'Ok' : PrizeOutput } |
   { 'Err' : string };
 export type Result_1 = { 'Ok' : null } |
   { 'Err' : string };
-export type Result_10 = { 'Ok' : NameOutput } |
+export type Result_10 = { 'Ok' : bigint } |
+  { 'Err' : string };
+export type Result_11 = { 'Ok' : [] | [NameOutput] } |
+  { 'Err' : null };
+export type Result_12 = { 'Ok' : Principal } |
+  { 'Err' : string };
+export type Result_13 = { 'Ok' : NameOutput } |
   { 'Err' : string };
-export type Result_11 = { 'Ok' : State } |
+export type Result_14 = { 'Ok' : State } |
   { 'Err' : null };
-export type Result_12 = { 'Ok' : bigint } |
+export type Result_15 = { 'Ok' : bigint } |
   { 'Err' : string };
-export type Result_13 = { 'Ok' : Principal } |
+export type Result_16 = { 'Ok' : Principal } |
   { 'Err' : null };
 export type Result_2 = { 'Ok' : AirdropStateOutput } |
   { 'Err' : string };
 export type Result_3 = { 'Ok' : AirdropStateOutput } |
   { 'Err' : null };
-export type Result_4 = { 'Ok' : CaptchaOutput } |
+export type Result_4 = { 'Ok' : Airdrops108Output } |
+  { 'Err' : null };
+export type Result_5 = { 'Ok' : CaptchaOutput } |
   { 'Err' : string };
-export type Result_5 = { 'Ok' : ClaimPrizeOutput } |
+export type Result_6 = { 'Ok' : ClaimPrizeOutput } |
   { 'Err' : string };
-export type Result_6 = { 'Ok' : LuckyDrawOutput } |
+export type Result_7 = { 'Ok' : LuckyDrawOutput } |
   { 'Err' : string };
-export type Result_7 = { 'Ok' : string } |
+export type Result_8 = { 'Ok' : string } |
   { 'Err' : string };
-export type Result_8 = { 'Ok' : [] | [NameOutput] } |
-  { 'Err' : null };
-export type Result_9 = { 'Ok' : Principal } |
+export type Result_9 = { 'Ok' : boolean } |
   { 'Err' : string };
 export interface State {
   'latest_luckydraw_logs' : Array<LuckyDrawLog>,
@@ -159,6 +185,7 @@ export interface State {
 export interface _SERVICE {
   'add_prize' : ActorMethod<[AddPrizeInputV2], Result>,
   'admin_collect_icp' : ActorMethod<[bigint], Result_1>,
+  'admin_collect_tokens' : ActorMethod<[bigint], Result_1>,
   'admin_set_managers' : ActorMethod<[Array<Principal>], Result_1>,
   'airdrop' : ActorMethod<[AirdropClaimInput], Result_2>,
   'airdrop_codes_of' : ActorMethod<[Principal], Array<AirdropCodeOutput>>,
@@ -167,27 +194,37 @@ export interface _SERVICE {
     Array<AirdropLog>
   >,
   'airdrop_state_of' : ActorMethod<[[] | [Principal]], Result_3>,
+  'airdrops108_of' : ActorMethod<[[] | [Principal]], Result_4>,
   'api_version' : ActorMethod<[], number>,
-  'captcha' : ActorMethod<[], Result_4>,
-  'claim_prize' : ActorMethod<[ClaimPrizeInput], Result_5>,
+  'captcha' : ActorMethod<[], Result_5>,
+  'claim_prize' : ActorMethod<[ClaimPrizeInput], Result_6>,
   'harvest' : ActorMethod<[AirdropHarvestInput], Result_2>,
-  'luckydraw' : ActorMethod<[LuckyDrawInput], Result_6>,
+  'luckydraw' : ActorMethod<[LuckyDrawInput], Result_7>,
   'luckydraw_logs' : ActorMethod<
     [[] | [bigint], [] | [bigint]],
     Array<LuckyDrawLog>
   >,
   'manager_add_notification' : ActorMethod<[Notification], Result_1>,
-  'manager_add_prize' : ActorMethod<[AddPrizeInput], Result_7>,
-  'manager_add_prize_v2' : ActorMethod<[AddPrizeInputV2], Result_7>,
+  'manager_add_prize' : ActorMethod<[AddPrizeInput], Result_8>,
+  'manager_add_prize_v2' : ActorMethod<[AddPrizeInputV2], Result_8>,
   'manager_ban_users' : ActorMethod<[Array<Principal>], Result_1>,
-  'manager_get_airdrop_key' : ActorMethod<[], Result_7>,
+  'manager_get_airdrop_key' : ActorMethod<[], Result_8>,
   'manager_remove_notifications' : ActorMethod<
     [Uint8Array | number[]],
     Result_1
   >,
   'manager_set_challenge_pub_key' : ActorMethod<[string], Result_1>,
+  'manager_start_airdrops108' : ActorMethod<[], Result_9>,
   'manager_update_airdrop_amount' : ActorMethod<[bigint], Result_1>,
   'manager_update_airdrop_balance' : ActorMethod<[bigint], Result_1>,
+  'manager_update_airdrops108_ledger_list' : ActorMethod<
+    [Uint8Array | number[]],
+    Result_10
+  >,
+  'manager_update_airdrops108_neurons_list' : ActorMethod<
+    [Uint8Array | number[]],
+    Result_10
+  >,
   'manager_update_prize_subsidy' : ActorMethod<
     [[] | [[bigint, number, number, number, number, number]]],
     Result_1
@@ -196,10 +233,10 @@ export interface _SERVICE {
     [[] | [bigint], [] | [bigint]],
     Array<LuckyDrawLog>
   >,
-  'name_lookup' : ActorMethod<[string], Result_8>,
-  'name_of' : ActorMethod<[[] | [Principal]], Result_8>,
+  'name_lookup' : ActorMethod<[string], Result_11>,
+  'name_of' : ActorMethod<[[] | [Principal]], Result_11>,
   'notifications' : ActorMethod<[], Array<Notification>>,
-  'principal_by_luckycode' : ActorMethod<[string], Result_9>,
+  'principal_by_luckycode' : ActorMethod<[string], Result_12>,
   'prize' : ActorMethod<[string], Result_2>,
   'prize_claim_logs' : ActorMethod<
     [Principal, [] | [bigint], [] | [bigint]],
@@ -215,15 +252,16 @@ export interface _SERVICE {
     [[] | [Principal]],
     Array<[number, number, number, number, number, number]>
   >,
-  'register_name' : ActorMethod<[NameInput], Result_10>,
-  'state' : ActorMethod<[], Result_11>,
-  'unregister_name' : ActorMethod<[NameInput], Result_12>,
-  'update_name' : ActorMethod<[NameInput], Result_10>,
-  'validate2_admin_collect_icp' : ActorMethod<[bigint], Result_7>,
-  'validate2_admin_set_managers' : ActorMethod<[Array<Principal>], Result_7>,
+  'register_name' : ActorMethod<[NameInput], Result_13>,
+  'state' : ActorMethod<[], Result_14>,
+  'unregister_name' : ActorMethod<[NameInput], Result_15>,
+  'update_name' : ActorMethod<[NameInput], Result_13>,
+  'validate2_admin_collect_icp' : ActorMethod<[bigint], Result_8>,
+  'validate2_admin_set_managers' : ActorMethod<[Array<Principal>], Result_8>,
   'validate_admin_collect_icp' : ActorMethod<[bigint], Result_1>,
+  'validate_admin_collect_tokens' : ActorMethod<[bigint], Result_8>,
   'validate_admin_set_managers' : ActorMethod<[Array<Principal>], Result_1>,
-  'whoami' : ActorMethod<[], Result_13>,
+  'whoami' : ActorMethod<[], Result_16>,
 }
 export declare const idlFactory: IDL.InterfaceFactory;
 export declare const init: (args: { IDL: typeof IDL }) => IDL.Type[];