_ Git - ldk-java/blob - ts/structs/BaseSign.ts

   1
   2
   3 import CommonBase from './CommonBase';
   4 import * as bindings from '../bindings' // TODO: figure out location
   5
   6
   7
   8             export class BaseSign extends CommonBase {
   9
  10                 bindings_instance?: bindings.LDKBaseSign;
  11
  12                 constructor(ptr?: number, arg?: bindings.LDKBaseSign, pubkeys?: ChannelPublicKeys) {
  13                     if (Number.isFinite(ptr)) {
  14                                         super(ptr);
  15                                         this.bindings_instance = null;
  16                                     } else {
  17                                         // TODO: private constructor instantiation
  18                                         super(bindings.LDKBaseSign_new(arg, pubkeys == null ? 0 : pubkeys.clone_ptr()));
  19                                         this.ptrs_to.push(arg);
  20
  21                                     }
  22                 }
  23
  24                 protected finalize() {
  25                     if (this.ptr != 0) {
  26                         bindings.BaseSign_free(this.ptr);
  27                     }
  28                     super.finalize();
  29                 }
  30
  31                 static new_impl(arg: BaseSignInterface, pubkeys: ChannelPublicKeys): BaseSign {
  32                     const impl_holder: LDKBaseSignHolder = new LDKBaseSignHolder();
  33                     let structImplementation = <bindings.LDKBaseSign>{
  34                         // todo: in-line interface filling
  35                         get_per_commitment_point (idx: number): Uint8Array {
  36                                                         Uint8Array ret = arg.get_per_commitment_point(idx);
  37                                 result: Uint8Array = InternalUtils.check_arr_len(ret, 33);
  38                                 return result;
  39                                                 },
  40
  41                                                 release_commitment_secret (idx: number): Uint8Array {
  42                                                         Uint8Array ret = arg.release_commitment_secret(idx);
  43                                 result: Uint8Array = InternalUtils.check_arr_len(ret, 32);
  44                                 return result;
  45                                                 },
  46
  47                                                 validate_holder_commitment (holder_tx: number): number {
  48                                                         const holder_tx_hu_conv: HolderCommitmentTransaction = new HolderCommitmentTransaction(null, holder_tx);
  49                                                         Result_NoneNoneZ ret = arg.validate_holder_commitment(holder_tx_hu_conv);
  50                                 result: number = ret == null ? 0 : ret.clone_ptr();
  51                                 return result;
  52                                                 },
  53
  54                                                 channel_keys_id (): Uint8Array {
  55                                                         Uint8Array ret = arg.channel_keys_id();
  56                                 result: Uint8Array = InternalUtils.check_arr_len(ret, 32);
  57                                 return result;
  58                                                 },
  59
  60                                                 sign_counterparty_commitment (commitment_tx: number): number {
  61                                                         const commitment_tx_hu_conv: CommitmentTransaction = new CommitmentTransaction(null, commitment_tx);
  62                                                         Result_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = arg.sign_counterparty_commitment(commitment_tx_hu_conv);
  63                                 result: number = ret == null ? 0 : ret.clone_ptr();
  64                                 return result;
  65                                                 },
  66
  67                                                 validate_counterparty_revocation (idx: number, secret: Uint8Array): number {
  68                                                         Result_NoneNoneZ ret = arg.validate_counterparty_revocation(idx, secret);
  69                                 result: number = ret == null ? 0 : ret.clone_ptr();
  70                                 return result;
  71                                                 },
  72
  73                                                 sign_holder_commitment_and_htlcs (commitment_tx: number): number {
  74                                                         const commitment_tx_hu_conv: HolderCommitmentTransaction = new HolderCommitmentTransaction(null, commitment_tx);
  75                                                         Result_C2Tuple_SignatureCVec_SignatureZZNoneZ ret = arg.sign_holder_commitment_and_htlcs(commitment_tx_hu_conv);
  76                                 result: number = ret == null ? 0 : ret.clone_ptr();
  77                                 return result;
  78                                                 },
  79
  80                                                 sign_justice_revoked_output (justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array): number {
  81                                                         Result_SignatureNoneZ ret = arg.sign_justice_revoked_output(justice_tx, input, amount, per_commitment_key);
  82                                 result: number = ret == null ? 0 : ret.clone_ptr();
  83                                 return result;
  84                                                 },
  85
  86                                                 sign_justice_revoked_htlc (justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: number): number {
  87                                                         const htlc_hu_conv: HTLCOutputInCommitment = new HTLCOutputInCommitment(null, htlc);
  88                                                         Result_SignatureNoneZ ret = arg.sign_justice_revoked_htlc(justice_tx, input, amount, per_commitment_key, htlc_hu_conv);
  89                                 result: number = ret == null ? 0 : ret.clone_ptr();
  90                                 return result;
  91                                                 },
  92
  93                                                 sign_counterparty_htlc_transaction (htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: number): number {
  94                                                         const htlc_hu_conv: HTLCOutputInCommitment = new HTLCOutputInCommitment(null, htlc);
  95                                                         Result_SignatureNoneZ ret = arg.sign_counterparty_htlc_transaction(htlc_tx, input, amount, per_commitment_point, htlc_hu_conv);
  96                                 result: number = ret == null ? 0 : ret.clone_ptr();
  97                                 return result;
  98                                                 },
  99
 100                                                 sign_closing_transaction (closing_tx: number): number {
 101                                                         const closing_tx_hu_conv: ClosingTransaction = new ClosingTransaction(null, closing_tx);
 102                                                         Result_SignatureNoneZ ret = arg.sign_closing_transaction(closing_tx_hu_conv);
 103                                 result: number = ret == null ? 0 : ret.clone_ptr();
 104                                 return result;
 105                                                 },
 106
 107                                                 sign_channel_announcement (msg: number): number {
 108                                                         const msg_hu_conv: UnsignedChannelAnnouncement = new UnsignedChannelAnnouncement(null, msg);
 109                                                         Result_SignatureNoneZ ret = arg.sign_channel_announcement(msg_hu_conv);
 110                                 result: number = ret == null ? 0 : ret.clone_ptr();
 111                                 return result;
 112                                                 },
 113
 114                                                 ready_channel (channel_parameters: number): void {
 115                                                         const channel_parameters_hu_conv: ChannelTransactionParameters = new ChannelTransactionParameters(null, channel_parameters);
 116                                                         arg.ready_channel(channel_parameters_hu_conv);
 117                                                 },
 118
 119
 120                     };
 121                     impl_holder.held = new BaseSign (null, structImplementation, pubkeys);
 122                 }
 123             }
 124
 125             export interface BaseSignInterface {
 126                 get_per_commitment_point(idx: number): Uint8Array;
 127                                 release_commitment_secret(idx: number): Uint8Array;
 128                                 validate_holder_commitment(holder_tx: HolderCommitmentTransaction): Result_NoneNoneZ;
 129                                 channel_keys_id(): Uint8Array;
 130                                 sign_counterparty_commitment(commitment_tx: CommitmentTransaction): Result_C2Tuple_SignatureCVec_SignatureZZNoneZ;
 131                                 validate_counterparty_revocation(idx: number, secret: Uint8Array): Result_NoneNoneZ;
 132                                 sign_holder_commitment_and_htlcs(commitment_tx: HolderCommitmentTransaction): Result_C2Tuple_SignatureCVec_SignatureZZNoneZ;
 133                                 sign_justice_revoked_output(justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array): Result_SignatureNoneZ;
 134                                 sign_justice_revoked_htlc(justice_tx: Uint8Array, input: number, amount: number, per_commitment_key: Uint8Array, htlc: HTLCOutputInCommitment): Result_SignatureNoneZ;
 135                                 sign_counterparty_htlc_transaction(htlc_tx: Uint8Array, input: number, amount: number, per_commitment_point: Uint8Array, htlc: HTLCOutputInCommitment): Result_SignatureNoneZ;
 136                                 sign_closing_transaction(closing_tx: ClosingTransaction): Result_SignatureNoneZ;
 137                                 sign_channel_announcement(msg: UnsignedChannelAnnouncement): Result_SignatureNoneZ;
 138                                 ready_channel(channel_parameters: ChannelTransactionParameters): void;
 139
 140             }
 141
 142             class LDKBaseSignHolder {
 143                 held: BaseSign;
 144             }
 145         public Uint8Array get_per_commitment_point(number idx) {
 146                 Uint8Array ret = bindings.BaseSign_get_per_commitment_point(this.ptr, idx);
 147                 return ret;
 148         }
 149
 150         public Uint8Array release_commitment_secret(number idx) {
 151                 Uint8Array ret = bindings.BaseSign_release_commitment_secret(this.ptr, idx);
 152                 return ret;
 153         }
 154
 155         public Result_NoneNoneZ validate_holder_commitment(HolderCommitmentTransaction holder_tx) {
 156                 number ret = bindings.BaseSign_validate_holder_commitment(this.ptr, holder_tx == null ? 0 : holder_tx.ptr & ~1);
 157                 Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret);
 158                 this.ptrs_to.add(holder_tx);
 159                 return ret_hu_conv;
 160         }
 161
 162         public Uint8Array channel_keys_id() {
 163                 Uint8Array ret = bindings.BaseSign_channel_keys_id(this.ptr);
 164                 return ret;
 165         }
 166
 167         public Result_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment(CommitmentTransaction commitment_tx) {
 168                 number ret = bindings.BaseSign_sign_counterparty_commitment(this.ptr, commitment_tx == null ? 0 : commitment_tx.ptr & ~1);
 169                 Result_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_hu_conv = Result_C2Tuple_SignatureCVec_SignatureZZNoneZ.constr_from_ptr(ret);
 170                 this.ptrs_to.add(commitment_tx);
 171                 return ret_hu_conv;
 172         }
 173
 174         public Result_NoneNoneZ validate_counterparty_revocation(number idx, Uint8Array secret) {
 175                 number ret = bindings.BaseSign_validate_counterparty_revocation(this.ptr, idx, InternalUtils.check_arr_len(secret, 32));
 176                 Result_NoneNoneZ ret_hu_conv = Result_NoneNoneZ.constr_from_ptr(ret);
 177                 return ret_hu_conv;
 178         }
 179
 180         public Result_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs(HolderCommitmentTransaction commitment_tx) {
 181                 number ret = bindings.BaseSign_sign_holder_commitment_and_htlcs(this.ptr, commitment_tx == null ? 0 : commitment_tx.ptr & ~1);
 182                 Result_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_hu_conv = Result_C2Tuple_SignatureCVec_SignatureZZNoneZ.constr_from_ptr(ret);
 183                 this.ptrs_to.add(commitment_tx);
 184                 return ret_hu_conv;
 185         }
 186
 187         public Result_SignatureNoneZ sign_justice_revoked_output(Uint8Array justice_tx, number input, number amount, Uint8Array per_commitment_key) {
 188                 number ret = bindings.BaseSign_sign_justice_revoked_output(this.ptr, justice_tx, input, amount, InternalUtils.check_arr_len(per_commitment_key, 32));
 189                 Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
 190                 return ret_hu_conv;
 191         }
 192
 193         public Result_SignatureNoneZ sign_justice_revoked_htlc(Uint8Array justice_tx, number input, number amount, Uint8Array per_commitment_key, HTLCOutputInCommitment htlc) {
 194                 number ret = bindings.BaseSign_sign_justice_revoked_htlc(this.ptr, justice_tx, input, amount, InternalUtils.check_arr_len(per_commitment_key, 32), htlc == null ? 0 : htlc.ptr & ~1);
 195                 Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
 196                 this.ptrs_to.add(htlc);
 197                 return ret_hu_conv;
 198         }
 199
 200         public Result_SignatureNoneZ sign_counterparty_htlc_transaction(Uint8Array htlc_tx, number input, number amount, Uint8Array per_commitment_point, HTLCOutputInCommitment htlc) {
 201                 number ret = bindings.BaseSign_sign_counterparty_htlc_transaction(this.ptr, htlc_tx, input, amount, InternalUtils.check_arr_len(per_commitment_point, 33), htlc == null ? 0 : htlc.ptr & ~1);
 202                 Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
 203                 this.ptrs_to.add(htlc);
 204                 return ret_hu_conv;
 205         }
 206
 207         public Result_SignatureNoneZ sign_closing_transaction(ClosingTransaction closing_tx) {
 208                 number ret = bindings.BaseSign_sign_closing_transaction(this.ptr, closing_tx == null ? 0 : closing_tx.ptr & ~1);
 209                 Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
 210                 this.ptrs_to.add(closing_tx);
 211                 return ret_hu_conv;
 212         }
 213
 214         public Result_SignatureNoneZ sign_channel_announcement(UnsignedChannelAnnouncement msg) {
 215                 number ret = bindings.BaseSign_sign_channel_announcement(this.ptr, msg == null ? 0 : msg.ptr & ~1);
 216                 Result_SignatureNoneZ ret_hu_conv = Result_SignatureNoneZ.constr_from_ptr(ret);
 217                 this.ptrs_to.add(msg);
 218                 return ret_hu_conv;
 219         }
 220
 221         public void ready_channel(ChannelTransactionParameters channel_parameters) {
 222                 bindings.BaseSign_ready_channel(this.ptr, channel_parameters == null ? 0 : channel_parameters.ptr & ~1);
 223                 this.ptrs_to.add(channel_parameters);
 224         }
 225
 226         public ChannelPublicKeys get_pubkeys() {
 227                 number ret = bindings.BaseSign_get_pubkeys(this.ptr);
 228                 const ret_hu_conv: ChannelPublicKeys = new ChannelPublicKeys(null, ret);
 229                 ret_hu_conv.ptrs_to.add(this);
 230                 return ret_hu_conv;
 231         }
 232
 233 }