Implement all Tezos transactions

src/blockchain/atomexProtocolMultiChain/initiateParameters.ts

@@ -1,6 +1,7 @@
 import type { BigNumber } from 'bignumber.js';
 
 export interface AtomexProtocolMultiChainInitiateParameters {
+  readonly senderAddress: string;
   readonly amount: BigNumber;
   readonly secretHash: string;
   readonly receivingAddress: string;

src/blockchain/atomexProtocolMultiChain/redeemParameters.ts

@@ -1,3 +1,4 @@
 export interface AtomexProtocolMultiChainRedeemParameters {
-  readonly secretHash: string;
+  readonly senderAddress: string;
+  readonly secret: string;
 }

src/blockchain/atomexProtocolMultiChain/refundParameters.ts

@@ -1,3 +1,4 @@
 export interface AtomexProtocolMultiChainRefundParameters {
-  readonly secretHash: string;
+  readonly senderAddress: string;
+  readonly secret: string;
 }

src/tezos/atomexProtocol/taquitoAtomexProtocolMultiChain.ts

@@ -1,4 +1,4 @@
-import type { TezosToolkit } from '@taquito/taquito';
+import type { TezosToolkit, TransactionWalletOperation } from '@taquito/taquito';
 import BigNumber from 'bignumber.js';
 
 import type {
@@ -77,4 +77,23 @@ export abstract class TaquitoAtomexProtocolMultiChain implements AtomexProtocolM
 
     return taquitoWallet;
   }
+
+  protected async getTransaction(operation: TransactionWalletOperation): Promise<Transaction> {
+    const status = await operation.status();
+    const confirmation = await operation.confirmation();
+
+    //TODO: fill others fields
+    return {
+      id: operation.opHash,
+      currencyId: this.currencyId,
+      confirmations: confirmation.currentConfirmation,
+      status,
+      blockId: 0,
+      type: ''
+    };
+  }
+
+  protected formatDate(date: Date): string {
+    return date.toISOString().slice(0, -5) + 'Z';
+  }
 }

src/tezos/atomexProtocol/tezosTaquitoAtomexProtocolMultiChain.ts

@@ -1,3 +1,5 @@
+import type { Wallet } from '@taquito/taquito';
+
 import { atomexProtocolMultiChainHelper } from '../../blockchain/atomexProtocolMultiChain';
 import type {
   AtomexBlockchainProvider,
@@ -9,7 +11,8 @@ import type {
 import type { AtomexNetwork } from '../../common/index';
 import type { DeepReadonly } from '../../core/index';
 import type { PriceManager } from '../../exchange';
-import type { TezosTaquitoAtomexProtocolMultiChainOptions } from '../models/index';
+import type { TezosMultiChainSmartContract, TezosTaquitoAtomexProtocolMultiChainOptions } from '../models/index';
+import { mutezInTez } from '../utils';
 import { TaquitoAtomexProtocolMultiChain } from './taquitoAtomexProtocolMultiChain';
 
 export class TezosTaquitoAtomexProtocolMultiChain extends TaquitoAtomexProtocolMultiChain {
@@ -27,16 +30,31 @@ export class TezosTaquitoAtomexProtocolMultiChain extends TaquitoAtomexProtocolM
     return this.atomexProtocolOptions.currencyId;
   }
 
-  initiate(_params: AtomexProtocolMultiChainInitiateParameters): Promise<Transaction> {
-    throw new Error('Method not implemented.');
+  async initiate(params: AtomexProtocolMultiChainInitiateParameters): Promise<Transaction> {
+    const contract = await this.getSwapContract(params.senderAddress);
+    const operation = await contract.methodsObject
+      .initiate({
+        settings: {
+          hashed_secret: params.secretHash,
+          refund_time: this.formatDate(params.refundTimestamp),
+          payoff: params.rewardForRedeem.multipliedBy(mutezInTez).toNumber(),
+        },
+        participant: params.receivingAddress,
+      })
+      .send({ amount: params.amount.toNumber() });
+
+    return this.getTransaction(operation);
   }
 
   getInitiateFees(params: Partial<AtomexProtocolMultiChainInitiateParameters>): Promise<FeesInfo> {
     return super.getInitiateFees(params);
   }
 
-  redeem(_params: AtomexProtocolMultiChainRedeemParameters): Promise<Transaction> {
-    throw new Error('Method not implemented.');
+  async redeem(params: AtomexProtocolMultiChainRedeemParameters): Promise<Transaction> {
+    const contract = await this.getSwapContract(params.senderAddress);
+    const operation = await contract.methodsObject.redeem(params.secret).send();
+
+    return this.getTransaction(operation);
   }
 
   getRedeemReward(redeemFee: FeesInfo): Promise<FeesInfo> {
@@ -47,11 +65,21 @@ export class TezosTaquitoAtomexProtocolMultiChain extends TaquitoAtomexProtocolM
     return super.getRedeemFees(params);
   }
 
-  refund(_params: AtomexProtocolMultiChainRefundParameters): Promise<Transaction> {
-    throw new Error('Method not implemented.');
+  async refund(params: AtomexProtocolMultiChainRefundParameters): Promise<Transaction> {
+    const contract = await this.getSwapContract(params.senderAddress);
+    const operation = await contract.methodsObject.refund(params.secret).send();
+
+    return this.getTransaction(operation);
   }
 
   getRefundFees(params: Partial<AtomexProtocolMultiChainInitiateParameters>): Promise<FeesInfo> {
     return super.getRefundFees(params);
   }
+
+  protected async getSwapContract(address: string): Promise<TezosMultiChainSmartContract<Wallet>> {
+    const wallet = await this.getWallet(address);
+    const contract = await wallet.toolkit.wallet.at<TezosMultiChainSmartContract<Wallet>>(this.swapContractAddress);
+
+    return contract;
+  }
 }

src/tezos/config/defaultOptions.ts

@@ -42,7 +42,6 @@ const createAtomexProtocol = (
     default:
       throw new Error(`Unknown Tezos currency: ${(currency as TezosCurrency).id}`);
   }
-
 };
 
 const createCurrencyOptions = (

src/tezos/models/contracts.ts

@@ -0,0 +1,17 @@
+import type { ContractAbstraction, ContractMethod, ContractProvider, Wallet } from '@taquito/taquito';
+
+export type TezosMultiChainSmartContract<T extends ContractProvider | Wallet = ContractProvider> = ContractAbstraction<T> & {
+  methodsObject: {
+    initiate(args: {
+      settings: {
+        hashed_secret: string;
+        refund_time: string;
+        payoff: number;
+      },
+      participant: string;
+    }): ContractMethod<T>;
+
+    redeem(secret: string): ContractMethod<T>;
+    refund(secret: string): ContractMethod<T>;
+  }
+};

src/tezos/models/index.ts

@@ -6,3 +6,4 @@ export type {
   TaquitoAtomexProtocolMultiChainOptions, TezosTaquitoAtomexProtocolMultiChainOptions,
   FA12TezosTaquitoAtomexProtocolMultiChainOptions, FA2TezosTaquitoAtomexProtocolMultiChainOptions
 } from './atomexProtocolOptions';
+export type { TezosMultiChainSmartContract } from './contracts';