@dfinity/sns 0.0.3 → 0.0.4-next-2022-09-23

package/dist/candid/sns_root.d.ts

@@ -1,4 +1,6 @@
+import type { ActorMethod } from "@dfinity/agent";
 import type { Principal } from "@dfinity/principal";
+
 export interface CanisterCallError {
   code: [] | [number];
   description: string;
@@ -10,18 +12,18 @@ export interface CanisterStatusResult {
   controller: Principal;
   status: CanisterStatusType;
   memory_size: bigint;
-  module_hash: [] | [Array<number>];
+  module_hash: [] | [Uint8Array];
 }
 export interface CanisterStatusResultV2 {
   controller: Principal;
   status: CanisterStatusType_1;
   freezing_threshold: bigint;
-  balance: Array<[Array<number>, bigint]>;
+  balance: Array<[Uint8Array, bigint]>;
   memory_size: bigint;
   cycles: bigint;
   settings: DefiniteCanisterSettingsArgs;
   idle_cycles_burned_per_day: bigint;
-  module_hash: [] | [Array<number>];
+  module_hash: [] | [Uint8Array];
 }
 export type CanisterStatusType =
   | { stopped: null }
@@ -83,14 +85,16 @@ export interface SnsRootCanister {
   ledger_canister_id: [] | [Principal];
 }
 export interface _SERVICE {
-  canister_status: (arg_0: CanisterIdRecord) => Promise<CanisterStatusResult>;
-  get_build_metadata: () => Promise<string>;
-  get_sns_canisters_summary: (
-    arg_0: GetSnsCanistersSummaryRequest
-  ) => Promise<GetSnsCanistersSummaryResponse>;
-  list_sns_canisters: (arg_0: {}) => Promise<ListSnsCanistersResponse>;
-  register_dapp_canister: (arg_0: RegisterDappCanisterRequest) => Promise<{}>;
-  set_dapp_controllers: (
-    arg_0: SetDappControllersRequest
-  ) => Promise<SetDappControllersResponse>;
+  canister_status: ActorMethod<[CanisterIdRecord], CanisterStatusResult>;
+  get_build_metadata: ActorMethod<[], string>;
+  get_sns_canisters_summary: ActorMethod<
+    [GetSnsCanistersSummaryRequest],
+    GetSnsCanistersSummaryResponse
+  >;
+  list_sns_canisters: ActorMethod<[{}], ListSnsCanistersResponse>;
+  register_dapp_canister: ActorMethod<[RegisterDappCanisterRequest], {}>;
+  set_dapp_controllers: ActorMethod<
+    [SetDappControllersRequest],
+    SetDappControllersResponse
+  >;
 }

package/dist/candid/sns_swap.certified.idl.js

@@ -2,25 +2,34 @@
 export const idlFactory = ({ IDL }) => {
   const Init = IDL.Record({
     'sns_root_canister_id' : IDL.Text,
-    'min_participant_icp_e8s' : IDL.Nat64,
     'fallback_controller_principal_ids' : IDL.Vec(IDL.Text),
-    'max_icp_e8s' : IDL.Nat64,
-    'min_participants' : IDL.Nat32,
     'nns_governance_canister_id' : IDL.Text,
     'icp_ledger_canister_id' : IDL.Text,
     'sns_ledger_canister_id' : IDL.Text,
-    'max_participant_icp_e8s' : IDL.Nat64,
     'sns_governance_canister_id' : IDL.Text,
-    'min_icp_e8s' : IDL.Nat64,
   });
   const ErrorRefundIcpRequest = IDL.Record({
     'icp_e8s' : IDL.Nat64,
     'fee_override_e8s' : IDL.Nat64,
   });
+  const GovernanceError = IDL.Record({
+    'error_message' : IDL.Text,
+    'error_type' : IDL.Int32,
+  });
+  const Response = IDL.Record({
+    'governance_error' : IDL.Opt(GovernanceError),
+  });
   const CanisterCallError = IDL.Record({
     'code' : IDL.Opt(IDL.Int32),
     'description' : IDL.Text,
   });
+  const Possibility = IDL.Variant({
+    'Ok' : Response,
+    'Err' : CanisterCallError,
+  });
+  const SettleCommunityFundParticipationResult = IDL.Record({
+    'possibility' : IDL.Opt(Possibility),
+  });
   const FailedUpdate = IDL.Record({
     'err' : IDL.Opt(CanisterCallError),
     'dapp_canister_id' : IDL.Opt(IDL.Principal),
@@ -28,16 +37,16 @@ export const idlFactory = ({ IDL }) => {
   const SetDappControllersResponse = IDL.Record({
     'failed_updates' : IDL.Vec(FailedUpdate),
   });
-  const Possibility = IDL.Variant({
+  const Possibility_1 = IDL.Variant({
     'Ok' : SetDappControllersResponse,
     'Err' : CanisterCallError,
   });
   const SetDappControllersCallResult = IDL.Record({
-    'possibility' : IDL.Opt(Possibility),
+    'possibility' : IDL.Opt(Possibility_1),
   });
-  const Possibility_1 = IDL.Variant({ 'Err' : CanisterCallError });
+  const Possibility_2 = IDL.Variant({ 'Err' : CanisterCallError });
   const SetModeCallResult = IDL.Record({
-    'possibility' : IDL.Opt(Possibility_1),
+    'possibility' : IDL.Opt(Possibility_2),
   });
   const SweepResult = IDL.Record({
     'failure' : IDL.Nat32,
@@ -45,6 +54,9 @@ export const idlFactory = ({ IDL }) => {
     'success' : IDL.Nat32,
   });
   const FinalizeSwapResponse = IDL.Record({
+    'settle_community_fund_participation_result' : IDL.Opt(
+      SettleCommunityFundParticipationResult
+    ),
     'set_dapp_controllers_result' : IDL.Opt(SetDappControllersCallResult),
     'sns_governance_normal_mode_enabled' : IDL.Opt(SetModeCallResult),
     'sweep_icp' : IDL.Opt(SweepResult),
@@ -54,12 +66,12 @@ export const idlFactory = ({ IDL }) => {
   const GetBuyerStateRequest = IDL.Record({
     'principal_id' : IDL.Opt(IDL.Principal),
   });
-  const BuyerState = IDL.Record({
-    'icp_disbursing' : IDL.Bool,
-    'amount_sns_e8s' : IDL.Nat64,
-    'amount_icp_e8s' : IDL.Nat64,
-    'sns_disbursing' : IDL.Bool,
+  const TransferableAmount = IDL.Record({
+    'transfer_start_timestamp_seconds' : IDL.Nat64,
+    'amount_e8s' : IDL.Nat64,
+    'transfer_success_timestamp_seconds' : IDL.Nat64,
   });
+  const BuyerState = IDL.Record({ 'icp' : IDL.Opt(TransferableAmount) });
   const GetBuyerStateResponse = IDL.Record({
     'buyer_state' : IDL.Opt(BuyerState),
   });
@@ -87,17 +99,45 @@ export const idlFactory = ({ IDL }) => {
     'idle_cycles_burned_per_day' : IDL.Nat,
     'module_hash' : IDL.Opt(IDL.Vec(IDL.Nat8)),
   });
-  const TimeWindow = IDL.Record({
-    'start_timestamp_seconds' : IDL.Nat64,
-    'end_timestamp_seconds' : IDL.Nat64,
+  const CfInvestment = IDL.Record({
+    'hotkey_principal' : IDL.Text,
+    'nns_neuron_id' : IDL.Nat64,
+  });
+  const DirectInvestment = IDL.Record({ 'buyer_principal' : IDL.Text });
+  const Investor = IDL.Variant({
+    'CommunityFund' : CfInvestment,
+    'Direct' : DirectInvestment,
+  });
+  const SnsNeuronRecipe = IDL.Record({
+    'sns' : IDL.Opt(TransferableAmount),
+    'investor' : IDL.Opt(Investor),
   });
-  const State = IDL.Record({
-    'open_time_window' : IDL.Opt(TimeWindow),
+  const CfNeuron = IDL.Record({
+    'nns_neuron_id' : IDL.Nat64,
+    'amount_icp_e8s' : IDL.Nat64,
+  });
+  const CfParticipant = IDL.Record({
+    'hotkey_principal' : IDL.Text,
+    'cf_neurons' : IDL.Vec(CfNeuron),
+  });
+  const Params = IDL.Record({
+    'min_participant_icp_e8s' : IDL.Nat64,
+    'max_icp_e8s' : IDL.Nat64,
+    'swap_due_timestamp_seconds' : IDL.Nat64,
+    'min_participants' : IDL.Nat32,
     'sns_token_e8s' : IDL.Nat64,
+    'max_participant_icp_e8s' : IDL.Nat64,
+    'min_icp_e8s' : IDL.Nat64,
+  });
+  const Swap = IDL.Record({
+    'neuron_recipes' : IDL.Vec(SnsNeuronRecipe),
+    'cf_participants' : IDL.Vec(CfParticipant),
+    'init' : IDL.Opt(Init),
     'lifecycle' : IDL.Int32,
     'buyers' : IDL.Vec(IDL.Tuple(IDL.Text, BuyerState)),
+    'params' : IDL.Opt(Params),
+    'open_sns_token_swap_proposal_id' : IDL.Opt(IDL.Nat64),
   });
-  const Swap = IDL.Record({ 'init' : IDL.Opt(Init), 'state' : IDL.Opt(State) });
   const DerivedState = IDL.Record({
     'sns_tokens_per_icp' : IDL.Float32,
     'buyer_total_icp_e8s' : IDL.Nat64,
@@ -106,9 +146,15 @@ export const idlFactory = ({ IDL }) => {
     'swap' : IDL.Opt(Swap),
     'derived' : IDL.Opt(DerivedState),
   });
+  const OpenRequest = IDL.Record({
+    'cf_participants' : IDL.Vec(CfParticipant),
+    'params' : IDL.Opt(Params),
+    'open_sns_token_swap_proposal_id' : IDL.Opt(IDL.Nat64),
+  });
   const RefreshBuyerTokensRequest = IDL.Record({ 'buyer' : IDL.Text });
-  const SetOpenTimeWindowRequest = IDL.Record({
-    'open_time_window' : IDL.Opt(TimeWindow),
+  const RefreshBuyerTokensResponse = IDL.Record({
+    'icp_accepted_participation_e8s' : IDL.Nat64,
+    'icp_ledger_account_balance_e8s' : IDL.Nat64,
   });
   return IDL.Service({
     'error_refund_icp' : IDL.Func(
@@ -133,15 +179,10 @@ export const idlFactory = ({ IDL }) => {
         [],
       ),
     'get_state' : IDL.Func([IDL.Record({})], [GetStateResponse], []),
+    'open' : IDL.Func([OpenRequest], [IDL.Record({})], []),
     'refresh_buyer_tokens' : IDL.Func(
         [RefreshBuyerTokensRequest],
-        [IDL.Record({})],
-        [],
-      ),
-    'refresh_sns_tokens' : IDL.Func([IDL.Record({})], [IDL.Record({})], []),
-    'set_open_time_window' : IDL.Func(
-        [SetOpenTimeWindowRequest],
-        [IDL.Record({})],
+        [RefreshBuyerTokensResponse],
         [],
       ),
   });
@@ -149,16 +190,11 @@ export const idlFactory = ({ IDL }) => {
 export const init = ({ IDL }) => {
   const Init = IDL.Record({
     'sns_root_canister_id' : IDL.Text,
-    'min_participant_icp_e8s' : IDL.Nat64,
     'fallback_controller_principal_ids' : IDL.Vec(IDL.Text),
-    'max_icp_e8s' : IDL.Nat64,
-    'min_participants' : IDL.Nat32,
     'nns_governance_canister_id' : IDL.Text,
     'icp_ledger_canister_id' : IDL.Text,
     'sns_ledger_canister_id' : IDL.Text,
-    'max_participant_icp_e8s' : IDL.Nat64,
     'sns_governance_canister_id' : IDL.Text,
-    'min_icp_e8s' : IDL.Nat64,
   });
   return [Init];
 };

package/dist/candid/sns_swap.d.ts

@@ -1,9 +1,8 @@
+import type { ActorMethod } from "@dfinity/agent";
 import type { Principal } from "@dfinity/principal";
+
 export interface BuyerState {
-  icp_disbursing: boolean;
-  amount_sns_e8s: bigint;
-  amount_icp_e8s: bigint;
-  sns_disbursing: boolean;
+  icp: [] | [TransferableAmount];
 }
 export interface CanisterCallError {
   code: [] | [number];
@@ -13,17 +12,29 @@ export interface CanisterStatusResultV2 {
   controller: Principal;
   status: CanisterStatusType;
   freezing_threshold: bigint;
-  balance: Array<[Array<number>, bigint]>;
+  balance: Array<[Uint8Array, bigint]>;
   memory_size: bigint;
   cycles: bigint;
   settings: DefiniteCanisterSettingsArgs;
   idle_cycles_burned_per_day: bigint;
-  module_hash: [] | [Array<number>];
+  module_hash: [] | [Uint8Array];
 }
 export type CanisterStatusType =
   | { stopped: null }
   | { stopping: null }
   | { running: null };
+export interface CfInvestment {
+  hotkey_principal: string;
+  nns_neuron_id: bigint;
+}
+export interface CfNeuron {
+  nns_neuron_id: bigint;
+  amount_icp_e8s: bigint;
+}
+export interface CfParticipant {
+  hotkey_principal: string;
+  cf_neurons: Array<CfNeuron>;
+}
 export interface DefiniteCanisterSettingsArgs {
   controller: Principal;
   freezing_threshold: bigint;
@@ -35,6 +46,9 @@ export interface DerivedState {
   sns_tokens_per_icp: number;
   buyer_total_icp_e8s: bigint;
 }
+export interface DirectInvestment {
+  buyer_principal: string;
+}
 export interface ErrorRefundIcpRequest {
   icp_e8s: bigint;
   fee_override_e8s: bigint;
@@ -44,6 +58,9 @@ export interface FailedUpdate {
   dapp_canister_id: [] | [Principal];
 }
 export interface FinalizeSwapResponse {
+  settle_community_fund_participation_result:
+    | []
+    | [SettleCommunityFundParticipationResult];
   set_dapp_controllers_result: [] | [SetDappControllersCallResult];
   sns_governance_normal_mode_enabled: [] | [SetModeCallResult];
   sweep_icp: [] | [SweepResult];
@@ -63,67 +80,95 @@ export interface GetStateResponse {
   swap: [] | [Swap];
   derived: [] | [DerivedState];
 }
+export interface GovernanceError {
+  error_message: string;
+  error_type: number;
+}
 export interface Init {
   sns_root_canister_id: string;
-  min_participant_icp_e8s: bigint;
   fallback_controller_principal_ids: Array<string>;
-  max_icp_e8s: bigint;
-  min_participants: number;
   nns_governance_canister_id: string;
   icp_ledger_canister_id: string;
   sns_ledger_canister_id: string;
-  max_participant_icp_e8s: bigint;
   sns_governance_canister_id: string;
+}
+export type Investor =
+  | { CommunityFund: CfInvestment }
+  | { Direct: DirectInvestment };
+export interface OpenRequest {
+  cf_participants: Array<CfParticipant>;
+  params: [] | [Params];
+  open_sns_token_swap_proposal_id: [] | [bigint];
+}
+export interface Params {
+  min_participant_icp_e8s: bigint;
+  max_icp_e8s: bigint;
+  swap_due_timestamp_seconds: bigint;
+  min_participants: number;
+  sns_token_e8s: bigint;
+  max_participant_icp_e8s: bigint;
   min_icp_e8s: bigint;
 }
-export type Possibility =
+export type Possibility = { Ok: Response } | { Err: CanisterCallError };
+export type Possibility_1 =
   | { Ok: SetDappControllersResponse }
   | { Err: CanisterCallError };
-export type Possibility_1 = { Err: CanisterCallError };
+export type Possibility_2 = { Err: CanisterCallError };
 export interface RefreshBuyerTokensRequest {
   buyer: string;
 }
+export interface RefreshBuyerTokensResponse {
+  icp_accepted_participation_e8s: bigint;
+  icp_ledger_account_balance_e8s: bigint;
+}
+export interface Response {
+  governance_error: [] | [GovernanceError];
+}
 export interface SetDappControllersCallResult {
-  possibility: [] | [Possibility];
+  possibility: [] | [Possibility_1];
 }
 export interface SetDappControllersResponse {
   failed_updates: Array<FailedUpdate>;
 }
 export interface SetModeCallResult {
-  possibility: [] | [Possibility_1];
+  possibility: [] | [Possibility_2];
 }
-export interface SetOpenTimeWindowRequest {
-  open_time_window: [] | [TimeWindow];
+export interface SettleCommunityFundParticipationResult {
+  possibility: [] | [Possibility];
 }
-export interface State {
-  open_time_window: [] | [TimeWindow];
-  sns_token_e8s: bigint;
-  lifecycle: number;
-  buyers: Array<[string, BuyerState]>;
+export interface SnsNeuronRecipe {
+  sns: [] | [TransferableAmount];
+  investor: [] | [Investor];
 }
 export interface Swap {
+  neuron_recipes: Array<SnsNeuronRecipe>;
+  cf_participants: Array<CfParticipant>;
   init: [] | [Init];
-  state: [] | [State];
+  lifecycle: number;
+  buyers: Array<[string, BuyerState]>;
+  params: [] | [Params];
+  open_sns_token_swap_proposal_id: [] | [bigint];
 }
 export interface SweepResult {
   failure: number;
   skipped: number;
   success: number;
 }
-export interface TimeWindow {
-  start_timestamp_seconds: bigint;
-  end_timestamp_seconds: bigint;
+export interface TransferableAmount {
+  transfer_start_timestamp_seconds: bigint;
+  amount_e8s: bigint;
+  transfer_success_timestamp_seconds: bigint;
 }
 export interface _SERVICE {
-  error_refund_icp: (arg_0: ErrorRefundIcpRequest) => Promise<{}>;
-  finalize_swap: (arg_0: {}) => Promise<FinalizeSwapResponse>;
-  get_buyer_state: (
-    arg_0: GetBuyerStateRequest
-  ) => Promise<GetBuyerStateResponse>;
-  get_buyers_total: (arg_0: {}) => Promise<GetBuyersTotalResponse>;
-  get_canister_status: (arg_0: {}) => Promise<CanisterStatusResultV2>;
-  get_state: (arg_0: {}) => Promise<GetStateResponse>;
-  refresh_buyer_tokens: (arg_0: RefreshBuyerTokensRequest) => Promise<{}>;
-  refresh_sns_tokens: (arg_0: {}) => Promise<{}>;
-  set_open_time_window: (arg_0: SetOpenTimeWindowRequest) => Promise<{}>;
+  error_refund_icp: ActorMethod<[ErrorRefundIcpRequest], {}>;
+  finalize_swap: ActorMethod<[{}], FinalizeSwapResponse>;
+  get_buyer_state: ActorMethod<[GetBuyerStateRequest], GetBuyerStateResponse>;
+  get_buyers_total: ActorMethod<[{}], GetBuyersTotalResponse>;
+  get_canister_status: ActorMethod<[{}], CanisterStatusResultV2>;
+  get_state: ActorMethod<[{}], GetStateResponse>;
+  open: ActorMethod<[OpenRequest], {}>;
+  refresh_buyer_tokens: ActorMethod<
+    [RefreshBuyerTokensRequest],
+    RefreshBuyerTokensResponse
+  >;
 }

package/dist/candid/sns_swap.did

@@ -1,10 +1,5 @@
-// Generated from IC repo commit 518271451cf8901c77c986e007e2c4762d1fc948 'rs/sns/swap/canister/swap.did' by import-candid
-type BuyerState = record {
-  icp_disbursing : bool;
-  amount_sns_e8s : nat64;
-  amount_icp_e8s : nat64;
-  sns_disbursing : bool;
-};
+// Generated from IC repo commit fb28a950f1799dec4a67cc21abd3888686ab50d9 'rs/sns/swap/canister/swap.did' by import-candid
+type BuyerState = record { icp : opt TransferableAmount };
 type CanisterCallError = record { code : opt int32; description : text };
 type CanisterStatusResultV2 = record {
   controller : principal;
@@ -18,6 +13,12 @@ type CanisterStatusResultV2 = record {
   module_hash : opt vec nat8;
 };
 type CanisterStatusType = variant { stopped; stopping; running };
+type CfInvestment = record { hotkey_principal : text; nns_neuron_id : nat64 };
+type CfNeuron = record { nns_neuron_id : nat64; amount_icp_e8s : nat64 };
+type CfParticipant = record {
+  hotkey_principal : text;
+  cf_neurons : vec CfNeuron;
+};
 type DefiniteCanisterSettingsArgs = record {
   controller : principal;
   freezing_threshold : nat;
@@ -29,6 +30,7 @@ type DerivedState = record {
   sns_tokens_per_icp : float32;
   buyer_total_icp_e8s : nat64;
 };
+type DirectInvestment = record { buyer_principal : text };
 type ErrorRefundIcpRequest = record {
   icp_e8s : nat64;
   fee_override_e8s : nat64;
@@ -38,6 +40,7 @@ type FailedUpdate = record {
   dapp_canister_id : opt principal;
 };
 type FinalizeSwapResponse = record {
+  settle_community_fund_participation_result : opt SettleCommunityFundParticipationResult;
   set_dapp_controllers_result : opt SetDappControllersCallResult;
   sns_governance_normal_mode_enabled : opt SetModeCallResult;
   sweep_icp : opt SweepResult;
@@ -48,40 +51,69 @@ type GetBuyerStateRequest = record { principal_id : opt principal };
 type GetBuyerStateResponse = record { buyer_state : opt BuyerState };
 type GetBuyersTotalResponse = record { buyers_total : nat64 };
 type GetStateResponse = record { swap : opt Swap; derived : opt DerivedState };
+type GovernanceError = record { error_message : text; error_type : int32 };
 type Init = record {
   sns_root_canister_id : text;
-  min_participant_icp_e8s : nat64;
   fallback_controller_principal_ids : vec text;
-  max_icp_e8s : nat64;
-  min_participants : nat32;
   nns_governance_canister_id : text;
   icp_ledger_canister_id : text;
   sns_ledger_canister_id : text;
-  max_participant_icp_e8s : nat64;
   sns_governance_canister_id : text;
+};
+type Investor = variant {
+  CommunityFund : CfInvestment;
+  Direct : DirectInvestment;
+};
+type OpenRequest = record {
+  cf_participants : vec CfParticipant;
+  params : opt Params;
+  open_sns_token_swap_proposal_id : opt nat64;
+};
+type Params = record {
+  min_participant_icp_e8s : nat64;
+  max_icp_e8s : nat64;
+  swap_due_timestamp_seconds : nat64;
+  min_participants : nat32;
+  sns_token_e8s : nat64;
+  max_participant_icp_e8s : nat64;
   min_icp_e8s : nat64;
 };
-type Possibility = variant {
+type Possibility = variant { Ok : Response; Err : CanisterCallError };
+type Possibility_1 = variant {
   Ok : SetDappControllersResponse;
   Err : CanisterCallError;
 };
-type Possibility_1 = variant { Err : CanisterCallError };
+type Possibility_2 = variant { Err : CanisterCallError };
 type RefreshBuyerTokensRequest = record { buyer : text };
-type SetDappControllersCallResult = record { possibility : opt Possibility };
+type RefreshBuyerTokensResponse = record {
+  icp_accepted_participation_e8s : nat64;
+  icp_ledger_account_balance_e8s : nat64;
+};
+type Response = record { governance_error : opt GovernanceError };
+type SetDappControllersCallResult = record { possibility : opt Possibility_1 };
 type SetDappControllersResponse = record { failed_updates : vec FailedUpdate };
-type SetModeCallResult = record { possibility : opt Possibility_1 };
-type SetOpenTimeWindowRequest = record { open_time_window : opt TimeWindow };
-type State = record {
-  open_time_window : opt TimeWindow;
-  sns_token_e8s : nat64;
+type SetModeCallResult = record { possibility : opt Possibility_2 };
+type SettleCommunityFundParticipationResult = record {
+  possibility : opt Possibility;
+};
+type SnsNeuronRecipe = record {
+  sns : opt TransferableAmount;
+  investor : opt Investor;
+};
+type Swap = record {
+  neuron_recipes : vec SnsNeuronRecipe;
+  cf_participants : vec CfParticipant;
+  init : opt Init;
   lifecycle : int32;
   buyers : vec record { text; BuyerState };
+  params : opt Params;
+  open_sns_token_swap_proposal_id : opt nat64;
 };
-type Swap = record { init : opt Init; state : opt State };
 type SweepResult = record { failure : nat32; skipped : nat32; success : nat32 };
-type TimeWindow = record {
-  start_timestamp_seconds : nat64;
-  end_timestamp_seconds : nat64;
+type TransferableAmount = record {
+  transfer_start_timestamp_seconds : nat64;
+  amount_e8s : nat64;
+  transfer_success_timestamp_seconds : nat64;
 };
 service : (Init) -> {
   error_refund_icp : (ErrorRefundIcpRequest) -> (record {});
@@ -90,7 +122,8 @@ service : (Init) -> {
   get_buyers_total : (record {}) -> (GetBuyersTotalResponse);
   get_canister_status : (record {}) -> (CanisterStatusResultV2);
   get_state : (record {}) -> (GetStateResponse) query;
-  refresh_buyer_tokens : (RefreshBuyerTokensRequest) -> (record {});
-  refresh_sns_tokens : (record {}) -> (record {});
-  set_open_time_window : (SetOpenTimeWindowRequest) -> (record {});
+  open : (OpenRequest) -> (record {});
+  refresh_buyer_tokens : (RefreshBuyerTokensRequest) -> (
+      RefreshBuyerTokensResponse,
+    );
 }