X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=ts%2Fstructs%2FKeysInterface.ts;h=46543e46aee58fa82a6aa638430ab057f6bbdfa6;hb=f3e670e9341decac613d33fc52febf19cea32f20;hp=b4e1b71d4d9b59dd7a472de8bee08da746ec38b6;hpb=822471992c6bf6f9985e531cc5940e4cc35e3e4c;p=ldk-java diff --git a/ts/structs/KeysInterface.ts b/ts/structs/KeysInterface.ts index b4e1b71d..46543e46 100644 --- a/ts/structs/KeysInterface.ts +++ b/ts/structs/KeysInterface.ts @@ -1,93 +1,137 @@ + import CommonBase from './CommonBase'; import * as bindings from '../bindings' // TODO: figure out location -public class KeysInterface extends CommonBase { - final bindings.LDKKeysInterface bindings_instance; - KeysInterface(Object _dummy, long ptr) { super(ptr); bindings_instance = null; } - private KeysInterface(bindings.LDKKeysInterface arg) { - super(bindings.LDKKeysInterface_new(arg)); - this.ptrs_to.add(arg); - this.bindings_instance = arg; - } - @Override @SuppressWarnings("deprecation") - protected void finalize() throws Throwable { - if (ptr != 0) { bindings.KeysInterface_free(ptr); } super.finalize(); - } - public static interface KeysInterfaceInterface { - byte[] get_node_secret(); - byte[] get_destination_script(); - byte[] get_shutdown_pubkey(); - ChannelKeys get_channel_keys(boolean inbound, long channel_value_satoshis); - byte[] get_secure_random_bytes(); - Result_ChanKeySignerDecodeErrorZ read_chan_signer(byte[] reader); - } - private static class LDKKeysInterfaceHolder { KeysInterface held; } - public static KeysInterface new_impl(KeysInterfaceInterface arg) { - final LDKKeysInterfaceHolder impl_holder = new LDKKeysInterfaceHolder(); - impl_holder.held = new KeysInterface(new bindings.LDKKeysInterface() { - @Override public byte[] get_node_secret() { - byte[] ret = arg.get_node_secret(); - return ret; - } - @Override public byte[] get_destination_script() { - byte[] ret = arg.get_destination_script(); - return ret; - } - @Override public byte[] get_shutdown_pubkey() { - byte[] ret = arg.get_shutdown_pubkey(); + + export class KeysInterface extends CommonBase { + + bindings_instance?: bindings.LDKKeysInterface; + + constructor(ptr?: number, arg?: bindings.LDKKeysInterface) { + if (Number.isFinite(ptr)) { + super(ptr); + this.bindings_instance = null; + } else { + // TODO: private constructor instantiation + super(bindings.LDKKeysInterface_new(arg)); + this.ptrs_to.push(arg); + + } + } + + protected finalize() { + if (this.ptr != 0) { + bindings.KeysInterface_free(this.ptr); + } + super.finalize(); + } + + static new_impl(arg: KeysInterfaceInterface): KeysInterface { + const impl_holder: LDKKeysInterfaceHolder = new LDKKeysInterfaceHolder(); + let structImplementation = { + // todo: in-line interface filling + get_node_secret (): Uint8Array { + Uint8Array ret = arg.get_node_secret(); + result: Uint8Array = InternalUtils.check_arr_len(ret, 32); + return result; + }, + + get_destination_script (): Uint8Array { + Uint8Array ret = arg.get_destination_script(); return ret; - } - @Override public uint32_t get_channel_keys(boolean inbound, long channel_value_satoshis) { - ChannelKeys ret = arg.get_channel_keys(inbound, channel_value_satoshis); - uint32_t result = ret == null ? 0 : ret.ptr; + }, + + get_shutdown_scriptpubkey (): number { + ShutdownScript ret = arg.get_shutdown_scriptpubkey(); + result: number = ret == null ? 0 : ret.clone_ptr(); + return result; + }, + + get_channel_signer (inbound: boolean, channel_value_satoshis: number): number { + Sign ret = arg.get_channel_signer(inbound, channel_value_satoshis); + result: number = ret == null ? 0 : ret.clone_ptr(); impl_holder.held.ptrs_to.add(ret); return result; - } - @Override public byte[] get_secure_random_bytes() { - byte[] ret = arg.get_secure_random_bytes(); - return ret; - } - @Override public uint32_t read_chan_signer(byte[] reader) { - Result_ChanKeySignerDecodeErrorZ ret = arg.read_chan_signer(reader); - uint32_t result = ret != null ? ret.ptr : 0; - ret.ptr = 0; + }, + + get_secure_random_bytes (): Uint8Array { + Uint8Array ret = arg.get_secure_random_bytes(); + result: Uint8Array = InternalUtils.check_arr_len(ret, 32); return result; - } - }); - return impl_holder.held; - } - public byte[] get_node_secret() { - byte[] ret = bindings.KeysInterface_get_node_secret(this.ptr); + }, + + read_chan_signer (reader: Uint8Array): number { + Result_SignDecodeErrorZ ret = arg.read_chan_signer(reader); + result: number = ret == null ? 0 : ret.clone_ptr(); + return result; + }, + + sign_invoice (invoice_preimage: Uint8Array): number { + Result_RecoverableSignatureNoneZ ret = arg.sign_invoice(invoice_preimage); + result: number = ret == null ? 0 : ret.clone_ptr(); + return result; + }, + + + }; + impl_holder.held = new KeysInterface (null, structImplementation); + } + } + + export interface KeysInterfaceInterface { + get_node_secret(): Uint8Array; + get_destination_script(): Uint8Array; + get_shutdown_scriptpubkey(): ShutdownScript; + get_channel_signer(inbound: boolean, channel_value_satoshis: number): Sign; + get_secure_random_bytes(): Uint8Array; + read_chan_signer(reader: Uint8Array): Result_SignDecodeErrorZ; + sign_invoice(invoice_preimage: Uint8Array): Result_RecoverableSignatureNoneZ; + + } + + class LDKKeysInterfaceHolder { + held: KeysInterface; + } + public Uint8Array get_node_secret() { + Uint8Array ret = bindings.KeysInterface_get_node_secret(this.ptr); return ret; } - public byte[] get_destination_script() { - byte[] ret = bindings.KeysInterface_get_destination_script(this.ptr); + public Uint8Array get_destination_script() { + Uint8Array ret = bindings.KeysInterface_get_destination_script(this.ptr); return ret; } - public byte[] get_shutdown_pubkey() { - byte[] ret = bindings.KeysInterface_get_shutdown_pubkey(this.ptr); - return ret; + public ShutdownScript get_shutdown_scriptpubkey() { + number ret = bindings.KeysInterface_get_shutdown_scriptpubkey(this.ptr); + const ret_hu_conv: ShutdownScript = new ShutdownScript(null, ret); + ret_hu_conv.ptrs_to.add(this); + return ret_hu_conv; } - public ChannelKeys get_channel_keys(boolean inbound, long channel_value_satoshis) { - uint32_t ret = bindings.KeysInterface_get_channel_keys(this.ptr, inbound, channel_value_satoshis); - ChannelKeys ret_hu_conv = new ChannelKeys(null, ret); + public Sign get_channel_signer(boolean inbound, number channel_value_satoshis) { + number ret = bindings.KeysInterface_get_channel_signer(this.ptr, inbound, channel_value_satoshis); + Sign ret_hu_conv = new Sign(null, ret); ret_hu_conv.ptrs_to.add(this); return ret_hu_conv; } - public byte[] get_secure_random_bytes() { - byte[] ret = bindings.KeysInterface_get_secure_random_bytes(this.ptr); + public Uint8Array get_secure_random_bytes() { + Uint8Array ret = bindings.KeysInterface_get_secure_random_bytes(this.ptr); return ret; } - public Result_ChanKeySignerDecodeErrorZ read_chan_signer(byte[] reader) { - uint32_t ret = bindings.KeysInterface_read_chan_signer(this.ptr, reader); - Result_ChanKeySignerDecodeErrorZ ret_hu_conv = Result_ChanKeySignerDecodeErrorZ.constr_from_ptr(ret); + public Result_SignDecodeErrorZ read_chan_signer(Uint8Array reader) { + number ret = bindings.KeysInterface_read_chan_signer(this.ptr, reader); + Result_SignDecodeErrorZ ret_hu_conv = Result_SignDecodeErrorZ.constr_from_ptr(ret); + return ret_hu_conv; + } + + public Result_RecoverableSignatureNoneZ sign_invoice(Uint8Array invoice_preimage) { + number ret = bindings.KeysInterface_sign_invoice(this.ptr, invoice_preimage); + Result_RecoverableSignatureNoneZ ret_hu_conv = Result_RecoverableSignatureNoneZ.constr_from_ptr(ret); return ret_hu_conv; }