zano_web3 10.1.0 → 10.2.0

package/web/src/types/responses/companion-methods/accept-ionic-swap/index.ts

@@ -0,0 +1,33 @@
+import z from "zod";
+
+export const acceptIonicSwapCompanionResponseSchema = z.union([
+    z.object({
+        data: z.union([
+            z.object({
+                result: z.object({
+                    result_tx_id: z.string(),
+                })
+            }),
+            z.object({
+                error: z.object({
+                    code: z.number().optional(),
+                })
+            })
+        ]),
+    }),
+    z.object({
+        error: z.string(),
+    })
+]);
+
+export type AcceptIonicSwapCompanionResponse = z.infer<typeof acceptIonicSwapCompanionResponseSchema>;
+
+export type AcceptIonicSwapResponse = {
+    success: true;
+    data: {
+        result_tx_id: string;
+    }
+} | {
+    success: false;
+    error: string;
+}

package/web/src/types/responses/companion-methods/add-whitelist-asset/index.ts

@@ -0,0 +1,53 @@
+import z from "zod";
+
+const addWhitelistAssetCompanionResponseAssetSchema = z.object({
+    current_supply: z.union([z.string(), z.number()]),
+    decimal_point: z.number(),
+    full_name: z.string(),
+    hidden_supply: z.boolean(),
+    meta_info: z.string(),
+    owner: z.string(),
+    owner_eth_pub_key: z.string(),
+    ticker: z.string(),
+    total_max_supply: z.union([z.string(), z.number()])
+});
+
+export type AddWhitelistAssetResponseAsset = z.infer<typeof addWhitelistAssetCompanionResponseAssetSchema>;
+
+export const addWhitelistAssetCompanionResponseSchema = z.union([
+    z.object({
+        data: z.union([
+            z.object({
+                result: z.union([
+                    z.object({
+                        asset_descriptor: addWhitelistAssetCompanionResponseAssetSchema,
+                        status: z.literal('OK'),
+                    }),
+                    z.object({
+                        status: z.string().refine((value) => value !== 'OK', {
+                            message: 'Status must not be OK',
+                        }),
+                    })
+                ])
+            }),
+            z.object({
+                error: z.object({
+                    code: z.number().optional(),
+                })
+            })
+        ])
+    }),
+    z.object({
+        error: z.string(),
+    })
+]);
+
+export type AddWhitelistAssetCompanionResponse = z.infer<typeof addWhitelistAssetCompanionResponseSchema>;
+
+export type AddWhitelistAssetResponse = {
+    success: true;
+    data: AddWhitelistAssetResponseAsset;
+} | {
+    success: false;
+    error: string;
+}

package/web/src/types/responses/companion-methods/burn-asset/index.ts

@@ -0,0 +1,33 @@
+import z from "zod";
+
+export const burnAssetCompanionResponseScheme = z.union([
+    z.object({
+        data: z.union([
+            z.object({
+                result: z.object({
+                    tx_id: z.string(),
+                })
+            }),
+            z.object({
+                error: z.object({
+                    code: z.number().optional(),
+                })
+            })
+        ]),
+    }),
+    z.object({
+        error: z.string(),
+    })
+]);
+
+export type BurnAssetCompanionResponse = z.infer<typeof burnAssetCompanionResponseScheme>;
+
+export type BurnAssetResponse = {
+    success: true;
+    data: {
+        tx_id: string;
+    }
+} | {
+    success: false;
+    error: string;
+}

package/web/src/types/responses/companion-methods/create-alias/index.ts

@@ -2,7 +2,18 @@ import z from 'zod';
 
 export const createAliasCompanionResponseSchema = z.union([
     z.object({
-        data: z.literal(true),
+        data: z.object({
+            result: z.object({
+                tx_id: z.string(),
+            })
+        }),
+    }),
+     z.object({
+        data: z.object({
+            error: z.object({
+                code: z.number().optional(),
+            })
+        }),
     }),
     z.object({
         error: z.string(),
@@ -13,6 +24,9 @@ export type CreateAliasCompanionResponse = z.infer<typeof createAliasCompanionRe
 
 export type CreateAliasResponse = {
     success: true;
+    data: {
+        tx_id: string;
+    };
 } | {
     success: false;
     error: string;

package/web/src/types/responses/companion-methods/get-address-by-alias/index.ts

@@ -1,7 +1,14 @@
 import z from 'zod';
 
 export const getAddressByAliasCompanionResponseSchema = z.union([
-    z.string(),
+    z.object({
+        address: z.string(),
+        comment: z.string(),
+        tracking_key: z.string(),
+    }),
+
+    // Error responses
+    z.literal(''),
     z.object({
         error: z.string(),
     })
@@ -11,7 +18,11 @@ export type GetAddressByAliasCompanionResponse = z.infer<typeof getAddressByAlia
 
 export type GetAddressByAliasResponse = {
     success: true;
-    data: string;
+    data: {
+        address: string;
+        comment: string;
+        tracking_key: string;
+    };
 } | {
     success: false;
     error: string;

package/web/src/types/responses/companion-methods/get-ionic-swap-info/index.ts

@@ -0,0 +1,45 @@
+import z from "zod";
+
+const getIonicSwapProposalInfoCompanionResponseInfoSchema = z.object({
+    proposal: z.object({
+        fee_paid_by_a: z.union([z.string(), z.number()]),
+        to_finalizer: z.array(z.object({
+            amount: z.union([z.string(), z.number()]),
+            asset_id: z.string(),
+        })),
+        to_initiator: z.array(z.object({
+            amount: z.union([z.string(), z.number()]),
+            asset_id: z.string(),
+        })),
+    }) 
+})
+
+export const getIonicSwapProposalInfoCompanionResponseSchema = z.union([
+    z.object({
+        data: z.object({
+            result: getIonicSwapProposalInfoCompanionResponseInfoSchema,
+        })
+    }),
+    z.object({
+        data: z.object({
+            error: z.object({
+                code: z.number().optional(),
+            })
+        }),
+    }),
+    z.object({
+        error: z.string(),
+    })
+]);
+
+export type GetIonicSwapProposalInfoResponseInfo = z.infer<typeof getIonicSwapProposalInfoCompanionResponseInfoSchema>;
+
+export type GetIonicSwapProposalInfoCompanionResponse = z.infer<typeof getIonicSwapProposalInfoCompanionResponseSchema>;
+
+export type GetIonicSwapProposalInfoResponse = {
+    success: true;
+    data: GetIonicSwapProposalInfoResponseInfo;
+} | {
+    success: false;
+    error: string;
+}

package/web/src/types/responses/companion-methods/get-permissions/index.ts

@@ -0,0 +1,24 @@
+import z from "zod";
+
+export const getPermissionsCompanionResponseSchema = z.union([
+    z.object({
+        data: z.array(z.enum(['general', 'balance', 'history']))
+    }),
+    z.object({
+        error: z.string(),
+    })
+]);
+
+export type GetPermissionsCompanionResponse = z.infer<typeof getPermissionsCompanionResponseSchema>;
+
+export type GetPermissionsResponsePermission = 'general' | 'balance' | 'history';
+
+export type GetPermissionsResponse = {
+    success: true;
+    data: {
+        permissions: GetPermissionsResponsePermission[];
+    };
+} | {
+    success: false;
+    error: string;
+}

package/web/src/types/responses/companion-methods/get-wallet-balance/index.ts

@@ -0,0 +1,57 @@
+import z from "zod";
+
+const getWalletBalanceCompanionResponseBalanceSchema = z.object({
+    balance: z.union([z.string(), z.number()]),
+    unlocked_balance: z.union([z.string(), z.number()]),
+    balances: z.array(z.object({
+        asset_info: z.object({
+            asset_id: z.string(),
+            current_supply: z.union([z.string(), z.number()]),
+            decimal_point: z.number(),
+            full_name: z.string(),
+            hidden_supply: z.custom<boolean>(),
+            meta_info: z.custom<string>(),
+            owner: z.custom<string>(),
+            owner_eth_pub_key: z.custom<string | undefined>(),
+            ticker: z.string(),
+            total_max_supply: z.union([z.string(), z.number()]),
+        }),
+        awaiting_in: z.custom<number | string>(),
+        awaiting_out: z.custom<number | string>(),
+        outs_amount_max: z.custom<number | string>(),
+        outs_amount_min: z.custom<number | string>(),
+        outs_count: z.custom<number | string>(),
+        total: z.union([z.string(), z.number()]),
+        unlocked: z.union([z.string(), z.number()]),
+    })),
+});
+
+export type GetWalletBalanceResponseBalance = z.infer<typeof getWalletBalanceCompanionResponseBalanceSchema>;
+
+export const getWalletBalanceCompanionResponseSchema = z.union([
+    z.object({
+        data: z.object({
+            result: getWalletBalanceCompanionResponseBalanceSchema,
+        }),
+    }),
+    z.object({
+        data: z.object({
+            error: z.object({
+                code: z.number().optional(),
+            })
+        }),
+    }),
+    z.object({
+        error: z.string(),
+    })
+]);
+
+export type GetWalletBalanceCompanionResponse = z.infer<typeof getWalletBalanceCompanionResponseSchema>;
+
+export type GetWalletBalanceResponse = {
+    success: true;
+    data: GetWalletBalanceResponseBalance;
+} | {
+    success: false;
+    error: string;
+}

package/web/src/types/responses/companion-methods/get-whitelist/index.ts

@@ -0,0 +1,30 @@
+import z from "zod";
+
+const getWhitelistCompanionResponseItemSchema = z.object({
+    asset_id: z.string(),
+    ticker: z.string(),
+    full_name: z.string(),
+    decimal_point: z.number(),
+    logo: z.string().optional(),
+});
+
+export type GetWhitelistResponseItem = z.infer<typeof getWhitelistCompanionResponseItemSchema>;
+
+export const getWhitelistCompanionResponseSchema = z.union([
+    z.object({
+        data: z.array(getWhitelistCompanionResponseItemSchema),
+    }),
+    z.object({
+        error: z.string(),
+    })
+]);
+  
+export type GetWhitelistCompanionResponse = z.infer<typeof getWhitelistCompanionResponseSchema>;
+
+export type GetWhitelistResponse = {
+    success: true;
+    data: GetWhitelistResponseItem[];
+} | {
+    success: false;
+    error: string;
+}

package/web/src/types/responses/companion-methods/index.ts

@@ -2,4 +2,13 @@ export { RequestPermissionsResponse } from './request-permissions';
 export { GetWalletDataResponse, GetWalletDataResponseWallet } from './get-wallet-data';
 export { GetAddressByAliasResponse } from './get-address-by-alias';
 export { CreateAliasResponse } from './create-alias';
-export { RequestMessageSignResponse, RequestMessageSignData } from './request-message-sign';
+export { RequestMessageSignResponse, RequestMessageSignData } from './request-message-sign';
+export { InitializeIonicSwapResponse } from './initialize-ionic-swap';
+export { AcceptIonicSwapResponse } from './accept-ionic-swap';
+export { GetPermissionsResponse, GetPermissionsResponsePermission } from './get-permissions';
+export { GetWalletBalanceResponse, GetWalletBalanceResponseBalance } from './get-wallet-balance';
+export { TransferResponse, TransferResponseInfo } from './transfer';
+export { GetIonicSwapProposalInfoResponse, GetIonicSwapProposalInfoResponseInfo } from './get-ionic-swap-info';
+export { GetWhitelistResponse, GetWhitelistResponseItem } from './get-whitelist';
+export { AddWhitelistAssetResponse, AddWhitelistAssetResponseAsset } from './add-whitelist-asset';
+export { BurnAssetResponse } from './burn-asset';

package/web/src/types/responses/companion-methods/initialize-ionic-swap/index.ts

@@ -0,0 +1,31 @@
+import z from "zod";
+
+export const initializeIonicSwapCompanionResponseSchema = z.union([
+    z.object({
+        data: z.union([
+            z.object({
+                result: z.object({
+                    hex_raw_proposal: z.string(),
+                })
+            }),
+            z.object({
+                error: z.object({
+                    code: z.number().optional(),
+                })
+            })
+        ]),
+    }),
+    z.object({
+        error: z.string(),
+    })
+]);
+
+export type InitializeIonicSwapCompanionResponse = z.infer<typeof initializeIonicSwapCompanionResponseSchema>;
+
+export type InitializeIonicSwapResponse = {
+    success: true;
+    data: string;
+} | {
+    success: false;
+    error: string;
+}

package/web/src/types/responses/companion-methods/request-message-sign/index.ts

@@ -1,11 +1,18 @@
 import z from 'zod';
 
-const requestMessageSignCompanionResponseDataSchema = z.object({
-  result: z.object({
-    pkey: z.string(),
-    sig: z.string(),
-  })
-});
+const requestMessageSignCompanionResponseDataSchema = z.union([
+    z.object({
+        result: z.object({
+            pkey: z.string(),
+            sig: z.string(),
+        })
+    }),
+    z.object({
+        error: z.object({
+            code: z.number().optional(),
+        })
+    }),
+])
 
 export const requestMessageSignCompanionResponseSchema = z.union([
     z.object({

package/web/src/types/responses/companion-methods/transfer/index.ts

@@ -0,0 +1,38 @@
+import z from "zod";
+
+const transferCompanionResponseInfoSchema = z.object({
+    tx_hash: z.string(),
+    tx_size: z.union([z.number(), z.string()]),
+    tx_unsigned_hex: z.custom<string>(),
+    used_out_ids: z.custom<number[]>(),
+});
+
+export type TransferResponseInfo = z.infer<typeof transferCompanionResponseInfoSchema>;
+
+export const transferCompanionResponseSchema = z.union([
+    z.object({
+        data: z.object({
+            result: transferCompanionResponseInfoSchema,
+        }),
+    }),
+    z.object({
+        data: z.object({
+            error: z.object({
+                code: z.number().optional(),
+            })
+        }),
+    }),
+    z.object({
+        error: z.string(),
+    })
+]);
+
+export type TransferCompanionResponse = z.infer<typeof transferCompanionResponseSchema>;
+
+export type TransferResponse = {
+    success: true;
+    data: TransferResponseInfo;
+} | {
+    success: false;
+    error: string;
+}